// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::TabPage;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// A dynamic tabbed container.
    ///
    /// [`TabView`][crate::TabView] is a container which shows one child at a time. While it
    /// provides keyboard shortcuts for switching between pages, it does not provide
    /// a visible tab bar and relies on external widgets for that, such as
    /// [`TabBar`][crate::TabBar].
    ///
    /// [`TabView`][crate::TabView] maintains a [`TabPage`][crate::TabPage] object for each page,which holds
    /// additional per-page properties. You can obtain the [`TabPage`][crate::TabPage] for a page
    /// with [`page()`][Self::page()], and as return value for
    /// [`append()`][Self::append()] and other functions for adding children.
    ///
    /// [`TabView`][crate::TabView] only aims to be useful for dynamic tabs in multi-window
    /// document-based applications, such as web browsers, file managers, text
    /// editors or terminals. It does not aim to replace `Gtk::Notebook` for use
    /// cases such as tabbed dialogs.
    ///
    /// As such, it does not support disabling page reordering or detaching, or
    /// adding children via [`gtk::Buildable`][crate::gtk::Buildable].
    ///
    /// ## CSS nodes
    ///
    /// [`TabView`][crate::TabView] has a main CSS node with the name `tabview`.
    ///
    /// It contains the subnode overlay, which contains subnodes stack and widget.
    /// The stack subnode contains the added pages.
    ///
    /// ```text
    /// tabview
    /// ╰── overlay
    ///     ├── stack
    ///     │   ╰── [ Children ]
    ///     ╰── widget
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `default-icon`
    ///  Default page icon.
    ///
    /// If a page doesn't provide its own icon via [`icon`][struct@crate::TabPage#icon], default
    /// icon may be used instead for contexts where having an icon is necessary.
    ///
    /// [`TabBar`][crate::TabBar] will use default icon for pinned tabs in case the page is
    /// not loading, doesn't have an icon and an indicator. Default icon is never
    /// used for tabs that aren't pinned.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-transferring-page`
    ///  Whether a page is being transferred.
    ///
    /// This property will be set to `TRUE` when a drag-n-drop tab transfer starts
    /// on any [`TabView`][crate::TabView], and to `FALSE` after it ends.
    ///
    /// During the transfer, children cannot receive pointer input and a tab can be
    /// safely dropped on the tab view.
    ///
    /// Readable
    ///
    ///
    /// #### `menu-model`
    ///  Tab context menu model.
    ///
    /// When a context menu is shown for a tab, it will be constructed from the
    /// provided menu model. Use [`setup-menu`][struct@crate::TabView#setup-menu] signal to set up the
    /// menu actions for the particular tab.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `n-pages`
    ///  The number of pages in the tab view.
    ///
    /// Readable
    ///
    ///
    /// #### `n-pinned-pages`
    ///  The number of pinned pages in the tab view.
    ///
    /// See [`TabView::set_page_pinned()`][crate::TabView::set_page_pinned()].
    ///
    /// Readable
    ///
    ///
    /// #### `selected-page`
    ///  The currently selected page.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `shortcut-widget`
    ///  Tab shortcut widget.
    ///
    /// Has the following shortcuts:
    ///
    /// * <kbd>Ctrl</kbd>+<kbd>Page Up</kbd> - switch to the previous page
    /// * <kbd>Ctrl</kbd>+<kbd>Page Down</kbd> - switch to the next page
    /// * <kbd>Ctrl</kbd>+<kbd>Home</kbd> - switch to the first page
    /// * <kbd>Ctrl</kbd>+<kbd>End</kbd> - switch to the last page
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Page Up</kbd> - move the current page
    ///     backward
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Page Down</kbd> - move the current
    ///     page forward
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Home</kbd> - move the current page at
    ///     the start
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>End</kbd> - move the current page at
    ///      the end
    /// * <kbd>Ctrl</kbd>+<kbd>Tab</kbd> - switch to the next page, with looping
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Tab</kbd> - switch to the previous
    ///     page, with looping
    /// * <kbd>Alt</kbd>+<kbd>1</kbd>⋯<kbd>9</kbd> - switch to pages 1-9
    /// * <kbd>Alt</kbd>+<kbd>0</kbd> - switch to page 10
    ///
    /// These shortcuts are always available on @self_, this property is useful if
    /// they should be available globally.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Container</h4></summary>
    ///
    ///
    /// #### `border-width`
    ///  Readable | Writeable
    ///
    ///
    /// #### `child`
    ///  Writeable
    ///
    ///
    /// #### `resize-mode`
    ///  Readable | Writeable
    /// </details>
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `app-paintable`
    ///  Readable | Writeable
    ///
    ///
    /// #### `can-default`
    ///  Readable | Writeable
    ///
    ///
    /// #### `can-focus`
    ///  Readable | Writeable
    ///
    ///
    /// #### `composite-child`
    ///  Readable
    ///
    ///
    /// #### `double-buffered`
    ///  Whether the widget is double buffered.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `events`
    ///  Readable | Writeable
    ///
    ///
    /// #### `expand`
    ///  Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
    /// GtkComboBox) implemented this property individually.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space, see #GtkAlign
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-default`
    ///  Readable | Writeable
    ///
    ///
    /// #### `has-focus`
    ///  Readable | Writeable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of #GtkWidget::query-tooltip on @widget.
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using #GtkWidget::query-tooltip to determine
    /// whether it will provide a tooltip or not.
    ///
    /// Note that setting this property to [`true`] for the first time will change
    /// the event masks of the GdkWindows of this widget to include leave-notify
    /// and motion-notify events.  This cannot and will not be undone when the
    /// property is set to [`false`] again.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Readable | Writeable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally. See gtk_widget_set_hexpand().
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-focus`
    ///  Readable | Writeable
    ///
    ///
    /// #### `margin`
    ///  Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-end`
    ///  Margin on end of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-left`
    ///  Margin on left side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-right`
    ///  Margin on right side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-start`
    ///  Margin on start of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-top`
    ///  Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `name`
    ///  Readable | Writeable
    ///
    ///
    /// #### `no-show-all`
    ///  Readable | Writeable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget. See gtk_widget_set_opacity() for
    /// more details about window opacity.
    ///
    /// Before 3.8 this was only available in GtkWindow
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `parent`
    ///  Readable | Writeable
    ///
    ///
    /// #### `receives-default`
    ///  Readable | Writeable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget. See gtk_widget_get_scale_factor() for
    /// more details about widget scaling.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Readable | Writeable
    ///
    ///
    /// #### `style`
    ///  The style of the widget, which contains information about how it will look (colors, etc).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with the [Pango text markup language][PangoMarkupFormat].
    /// Also see gtk_tooltip_set_markup().
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: #GtkWidget:has-tooltip
    /// will automatically be set to [`true`] and there will be taken care of
    /// #GtkWidget::query-tooltip in the default signal handler.
    ///
    /// Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
    /// are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see gtk_tooltip_set_text().
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: #GtkWidget:has-tooltip
    /// will automatically be set to [`true`] and there will be taken care of
    /// #GtkWidget::query-tooltip in the default signal handler.
    ///
    /// Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
    /// are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space, see #GtkAlign
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically. See gtk_widget_set_vexpand().
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible`
    ///  Readable | Writeable
    ///
    ///
    /// #### `width-request`
    ///  Readable | Writeable
    ///
    ///
    /// #### `window`
    ///  The widget's window if it is realized, [`None`] otherwise.
    ///
    /// Readable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `close-page`
    ///  Emitted after [`TabView::close_page()`][crate::TabView::close_page()] has been called for @page.
    ///
    /// The handler is expected to call [`TabView::close_page_finish()`][crate::TabView::close_page_finish()] to
    /// confirm or reject the closing.
    ///
    /// The default handler will immediately confirm closing for non-pinned pages,
    /// or reject it for pinned pages, equivalent to the following example:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static gboolean
    /// close_page_cb (HdyTabView *view,
    ///                HdyTabPage *page,
    ///                gpointer    user_data)
    /// {
    ///   hdy_tab_view_close_page_finish (view, page, !hdy_tab_page_get_pinned (page));
    ///
    ///   return GDK_EVENT_STOP;
    /// }
    /// ```
    ///
    /// The [`TabView::close_page_finish()`][crate::TabView::close_page_finish()] doesn't have to happen during the
    /// handler, so can be used to do asynchronous checks before confirming the
    /// closing.
    ///
    /// A typical reason to connect to this signal is to show a confirmation dialog
    /// for closing a tab.
    ///
    ///
    ///
    ///
    /// #### `create-window`
    ///  Emitted when a tab should be transferred into a new window.
    ///
    /// This can happen after a tab has been dropped on desktop.
    ///
    /// The signal handler is expected to create a new window, position it as
    /// needed and return its [`TabView`][crate::TabView]that the page will be transferred into.
    ///
    ///
    ///
    ///
    /// #### `indicator-activated`
    ///  Emitted after the indicator icon on @page has been activated.
    ///
    /// See [`indicator-icon`][struct@crate::TabPage#indicator-icon] and
    /// [`indicator-activatable`][struct@crate::TabPage#indicator-activatable].
    ///
    ///
    ///
    ///
    /// #### `page-attached`
    ///  Emitted when a page has been created or transferred to the view.
    ///
    /// A typical reason to connect to this signal would be to connect to page
    /// signals for things such as updating window title.
    ///
    ///
    ///
    ///
    /// #### `page-detached`
    ///  Emitted when a page has been removed or transferred to another view.
    ///
    /// A typical reason to connect to this signal would be to disconnect signal
    /// handlers connected in the [`page-attached`][struct@crate::TabView#page-attached] handler.
    ///
    /// It is important not to try and destroy the page child in the handler of
    /// this function as the child might merely be moved to another window; use
    /// child dispose handler for that or do it in sync with your
    /// [`TabView::close_page_finish()`][crate::TabView::close_page_finish()] calls.
    ///
    ///
    ///
    ///
    /// #### `page-reordered`
    ///  This signal is emitted after @page has been reordered to @position.
    ///
    ///
    ///
    ///
    /// #### `setup-menu`
    ///  Emitted when a context menu is opened or closed for @page.
    ///
    /// If the menu has been closed, @page will be set to `NULL`.
    ///
    /// It can be used to set up menu actions before showing the menu, for example
    /// disable actions not applicable to @page.
    ///
    ///
    /// <details><summary><h4>Container</h4></summary>
    ///
    ///
    /// #### `add`
    ///
    ///
    ///
    /// #### `check-resize`
    ///
    ///
    ///
    /// #### `remove`
    ///
    ///
    ///
    /// #### `set-focus-child`
    ///
    /// </details>
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `accel-closures-changed`
    ///
    ///
    ///
    /// #### `button-press-event`
    ///  The ::button-press-event signal will be emitted when a button
    /// (typically from a mouse) is pressed.
    ///
    /// To receive this signal, the #GdkWindow associated to the
    /// widget needs to enable the #GDK_BUTTON_PRESS_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `button-release-event`
    ///  The ::button-release-event signal will be emitted when a button
    /// (typically from a mouse) is released.
    ///
    /// To receive this signal, the #GdkWindow associated to the
    /// widget needs to enable the #GDK_BUTTON_RELEASE_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `can-activate-accel`
    ///  Determines whether an accelerator that activates the signal
    /// identified by @signal_id can currently be activated.
    /// This signal is present to allow applications and derived
    /// widgets to override the default #GtkWidget handling
    /// for determining whether an accelerator can be activated.
    ///
    ///
    ///
    ///
    /// #### `child-notify`
    ///  The ::child-notify signal is emitted for each
    /// [child property][child-properties]  that has
    /// changed on an object. The signal's detail holds the property name.
    ///
    /// Detailed
    ///
    ///
    /// #### `composited-changed`
    ///  The ::composited-changed signal is emitted when the composited
    /// status of @widgets screen changes.
    /// See gdk_screen_is_composited().
    ///
    /// Action
    ///
    ///
    /// #### `configure-event`
    ///  The ::configure-event signal will be emitted when the size, position or
    /// stacking of the @widget's window has changed.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `damage-event`
    ///  Emitted when a redirected window belonging to @widget gets drawn into.
    /// The region/area members of the event shows what area of the redirected
    /// drawable was drawn into.
    ///
    ///
    ///
    ///
    /// #### `delete-event`
    ///  The ::delete-event signal is emitted if a user requests that
    /// a toplevel window is closed. The default handler for this signal
    /// destroys the window. Connecting gtk_widget_hide_on_delete() to
    /// this signal will cause the window to be hidden instead, so that
    /// it can later be shown again without reconstructing it.
    ///
    ///
    ///
    ///
    /// #### `destroy`
    ///  Signals that all holders of a reference to the widget should release
    /// the reference that they hold. May result in finalization of the widget
    /// if all references are released.
    ///
    /// This signal is not suitable for saving widget state.
    ///
    ///
    ///
    ///
    /// #### `destroy-event`
    ///  The ::destroy-event signal is emitted when a #GdkWindow is destroyed.
    /// You rarely get this signal, because most widgets disconnect themselves
    /// from their window before they destroy it, so no widget owns the
    /// window at destroy time.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `direction-changed`
    ///  The ::direction-changed signal is emitted when the text direction
    /// of a widget changes.
    ///
    ///
    ///
    ///
    /// #### `drag-begin`
    ///  The ::drag-begin signal is emitted on the drag source when a drag is
    /// started. A typical reason to connect to this signal is to set up a
    /// custom drag icon with e.g. gtk_drag_source_set_icon_pixbuf().
    ///
    /// Note that some widgets set up a drag icon in the default handler of
    /// this signal, so you may have to use g_signal_connect_after() to
    /// override what the default handler did.
    ///
    ///
    ///
    ///
    /// #### `drag-data-delete`
    ///  The ::drag-data-delete signal is emitted on the drag source when a drag
    /// with the action `GDK_ACTION_MOVE` is successfully completed. The signal
    /// handler is responsible for deleting the data that has been dropped. What
    /// "delete" means depends on the context of the drag operation.
    ///
    ///
    ///
    ///
    /// #### `drag-data-get`
    ///  The ::drag-data-get signal is emitted on the drag source when the drop
    /// site requests the data which is dragged. It is the responsibility of
    /// the signal handler to fill @data with the data in the format which
    /// is indicated by @info. See gtk_selection_data_set() and
    /// gtk_selection_data_set_text().
    ///
    ///
    ///
    ///
    /// #### `drag-data-received`
    ///  The ::drag-data-received signal is emitted on the drop site when the
    /// dragged data has been received. If the data was received in order to
    /// determine whether the drop will be accepted, the handler is expected
    /// to call gdk_drag_status() and not finish the drag.
    /// If the data was received in response to a #GtkWidget::drag-drop signal
    /// (and this is the last target to be received), the handler for this
    /// signal is expected to process the received data and then call
    /// gtk_drag_finish(), setting the @success parameter depending on
    /// whether the data was processed successfully.
    ///
    /// Applications must create some means to determine why the signal was emitted
    /// and therefore whether to call gdk_drag_status() or gtk_drag_finish().
    ///
    /// The handler may inspect the selected action with
    /// gdk_drag_context_get_selected_action() before calling
    /// gtk_drag_finish(), e.g. to implement `GDK_ACTION_ASK` as
    /// shown in the following example:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// void
    /// drag_data_received (GtkWidget          *widget,
    ///                     GdkDragContext     *context,
    ///                     gint                x,
    ///                     gint                y,
    ///                     GtkSelectionData   *data,
    ///                     guint               info,
    ///                     guint               time)
    /// {
    ///   if ((data->length >= 0) && (data->format == 8))
    ///     {
    ///       GdkDragAction action;
    ///
    ///       // handle data here
    ///
    ///       action = gdk_drag_context_get_selected_action (context);
    ///       if (action == GDK_ACTION_ASK)
    ///         {
    ///           GtkWidget *dialog;
    ///           gint response;
    ///
    ///           dialog = gtk_message_dialog_new (NULL,
    ///                                            GTK_DIALOG_MODAL |
    ///                                            GTK_DIALOG_DESTROY_WITH_PARENT,
    ///                                            GTK_MESSAGE_INFO,
    ///                                            GTK_BUTTONS_YES_NO,
    ///                                            "Move the data ?\n");
    ///           response = gtk_dialog_run (GTK_DIALOG (dialog));
    ///           gtk_widget_destroy (dialog);
    ///
    ///           if (response == GTK_RESPONSE_YES)
    ///             action = GDK_ACTION_MOVE;
    ///           else
    ///             action = GDK_ACTION_COPY;
    ///          }
    ///
    ///       gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time);
    ///     }
    ///   else
    ///     gtk_drag_finish (context, FALSE, FALSE, time);
    ///  }
    /// ```
    ///
    ///
    ///
    ///
    /// #### `drag-drop`
    ///  The ::drag-drop signal is emitted on the drop site when the user drops
    /// the data onto the widget. The signal handler must determine whether
    /// the cursor position is in a drop zone or not. If it is not in a drop
    /// zone, it returns [`false`] and no further processing is necessary.
    /// Otherwise, the handler returns [`true`]. In this case, the handler must
    /// ensure that gtk_drag_finish() is called to let the source know that
    /// the drop is done. The call to gtk_drag_finish() can be done either
    /// directly or in a #GtkWidget::drag-data-received handler which gets
    /// triggered by calling gtk_drag_get_data() to receive the data for one
    /// or more of the supported targets.
    ///
    ///
    ///
    ///
    /// #### `drag-end`
    ///  The ::drag-end signal is emitted on the drag source when a drag is
    /// finished.  A typical reason to connect to this signal is to undo
    /// things done in #GtkWidget::drag-begin.
    ///
    ///
    ///
    ///
    /// #### `drag-failed`
    ///  The ::drag-failed signal is emitted on the drag source when a drag has
    /// failed. The signal handler may hook custom code to handle a failed DnD
    /// operation based on the type of error, it returns [`true`] is the failure has
    /// been already handled (not showing the default "drag operation failed"
    /// animation), otherwise it returns [`false`].
    ///
    ///
    ///
    ///
    /// #### `drag-leave`
    ///  The ::drag-leave signal is emitted on the drop site when the cursor
    /// leaves the widget. A typical reason to connect to this signal is to
    /// undo things done in #GtkWidget::drag-motion, e.g. undo highlighting
    /// with gtk_drag_unhighlight().
    ///
    ///
    /// Likewise, the #GtkWidget::drag-leave signal is also emitted before the
    /// ::drag-drop signal, for instance to allow cleaning up of a preview item
    /// created in the #GtkWidget::drag-motion signal handler.
    ///
    ///
    ///
    ///
    /// #### `drag-motion`
    ///  The ::drag-motion signal is emitted on the drop site when the user
    /// moves the cursor over the widget during a drag. The signal handler
    /// must determine whether the cursor position is in a drop zone or not.
    /// If it is not in a drop zone, it returns [`false`] and no further processing
    /// is necessary. Otherwise, the handler returns [`true`]. In this case, the
    /// handler is responsible for providing the necessary information for
    /// displaying feedback to the user, by calling gdk_drag_status().
    ///
    /// If the decision whether the drop will be accepted or rejected can't be
    /// made based solely on the cursor position and the type of the data, the
    /// handler may inspect the dragged data by calling gtk_drag_get_data() and
    /// defer the gdk_drag_status() call to the #GtkWidget::drag-data-received
    /// handler. Note that you must pass #GTK_DEST_DEFAULT_DROP,
    /// #GTK_DEST_DEFAULT_MOTION or #GTK_DEST_DEFAULT_ALL to gtk_drag_dest_set()
    /// when using the drag-motion signal that way.
    ///
    /// Also note that there is no drag-enter signal. The drag receiver has to
    /// keep track of whether he has received any drag-motion signals since the
    /// last #GtkWidget::drag-leave and if not, treat the drag-motion signal as
    /// an "enter" signal. Upon an "enter", the handler will typically highlight
    /// the drop site with gtk_drag_highlight().
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static void
    /// drag_motion (GtkWidget      *widget,
    ///              GdkDragContext *context,
    ///              gint            x,
    ///              gint            y,
    ///              guint           time)
    /// {
    ///   GdkAtom target;
    ///
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (!private_data->drag_highlight)
    ///    {
    ///      private_data->drag_highlight = 1;
    ///      gtk_drag_highlight (widget);
    ///    }
    ///
    ///   target = gtk_drag_dest_find_target (widget, context, NULL);
    ///   if (target == GDK_NONE)
    ///     gdk_drag_status (context, 0, time);
    ///   else
    ///    {
    ///      private_data->pending_status
    ///         = gdk_drag_context_get_suggested_action (context);
    ///      gtk_drag_get_data (widget, context, target, time);
    ///    }
    ///
    ///   return TRUE;
    /// }
    ///
    /// static void
    /// drag_data_received (GtkWidget        *widget,
    ///                     GdkDragContext   *context,
    ///                     gint              x,
    ///                     gint              y,
    ///                     GtkSelectionData *selection_data,
    ///                     guint             info,
    ///                     guint             time)
    /// {
    ///   PrivateData *private_data = GET_PRIVATE_DATA (widget);
    ///
    ///   if (private_data->suggested_action)
    ///    {
    ///      private_data->suggested_action = 0;
    ///
    ///      // We are getting this data due to a request in drag_motion,
    ///      // rather than due to a request in drag_drop, so we are just
    ///      // supposed to call gdk_drag_status(), not actually paste in
    ///      // the data.
    ///
    ///      str = gtk_selection_data_get_text (selection_data);
    ///      if (!data_is_acceptable (str))
    ///        gdk_drag_status (context, 0, time);
    ///      else
    ///        gdk_drag_status (context,
    ///                         private_data->suggested_action,
    ///                         time);
    ///    }
    ///   else
    ///    {
    ///      // accept the drop
    ///    }
    /// }
    /// ```
    ///
    ///
    ///
    ///
    /// #### `draw`
    ///  This signal is emitted when a widget is supposed to render itself.
    /// The @widget's top left corner must be painted at the origin of
    /// the passed in context and be sized to the values returned by
    /// gtk_widget_get_allocated_width() and
    /// gtk_widget_get_allocated_height().
    ///
    /// Signal handlers connected to this signal can modify the cairo
    /// context passed as @cr in any way they like and don't need to
    /// restore it. The signal emission takes care of calling cairo_save()
    /// before and cairo_restore() after invoking the handler.
    ///
    /// The signal handler will get a @cr with a clip region already set to the
    /// widget's dirty region, i.e. to the area that needs repainting.  Complicated
    /// widgets that want to avoid redrawing themselves completely can get the full
    /// extents of the clip region with gdk_cairo_get_clip_rectangle(), or they can
    /// get a finer-grained representation of the dirty region with
    /// cairo_copy_clip_rectangle_list().
    ///
    ///
    ///
    ///
    /// #### `enter-notify-event`
    ///  The ::enter-notify-event will be emitted when the pointer enters
    /// the @widget's window.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_ENTER_NOTIFY_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `event`
    ///  The GTK+ main loop will emit three signals for each GDK event delivered
    /// to a widget: one generic ::event signal, another, more specific,
    /// signal that matches the type of event delivered (e.g.
    /// #GtkWidget::key-press-event) and finally a generic
    /// #GtkWidget::event-after signal.
    ///
    ///
    ///
    ///
    /// #### `event-after`
    ///  After the emission of the #GtkWidget::event signal and (optionally)
    /// the second more specific signal, ::event-after will be emitted
    /// regardless of the previous two signals handlers return values.
    ///
    ///
    ///
    ///
    /// #### `focus`
    ///
    ///
    ///
    /// #### `focus-in-event`
    ///  The ::focus-in-event signal will be emitted when the keyboard focus
    /// enters the @widget's window.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_FOCUS_CHANGE_MASK mask.
    ///
    ///
    ///
    ///
    /// #### `focus-out-event`
    ///  The ::focus-out-event signal will be emitted when the keyboard focus
    /// leaves the @widget's window.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_FOCUS_CHANGE_MASK mask.
    ///
    ///
    ///
    ///
    /// #### `grab-broken-event`
    ///  Emitted when a pointer or keyboard grab on a window belonging
    /// to @widget gets broken.
    ///
    /// On X11, this happens when the grab window becomes unviewable
    /// (i.e. it or one of its ancestors is unmapped), or if the same
    /// application grabs the pointer or keyboard again.
    ///
    ///
    ///
    ///
    /// #### `grab-focus`
    ///  Action
    ///
    ///
    /// #### `grab-notify`
    ///  The ::grab-notify signal is emitted when a widget becomes
    /// shadowed by a GTK+ grab (not a pointer or keyboard grab) on
    /// another widget, or when it becomes unshadowed due to a grab
    /// being removed.
    ///
    /// A widget is shadowed by a gtk_grab_add() when the topmost
    /// grab widget in the grab stack of its window group is not
    /// its ancestor.
    ///
    ///
    ///
    ///
    /// #### `hide`
    ///  The ::hide signal is emitted when @widget is hidden, for example with
    /// gtk_widget_hide().
    ///
    ///
    ///
    ///
    /// #### `hierarchy-changed`
    ///  The ::hierarchy-changed signal is emitted when the
    /// anchored state of a widget changes. A widget is
    /// “anchored” when its toplevel
    /// ancestor is a #GtkWindow. This signal is emitted when
    /// a widget changes from un-anchored to anchored or vice-versa.
    ///
    ///
    ///
    ///
    /// #### `key-press-event`
    ///  The ::key-press-event signal is emitted when a key is pressed. The signal
    /// emission will reoccur at the key-repeat rate when the key is kept pressed.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_KEY_PRESS_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `key-release-event`
    ///  The ::key-release-event signal is emitted when a key is released.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_KEY_RELEASE_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `keynav-failed`
    ///  Gets emitted if keyboard navigation fails.
    /// See gtk_widget_keynav_failed() for details.
    ///
    ///
    ///
    ///
    /// #### `leave-notify-event`
    ///  The ::leave-notify-event will be emitted when the pointer leaves
    /// the @widget's window.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_LEAVE_NOTIFY_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `map`
    ///  The ::map signal is emitted when @widget is going to be mapped, that is
    /// when the widget is visible (which is controlled with
    /// gtk_widget_set_visible()) and all its parents up to the toplevel widget
    /// are also visible. Once the map has occurred, #GtkWidget::map-event will
    /// be emitted.
    ///
    /// The ::map signal can be used to determine whether a widget will be drawn,
    /// for instance it can resume an animation that was stopped during the
    /// emission of #GtkWidget::unmap.
    ///
    ///
    ///
    ///
    /// #### `map-event`
    ///  The ::map-event signal will be emitted when the @widget's window is
    /// mapped. A window is mapped when it becomes visible on the screen.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `mnemonic-activate`
    ///  The default handler for this signal activates @widget if @group_cycling
    /// is [`false`], or just makes @widget grab focus if @group_cycling is [`true`].
    ///
    ///
    ///
    ///
    /// #### `motion-notify-event`
    ///  The ::motion-notify-event signal is emitted when the pointer moves
    /// over the widget's #GdkWindow.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget
    /// needs to enable the #GDK_POINTER_MOTION_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `move-focus`
    ///  Action
    ///
    ///
    /// #### `parent-set`
    ///  The ::parent-set signal is emitted when a new parent
    /// has been set on a widget.
    ///
    ///
    ///
    ///
    /// #### `popup-menu`
    ///  This signal gets emitted whenever a widget should pop up a context
    /// menu. This usually happens through the standard key binding mechanism;
    /// by pressing a certain key while a widget is focused, the user can cause
    /// the widget to pop up a menu.  For example, the #GtkEntry widget creates
    /// a menu with clipboard commands. See the
    /// [Popup Menu Migration Checklist][checklist-popup-menu]
    /// for an example of how to use this signal.
    ///
    /// Action
    ///
    ///
    /// #### `property-notify-event`
    ///  The ::property-notify-event signal will be emitted when a property on
    /// the @widget's window has been changed or deleted.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_PROPERTY_CHANGE_MASK mask.
    ///
    ///
    ///
    ///
    /// #### `proximity-in-event`
    ///  To receive this signal the #GdkWindow associated to the widget needs
    /// to enable the #GDK_PROXIMITY_IN_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `proximity-out-event`
    ///  To receive this signal the #GdkWindow associated to the widget needs
    /// to enable the #GDK_PROXIMITY_OUT_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `query-tooltip`
    ///  Emitted when #GtkWidget:has-tooltip is [`true`] and the hover timeout
    /// has expired with the cursor hovering "above" @widget; or emitted when @widget got
    /// focus in keyboard mode.
    ///
    /// Using the given coordinates, the signal handler should determine
    /// whether a tooltip should be shown for @widget. If this is the case
    /// [`true`] should be returned, [`false`] otherwise.  Note that if
    /// @keyboard_mode is [`true`], the values of @x and @y are undefined and
    /// should not be used.
    ///
    /// The signal handler is free to manipulate @tooltip with the therefore
    /// destined function calls.
    ///
    ///
    ///
    ///
    /// #### `realize`
    ///  The ::realize signal is emitted when @widget is associated with a
    /// #GdkWindow, which means that gtk_widget_realize() has been called or the
    /// widget has been mapped (that is, it is going to be drawn).
    ///
    ///
    ///
    ///
    /// #### `screen-changed`
    ///  The ::screen-changed signal gets emitted when the
    /// screen of a widget has changed.
    ///
    ///
    ///
    ///
    /// #### `scroll-event`
    ///  The ::scroll-event signal is emitted when a button in the 4 to 7
    /// range is pressed. Wheel mice are usually configured to generate
    /// button press events for buttons 4 and 5 when the wheel is turned.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_SCROLL_MASK mask.
    ///
    /// This signal will be sent to the grab widget if there is one.
    ///
    ///
    ///
    ///
    /// #### `selection-clear-event`
    ///  The ::selection-clear-event signal will be emitted when the
    /// the @widget's window has lost ownership of a selection.
    ///
    ///
    ///
    ///
    /// #### `selection-get`
    ///
    ///
    ///
    /// #### `selection-notify-event`
    ///
    ///
    ///
    /// #### `selection-received`
    ///
    ///
    ///
    /// #### `selection-request-event`
    ///  The ::selection-request-event signal will be emitted when
    /// another client requests ownership of the selection owned by
    /// the @widget's window.
    ///
    ///
    ///
    ///
    /// #### `show`
    ///  The ::show signal is emitted when @widget is shown, for example with
    /// gtk_widget_show().
    ///
    ///
    ///
    ///
    /// #### `show-help`
    ///  Action
    ///
    ///
    /// #### `size-allocate`
    ///
    ///
    ///
    /// #### `state-changed`
    ///  The ::state-changed signal is emitted when the widget state changes.
    /// See gtk_widget_get_state().
    ///
    ///
    ///
    ///
    /// #### `state-flags-changed`
    ///  The ::state-flags-changed signal is emitted when the widget state
    /// changes, see gtk_widget_get_state_flags().
    ///
    ///
    ///
    ///
    /// #### `style-set`
    ///  The ::style-set signal is emitted when a new style has been set
    /// on a widget. Note that style-modifying functions like
    /// gtk_widget_modify_base() also cause this signal to be emitted.
    ///
    /// Note that this signal is emitted for changes to the deprecated
    /// #GtkStyle. To track changes to the #GtkStyleContext associated
    /// with a widget, use the #GtkWidget::style-updated signal.
    ///
    ///
    ///
    ///
    /// #### `style-updated`
    ///  The ::style-updated signal is a convenience signal that is emitted when the
    /// #GtkStyleContext::changed signal is emitted on the @widget's associated
    /// #GtkStyleContext as returned by gtk_widget_get_style_context().
    ///
    /// Note that style-modifying functions like gtk_widget_override_color() also
    /// cause this signal to be emitted.
    ///
    ///
    ///
    ///
    /// #### `touch-event`
    ///
    ///
    ///
    /// #### `unmap`
    ///  The ::unmap signal is emitted when @widget is going to be unmapped, which
    /// means that either it or any of its parents up to the toplevel widget have
    /// been set as hidden.
    ///
    /// As ::unmap indicates that a widget will not be shown any longer, it can be
    /// used to, for example, stop an animation on the widget.
    ///
    ///
    ///
    ///
    /// #### `unmap-event`
    ///  The ::unmap-event signal will be emitted when the @widget's window is
    /// unmapped. A window is unmapped when it becomes invisible on the screen.
    ///
    /// To receive this signal, the #GdkWindow associated to the widget needs
    /// to enable the #GDK_STRUCTURE_MASK mask. GDK will enable this mask
    /// automatically for all new windows.
    ///
    ///
    ///
    ///
    /// #### `unrealize`
    ///  The ::unrealize signal is emitted when the #GdkWindow associated with
    /// @widget is destroyed, which means that gtk_widget_unrealize() has been
    /// called or the widget has been unmapped (that is, it is going to be
    /// hidden).
    ///
    ///
    ///
    ///
    /// #### `visibility-notify-event`
    ///  The ::visibility-notify-event will be emitted when the @widget's
    /// window is obscured or unobscured.
    ///
    /// To receive this signal the #GdkWindow associated to the widget needs
    /// to enable the #GDK_VISIBILITY_NOTIFY_MASK mask.
    ///
    ///
    ///
    ///
    /// #### `window-state-event`
    ///  The ::window-state-event will be emitted when the state of the
    /// toplevel window associated to the @widget changes.
    ///
    /// To receive this signal the #GdkWindow associated to the widget
    /// needs to enable the #GDK_STRUCTURE_MASK mask. GDK will enable
    /// this mask automatically for all new windows.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`trait@gtk::prelude::BinExt`], [`trait@gtk::prelude::ContainerExt`], [`trait@gtk::prelude::WidgetExt`], [`trait@glib::ObjectExt`], [`trait@gtk::prelude::BuildableExt`]
    #[doc(alias = "HdyTabView")]
    pub struct TabView(Object<ffi::HdyTabView, ffi::HdyTabViewClass>) @extends gtk::Bin, gtk::Container, gtk::Widget, @implements gtk::Buildable;

    match fn {
        type_ => || ffi::hdy_tab_view_get_type(),
    }
}

impl TabView {
    /// Creates a new [`TabView`][crate::TabView].
    ///
    /// # Returns
    ///
    /// the newly created [`TabView`][crate::TabView]
    #[doc(alias = "hdy_tab_view_new")]
    pub fn new() -> TabView {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::hdy_tab_view_new()) }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`TabView`] objects.
    ///
    /// This method returns an instance of [`TabViewBuilder`](crate::builders::TabViewBuilder) which can be used to create [`TabView`] objects.
    pub fn builder() -> TabViewBuilder {
        TabViewBuilder::new()
    }

    /// Adds @child to @self with @parent as the parent.
    ///
    /// This function can be used to automatically position new pages, and to select
    /// the correct page when this page is closed while being selected (see
    /// [`close_page()`][Self::close_page()].
    ///
    /// If @parent is `NULL`, this function is equivalent to [`append()`][Self::append()].
    /// ## `child`
    /// a widget to add
    /// ## `parent`
    /// a parent page for @child
    ///
    /// # Returns
    ///
    /// the page object representing @child
    #[doc(alias = "hdy_tab_view_add_page")]
    pub fn add_page(
        &self,
        child: &impl IsA<gtk::Widget>,
        parent: Option<&TabPage>,
    ) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_add_page(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                parent.to_glib_none().0,
            ))
        }
    }

    /// Inserts @child as the last non-pinned page.
    /// ## `child`
    /// a widget to add
    ///
    /// # Returns
    ///
    /// the page object representing @child
    #[doc(alias = "hdy_tab_view_append")]
    pub fn append(&self, child: &impl IsA<gtk::Widget>) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_append(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Inserts @child as the last pinned page.
    /// ## `child`
    /// a widget to add
    ///
    /// # Returns
    ///
    /// the page object representing @child
    #[doc(alias = "hdy_tab_view_append_pinned")]
    pub fn append_pinned(&self, child: &impl IsA<gtk::Widget>) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_append_pinned(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Requests to close all pages other than @page.
    /// ## `page`
    /// a page of @self
    #[doc(alias = "hdy_tab_view_close_other_pages")]
    pub fn close_other_pages(&self, page: &TabPage) {
        unsafe {
            ffi::hdy_tab_view_close_other_pages(self.to_glib_none().0, page.to_glib_none().0);
        }
    }

    /// Requests to close @page.
    ///
    /// Calling this function will result in [`close-page`][struct@crate::TabView#close-page] signal
    /// being emitted for @page. Closing the page can then be confirmed or denied via
    /// [`close_page_finish()`][Self::close_page_finish()].
    ///
    /// If the page is waiting for a [`close_page_finish()`][Self::close_page_finish()] call, this
    /// function will do nothing.
    ///
    /// The default handler for [`close-page`][struct@crate::TabView#close-page] will immediately confirm
    /// closing the page if it's non-pinned, or reject it if it's pinned. This
    /// behavior can be changed by registering your own handler for that signal.
    ///
    /// If @page was selected, another page will be selected instead:
    ///
    /// If the [`parent`][struct@crate::TabPage#parent] value is `NULL`, the next page will be
    /// selected when possible, or if the page was already last, the previous page
    /// will be selected instead.
    ///
    /// If it's not `NULL`, the previous page will be selected if it's a descendant
    /// (possibly indirect) of the parent. If both the previous page and the parent
    /// are pinned, the parent will be selected instead.
    /// ## `page`
    /// a page of @self
    #[doc(alias = "hdy_tab_view_close_page")]
    pub fn close_page(&self, page: &TabPage) {
        unsafe {
            ffi::hdy_tab_view_close_page(self.to_glib_none().0, page.to_glib_none().0);
        }
    }

    /// Completes a [`close_page()`][Self::close_page()] call for @page.
    ///
    /// If @confirm is `TRUE`, @page will be closed. If it's `FALSE`, ite will be
    /// reverted to its previous state and [`close_page()`][Self::close_page()] can be called
    /// for it again.
    ///
    /// This function should not be called unless a custom handler for
    /// [`close-page`][struct@crate::TabView#close-page] is used.
    /// ## `page`
    /// a page of @self
    /// ## `confirm`
    /// whether to confirm or deny closing @page
    #[doc(alias = "hdy_tab_view_close_page_finish")]
    pub fn close_page_finish(&self, page: &TabPage, confirm: bool) {
        unsafe {
            ffi::hdy_tab_view_close_page_finish(
                self.to_glib_none().0,
                page.to_glib_none().0,
                confirm.into_glib(),
            );
        }
    }

    /// Requests to close all pages after @page.
    /// ## `page`
    /// a page of @self
    #[doc(alias = "hdy_tab_view_close_pages_after")]
    pub fn close_pages_after(&self, page: &TabPage) {
        unsafe {
            ffi::hdy_tab_view_close_pages_after(self.to_glib_none().0, page.to_glib_none().0);
        }
    }

    /// Requests to close all pages before @page.
    /// ## `page`
    /// a page of @self
    #[doc(alias = "hdy_tab_view_close_pages_before")]
    pub fn close_pages_before(&self, page: &TabPage) {
        unsafe {
            ffi::hdy_tab_view_close_pages_before(self.to_glib_none().0, page.to_glib_none().0);
        }
    }

    /// Gets default icon of @self.
    ///
    /// # Returns
    ///
    /// the default icon of @self
    #[doc(alias = "hdy_tab_view_get_default_icon")]
    #[doc(alias = "get_default_icon")]
    pub fn default_icon(&self) -> Option<gio::Icon> {
        unsafe { from_glib_none(ffi::hdy_tab_view_get_default_icon(self.to_glib_none().0)) }
    }

    /// Whether a page is being transferred.
    ///
    /// Gets the value of [`is-transferring-page`][struct@crate::TabView#is-transferring-page] property.
    ///
    /// # Returns
    ///
    /// whether a page is being transferred
    #[doc(alias = "hdy_tab_view_get_is_transferring_page")]
    #[doc(alias = "get_is_transferring_page")]
    pub fn is_transferring_page(&self) -> bool {
        unsafe {
            from_glib(ffi::hdy_tab_view_get_is_transferring_page(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the tab context menu model for @self.
    ///
    /// # Returns
    ///
    /// the tab context menu model for @self
    #[doc(alias = "hdy_tab_view_get_menu_model")]
    #[doc(alias = "get_menu_model")]
    pub fn menu_model(&self) -> Option<gio::MenuModel> {
        unsafe { from_glib_none(ffi::hdy_tab_view_get_menu_model(self.to_glib_none().0)) }
    }

    /// Gets the number of pages in @self.
    ///
    /// # Returns
    ///
    /// the number of pages in @self
    #[doc(alias = "hdy_tab_view_get_n_pages")]
    #[doc(alias = "get_n_pages")]
    pub fn n_pages(&self) -> i32 {
        unsafe { ffi::hdy_tab_view_get_n_pages(self.to_glib_none().0) }
    }

    /// Gets the number of pinned pages in @self.
    ///
    /// See [`set_page_pinned()`][Self::set_page_pinned()].
    ///
    /// # Returns
    ///
    /// the number of pinned pages in @self
    #[doc(alias = "hdy_tab_view_get_n_pinned_pages")]
    #[doc(alias = "get_n_pinned_pages")]
    pub fn n_pinned_pages(&self) -> i32 {
        unsafe { ffi::hdy_tab_view_get_n_pinned_pages(self.to_glib_none().0) }
    }

    /// Gets the [`TabPage`][crate::TabPage] representing the child at @position.
    /// ## `position`
    /// the index of the page in @self, starting from 0
    ///
    /// # Returns
    ///
    /// the page object at @position
    #[doc(alias = "hdy_tab_view_get_nth_page")]
    #[doc(alias = "get_nth_page")]
    pub fn nth_page(&self, position: i32) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_get_nth_page(
                self.to_glib_none().0,
                position,
            ))
        }
    }

    /// Gets the [`TabPage`][crate::TabPage] object representing @child.
    /// ## `child`
    /// a child in @self
    ///
    /// # Returns
    ///
    /// the [`TabPage`][crate::TabPage] representing @child
    #[doc(alias = "hdy_tab_view_get_page")]
    #[doc(alias = "get_page")]
    pub fn page(&self, child: &impl IsA<gtk::Widget>) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_get_page(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Finds the position of @page in @self, starting from 0.
    /// ## `page`
    /// a page of @self
    ///
    /// # Returns
    ///
    /// the position of @page in @self
    #[doc(alias = "hdy_tab_view_get_page_position")]
    #[doc(alias = "get_page_position")]
    pub fn page_position(&self, page: &TabPage) -> i32 {
        unsafe { ffi::hdy_tab_view_get_page_position(self.to_glib_none().0, page.to_glib_none().0) }
    }

    /// Returns a [`gio::ListModel`][crate::gio::ListModel] containing the pages of @self.
    ///
    /// This model can be used to keep an up to date view of the pages.
    ///
    /// # Returns
    ///
    /// the model containing pages of @self
    #[doc(alias = "hdy_tab_view_get_pages")]
    #[doc(alias = "get_pages")]
    pub fn pages(&self) -> Option<gio::ListModel> {
        unsafe { from_glib_none(ffi::hdy_tab_view_get_pages(self.to_glib_none().0)) }
    }

    /// Gets the currently selected page in @self.
    ///
    /// # Returns
    ///
    /// the selected page in @self
    #[doc(alias = "hdy_tab_view_get_selected_page")]
    #[doc(alias = "get_selected_page")]
    pub fn selected_page(&self) -> Option<TabPage> {
        unsafe { from_glib_none(ffi::hdy_tab_view_get_selected_page(self.to_glib_none().0)) }
    }

    /// Gets the shortcut widget for @self.
    ///
    /// # Returns
    ///
    /// the shortcut widget for @self
    #[doc(alias = "hdy_tab_view_get_shortcut_widget")]
    #[doc(alias = "get_shortcut_widget")]
    pub fn shortcut_widget(&self) -> Option<gtk::Widget> {
        unsafe { from_glib_none(ffi::hdy_tab_view_get_shortcut_widget(self.to_glib_none().0)) }
    }

    /// Inserts a non-pinned page at @position.
    ///
    /// It's an error to try to insert a page before a pinned page, in that case
    /// [`insert_pinned()`][Self::insert_pinned()] should be used instead.
    /// ## `child`
    /// a widget to add
    /// ## `position`
    /// the position to add @child at, starting from 0
    ///
    /// # Returns
    ///
    /// the page object representing @child
    #[doc(alias = "hdy_tab_view_insert")]
    pub fn insert(&self, child: &impl IsA<gtk::Widget>, position: i32) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_insert(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                position,
            ))
        }
    }

    /// Inserts a pinned page at @position.
    ///
    /// It's an error to try to insert a pinned page after a non-pinned page, in that
    /// case [`insert()`][Self::insert()] should be used instead.
    /// ## `child`
    /// a widget to add
    /// ## `position`
    /// the position to add @child at, starting from 0
    ///
    /// # Returns
    ///
    /// the page object representing @child
    #[doc(alias = "hdy_tab_view_insert_pinned")]
    pub fn insert_pinned(&self, child: &impl IsA<gtk::Widget>, position: i32) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_insert_pinned(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                position,
            ))
        }
    }

    /// Inserts @child as the first non-pinned page.
    /// ## `child`
    /// a widget to add
    ///
    /// # Returns
    ///
    /// the page object representing @child
    #[doc(alias = "hdy_tab_view_prepend")]
    pub fn prepend(&self, child: &impl IsA<gtk::Widget>) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_prepend(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Inserts @child as the first pinned page.
    /// ## `child`
    /// a widget to add
    ///
    /// # Returns
    ///
    /// the page object representing @child
    #[doc(alias = "hdy_tab_view_prepend_pinned")]
    pub fn prepend_pinned(&self, child: &impl IsA<gtk::Widget>) -> Option<TabPage> {
        unsafe {
            from_glib_none(ffi::hdy_tab_view_prepend_pinned(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Reorders @page to before its previous page if possible.
    /// ## `page`
    /// a page of @self
    ///
    /// # Returns
    ///
    /// whether @page was moved
    #[doc(alias = "hdy_tab_view_reorder_backward")]
    pub fn reorder_backward(&self, page: &TabPage) -> bool {
        unsafe {
            from_glib(ffi::hdy_tab_view_reorder_backward(
                self.to_glib_none().0,
                page.to_glib_none().0,
            ))
        }
    }

    /// Reorders @page to the first possible position.
    /// ## `page`
    /// a page of @self
    ///
    /// # Returns
    ///
    /// whether @page was moved
    #[doc(alias = "hdy_tab_view_reorder_first")]
    pub fn reorder_first(&self, page: &TabPage) -> bool {
        unsafe {
            from_glib(ffi::hdy_tab_view_reorder_first(
                self.to_glib_none().0,
                page.to_glib_none().0,
            ))
        }
    }

    /// Reorders @page to after its next page if possible.
    /// ## `page`
    /// a page of @self
    ///
    /// # Returns
    ///
    /// whether @page was moved
    #[doc(alias = "hdy_tab_view_reorder_forward")]
    pub fn reorder_forward(&self, page: &TabPage) -> bool {
        unsafe {
            from_glib(ffi::hdy_tab_view_reorder_forward(
                self.to_glib_none().0,
                page.to_glib_none().0,
            ))
        }
    }

    /// Reorders @page to the last possible position.
    /// ## `page`
    /// a page of @self
    ///
    /// # Returns
    ///
    /// whether @page was moved
    #[doc(alias = "hdy_tab_view_reorder_last")]
    pub fn reorder_last(&self, page: &TabPage) -> bool {
        unsafe {
            from_glib(ffi::hdy_tab_view_reorder_last(
                self.to_glib_none().0,
                page.to_glib_none().0,
            ))
        }
    }

    /// Reorders @page to @position.
    ///
    /// It's a programmer error to try to reorder a pinned page after a non-pinned
    /// one, or a non-pinned page before a pinned one.
    /// ## `page`
    /// a page of @self
    /// ## `position`
    /// the position to insert the page at, starting at 0
    ///
    /// # Returns
    ///
    /// whether @page was moved
    #[doc(alias = "hdy_tab_view_reorder_page")]
    pub fn reorder_page(&self, page: &TabPage, position: i32) -> bool {
        unsafe {
            from_glib(ffi::hdy_tab_view_reorder_page(
                self.to_glib_none().0,
                page.to_glib_none().0,
                position,
            ))
        }
    }

    /// Selects the page after the currently selected page.
    ///
    /// If the last page was already selected, this function does nothing.
    ///
    /// # Returns
    ///
    /// whether the selected page was changed
    #[doc(alias = "hdy_tab_view_select_next_page")]
    pub fn select_next_page(&self) -> bool {
        unsafe { from_glib(ffi::hdy_tab_view_select_next_page(self.to_glib_none().0)) }
    }

    /// Selects the page before the currently selected page.
    ///
    /// If the first page was already selected, this function does nothing.
    ///
    /// # Returns
    ///
    /// whether the selected page was changed
    #[doc(alias = "hdy_tab_view_select_previous_page")]
    pub fn select_previous_page(&self) -> bool {
        unsafe {
            from_glib(ffi::hdy_tab_view_select_previous_page(
                self.to_glib_none().0,
            ))
        }
    }

    /// Sets default page icon for @self.
    ///
    /// If a page doesn't provide its own icon via [`icon`][struct@crate::TabPage#icon], default
    /// icon may be used instead for contexts where having an icon is necessary.
    ///
    /// [`TabBar`][crate::TabBar] will use default icon for pinned tabs in case the page is not
    /// loading, doesn't have an icon and an indicator. Default icon is never used
    /// for tabs that aren't pinned.
    ///
    /// By default, `hdy-tab-icon-missing-symbolic` icon is used.
    /// ## `default_icon`
    /// the default icon
    #[doc(alias = "hdy_tab_view_set_default_icon")]
    pub fn set_default_icon(&self, default_icon: &impl IsA<gio::Icon>) {
        unsafe {
            ffi::hdy_tab_view_set_default_icon(
                self.to_glib_none().0,
                default_icon.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the tab context menu model for @self.
    ///
    /// When a context menu is shown for a tab, it will be constructed from the
    /// provided menu model. Use [`setup-menu`][struct@crate::TabView#setup-menu] signal to set up the
    /// menu actions for the particular tab.
    /// ## `menu_model`
    /// a menu model
    #[doc(alias = "hdy_tab_view_set_menu_model")]
    pub fn set_menu_model(&self, menu_model: Option<&impl IsA<gio::MenuModel>>) {
        unsafe {
            ffi::hdy_tab_view_set_menu_model(
                self.to_glib_none().0,
                menu_model.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Pins or unpins @page.
    ///
    /// Pinned pages are guaranteed to be placed before all non-pinned pages; at any
    /// given moment the first [`n-pinned-pages`][struct@crate::TabView#n-pinned-pages] pages in @self are
    /// guaranteed to be pinned.
    ///
    /// When a page is pinned or unpinned, it's automatically reordered: pinning a
    /// page moves it after other pinned pages; unpinning a page moves it before
    /// other non-pinned pages.
    ///
    /// Pinned pages can still be reordered between each other.
    ///
    /// [`TabBar`][crate::TabBar] will display pinned pages in a compact form, never showing the
    /// title or close button, and only showing a single icon, selected in the
    /// following order:
    ///
    /// 1. [`indicator-icon`][struct@crate::TabPage#indicator-icon]
    /// 2. A spinner if [`loading`][struct@crate::TabPage#loading] is `TRUE`
    /// 3. [`icon`][struct@crate::TabPage#icon]
    /// 4. [`default-icon`][struct@crate::TabView#default-icon]
    ///
    /// Pinned pages cannot be closed by default, see [`close-page`][struct@crate::TabView#close-page]
    /// for how to override that behavior.
    /// ## `page`
    /// a page of @self
    /// ## `pinned`
    /// whether @page should be pinned
    #[doc(alias = "hdy_tab_view_set_page_pinned")]
    pub fn set_page_pinned(&self, page: &TabPage, pinned: bool) {
        unsafe {
            ffi::hdy_tab_view_set_page_pinned(
                self.to_glib_none().0,
                page.to_glib_none().0,
                pinned.into_glib(),
            );
        }
    }

    /// Sets the currently selected page in @self.
    /// ## `selected_page`
    /// a page in @self
    #[doc(alias = "hdy_tab_view_set_selected_page")]
    pub fn set_selected_page(&self, selected_page: &TabPage) {
        unsafe {
            ffi::hdy_tab_view_set_selected_page(
                self.to_glib_none().0,
                selected_page.to_glib_none().0,
            );
        }
    }

    /// Sets the shortcut widget for @self.
    /// ## `widget`
    /// a shortcut widget
    #[doc(alias = "hdy_tab_view_set_shortcut_widget")]
    pub fn set_shortcut_widget(&self, widget: Option<&impl IsA<gtk::Widget>>) {
        unsafe {
            ffi::hdy_tab_view_set_shortcut_widget(
                self.to_glib_none().0,
                widget.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Transfers @page from @self to @other_view.
    ///
    /// The @page object will be reused.
    ///
    /// It's a programmer error to try to insert a pinned page after a non-pinned
    /// one, or a non-pinned page before a pinned one.
    /// ## `page`
    /// a page of @self
    /// ## `other_view`
    /// the tab view to transfer the page to
    /// ## `position`
    /// the position to insert the page at, starting at 0
    #[doc(alias = "hdy_tab_view_transfer_page")]
    pub fn transfer_page(&self, page: &TabPage, other_view: &TabView, position: i32) {
        unsafe {
            ffi::hdy_tab_view_transfer_page(
                self.to_glib_none().0,
                page.to_glib_none().0,
                other_view.to_glib_none().0,
                position,
            );
        }
    }

    /// Emitted after [`close_page()`][Self::close_page()] has been called for @page.
    ///
    /// The handler is expected to call [`close_page_finish()`][Self::close_page_finish()] to
    /// confirm or reject the closing.
    ///
    /// The default handler will immediately confirm closing for non-pinned pages,
    /// or reject it for pinned pages, equivalent to the following example:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static gboolean
    /// close_page_cb (HdyTabView *view,
    ///                HdyTabPage *page,
    ///                gpointer    user_data)
    /// {
    ///   hdy_tab_view_close_page_finish (view, page, !hdy_tab_page_get_pinned (page));
    ///
    ///   return GDK_EVENT_STOP;
    /// }
    /// ```
    ///
    /// The [`close_page_finish()`][Self::close_page_finish()] doesn't have to happen during the
    /// handler, so can be used to do asynchronous checks before confirming the
    /// closing.
    ///
    /// A typical reason to connect to this signal is to show a confirmation dialog
    /// for closing a tab.
    /// ## `page`
    /// a page of the view
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "close-page")]
    pub fn connect_close_page<F: Fn(&Self, &TabPage) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn close_page_trampoline<F: Fn(&TabView, &TabPage) -> bool + 'static>(
            this: *mut ffi::HdyTabView,
            page: *mut ffi::HdyTabPage,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(page)).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"close-page\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    close_page_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a tab should be transferred into a new window.
    ///
    /// This can happen after a tab has been dropped on desktop.
    ///
    /// The signal handler is expected to create a new window, position it as
    /// needed and return its [`TabView`][crate::TabView]that the page will be transferred into.
    ///
    /// # Returns
    ///
    /// the [`TabView`][crate::TabView] from the new
    ///   window
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "create-window")]
    pub fn connect_create_window<F: Fn(&Self) -> Option<TabView> + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn create_window_trampoline<
            F: Fn(&TabView) -> Option<TabView> + 'static,
        >(
            this: *mut ffi::HdyTabView,
            f: glib::ffi::gpointer,
        ) -> *mut ffi::HdyTabView {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this)) /*Not checked*/
                .to_glib_none()
                .0
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"create-window\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    create_window_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted after the indicator icon on @page has been activated.
    ///
    /// See [`indicator-icon`][struct@crate::TabPage#indicator-icon] and
    /// [`indicator-activatable`][struct@crate::TabPage#indicator-activatable].
    /// ## `page`
    /// a page of the view
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "indicator-activated")]
    pub fn connect_indicator_activated<F: Fn(&Self, &TabPage) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn indicator_activated_trampoline<F: Fn(&TabView, &TabPage) + 'static>(
            this: *mut ffi::HdyTabView,
            page: *mut ffi::HdyTabPage,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(page))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"indicator-activated\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    indicator_activated_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a page has been created or transferred to the view.
    ///
    /// A typical reason to connect to this signal would be to connect to page
    /// signals for things such as updating window title.
    /// ## `page`
    /// a page of the view
    /// ## `position`
    /// the position of the page, starting from 0
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "page-attached")]
    pub fn connect_page_attached<F: Fn(&Self, &TabPage, i32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn page_attached_trampoline<F: Fn(&TabView, &TabPage, i32) + 'static>(
            this: *mut ffi::HdyTabView,
            page: *mut ffi::HdyTabPage,
            position: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(page), position)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"page-attached\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    page_attached_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a page has been removed or transferred to another view.
    ///
    /// A typical reason to connect to this signal would be to disconnect signal
    /// handlers connected in the [`page-attached`][struct@crate::TabView#page-attached] handler.
    ///
    /// It is important not to try and destroy the page child in the handler of
    /// this function as the child might merely be moved to another window; use
    /// child dispose handler for that or do it in sync with your
    /// [`close_page_finish()`][Self::close_page_finish()] calls.
    /// ## `page`
    /// a page of the view
    /// ## `position`
    /// the position of the removed page, starting from 0
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "page-detached")]
    pub fn connect_page_detached<F: Fn(&Self, &TabPage, i32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn page_detached_trampoline<F: Fn(&TabView, &TabPage, i32) + 'static>(
            this: *mut ffi::HdyTabView,
            page: *mut ffi::HdyTabPage,
            position: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(page), position)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"page-detached\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    page_detached_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted after @page has been reordered to @position.
    /// ## `page`
    /// a page of the view
    /// ## `position`
    /// the position @page was moved to, starting at 0
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "page-reordered")]
    pub fn connect_page_reordered<F: Fn(&Self, &TabPage, i32) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn page_reordered_trampoline<F: Fn(&TabView, &TabPage, i32) + 'static>(
            this: *mut ffi::HdyTabView,
            page: *mut ffi::HdyTabPage,
            position: libc::c_int,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(page), position)
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"page-reordered\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    page_reordered_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a context menu is opened or closed for @page.
    ///
    /// If the menu has been closed, @page will be set to `NULL`.
    ///
    /// It can be used to set up menu actions before showing the menu, for example
    /// disable actions not applicable to @page.
    /// ## `page`
    /// a page of @self_
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "setup-menu")]
    pub fn connect_setup_menu<F: Fn(&Self, &TabPage) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn setup_menu_trampoline<F: Fn(&TabView, &TabPage) + 'static>(
            this: *mut ffi::HdyTabView,
            page: *mut ffi::HdyTabPage,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this), &from_glib_borrow(page))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"setup-menu\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    setup_menu_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "default-icon")]
    pub fn connect_default_icon_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_icon_trampoline<F: Fn(&TabView) + 'static>(
            this: *mut ffi::HdyTabView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::default-icon\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_default_icon_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "is-transferring-page")]
    pub fn connect_is_transferring_page_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_transferring_page_trampoline<F: Fn(&TabView) + 'static>(
            this: *mut ffi::HdyTabView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::is-transferring-page\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_is_transferring_page_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "menu-model")]
    pub fn connect_menu_model_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_menu_model_trampoline<F: Fn(&TabView) + 'static>(
            this: *mut ffi::HdyTabView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::menu-model\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_menu_model_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "n-pages")]
    pub fn connect_n_pages_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_n_pages_trampoline<F: Fn(&TabView) + 'static>(
            this: *mut ffi::HdyTabView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::n-pages\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_n_pages_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "n-pinned-pages")]
    pub fn connect_n_pinned_pages_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_n_pinned_pages_trampoline<F: Fn(&TabView) + 'static>(
            this: *mut ffi::HdyTabView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::n-pinned-pages\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_n_pinned_pages_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "selected-page")]
    pub fn connect_selected_page_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_selected_page_trampoline<F: Fn(&TabView) + 'static>(
            this: *mut ffi::HdyTabView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::selected-page\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_selected_page_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    #[doc(alias = "shortcut-widget")]
    pub fn connect_shortcut_widget_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_shortcut_widget_trampoline<F: Fn(&TabView) + 'static>(
            this: *mut ffi::HdyTabView,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::shortcut-widget\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_shortcut_widget_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

#[cfg(feature = "v1_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
impl Default for TabView {
    fn default() -> Self {
        Self::new()
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`TabView`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct TabViewBuilder {
    builder: glib::object::ObjectBuilder<'static, TabView>,
}

impl TabViewBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// Default page icon.
    ///
    /// If a page doesn't provide its own icon via [`icon`][struct@crate::TabPage#icon], default
    /// icon may be used instead for contexts where having an icon is necessary.
    ///
    /// [`TabBar`][crate::TabBar] will use default icon for pinned tabs in case the page is
    /// not loading, doesn't have an icon and an indicator. Default icon is never
    /// used for tabs that aren't pinned.
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn default_icon(self, default_icon: &impl IsA<gio::Icon>) -> Self {
        Self {
            builder: self
                .builder
                .property("default-icon", default_icon.clone().upcast()),
        }
    }

    /// Tab context menu model.
    ///
    /// When a context menu is shown for a tab, it will be constructed from the
    /// provided menu model. Use [`setup-menu`][struct@crate::TabView#setup-menu] signal to set up the
    /// menu actions for the particular tab.
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn menu_model(self, menu_model: &impl IsA<gio::MenuModel>) -> Self {
        Self {
            builder: self
                .builder
                .property("menu-model", menu_model.clone().upcast()),
        }
    }

    /// The currently selected page.
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn selected_page(self, selected_page: &TabPage) -> Self {
        Self {
            builder: self
                .builder
                .property("selected-page", selected_page.clone()),
        }
    }

    /// Tab shortcut widget.
    ///
    /// Has the following shortcuts:
    ///
    /// * <kbd>Ctrl</kbd>+<kbd>Page Up</kbd> - switch to the previous page
    /// * <kbd>Ctrl</kbd>+<kbd>Page Down</kbd> - switch to the next page
    /// * <kbd>Ctrl</kbd>+<kbd>Home</kbd> - switch to the first page
    /// * <kbd>Ctrl</kbd>+<kbd>End</kbd> - switch to the last page
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Page Up</kbd> - move the current page
    ///     backward
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Page Down</kbd> - move the current
    ///     page forward
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Home</kbd> - move the current page at
    ///     the start
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>End</kbd> - move the current page at
    ///      the end
    /// * <kbd>Ctrl</kbd>+<kbd>Tab</kbd> - switch to the next page, with looping
    /// * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Tab</kbd> - switch to the previous
    ///     page, with looping
    /// * <kbd>Alt</kbd>+<kbd>1</kbd>⋯<kbd>9</kbd> - switch to pages 1-9
    /// * <kbd>Alt</kbd>+<kbd>0</kbd> - switch to page 10
    ///
    /// These shortcuts are always available on @self_, this property is useful if
    /// they should be available globally.
    #[cfg(feature = "v1_2")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_2")))]
    pub fn shortcut_widget(self, shortcut_widget: &impl IsA<gtk::Widget>) -> Self {
        Self {
            builder: self
                .builder
                .property("shortcut-widget", shortcut_widget.clone().upcast()),
        }
    }

    pub fn border_width(self, border_width: u32) -> Self {
        Self {
            builder: self.builder.property("border-width", border_width),
        }
    }

    pub fn child(self, child: &impl IsA<gtk::Widget>) -> Self {
        Self {
            builder: self.builder.property("child", child.clone().upcast()),
        }
    }

    pub fn resize_mode(self, resize_mode: gtk::ResizeMode) -> Self {
        Self {
            builder: self.builder.property("resize-mode", resize_mode),
        }
    }

    pub fn app_paintable(self, app_paintable: bool) -> Self {
        Self {
            builder: self.builder.property("app-paintable", app_paintable),
        }
    }

    pub fn can_default(self, can_default: bool) -> Self {
        Self {
            builder: self.builder.property("can-default", can_default),
        }
    }

    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    pub fn events(self, events: gdk::EventMask) -> Self {
        Self {
            builder: self.builder.property("events", events),
        }
    }

    /// Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
    pub fn expand(self, expand: bool) -> Self {
        Self {
            builder: self.builder.property("expand", expand),
        }
    }

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
    /// GtkComboBox) implemented this property individually.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// How to distribute horizontal space if widget gets extra space, see #GtkAlign
    pub fn halign(self, halign: gtk::Align) -> Self {
        Self {
            builder: self.builder.property("halign", halign),
        }
    }

    pub fn has_default(self, has_default: bool) -> Self {
        Self {
            builder: self.builder.property("has-default", has_default),
        }
    }

    pub fn has_focus(self, has_focus: bool) -> Self {
        Self {
            builder: self.builder.property("has-focus", has_focus),
        }
    }

    /// Enables or disables the emission of #GtkWidget::query-tooltip on @widget.
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using #GtkWidget::query-tooltip to determine
    /// whether it will provide a tooltip or not.
    ///
    /// Note that setting this property to [`true`] for the first time will change
    /// the event masks of the GdkWindows of this widget to include leave-notify
    /// and motion-notify events.  This cannot and will not be undone when the
    /// property is set to [`false`] again.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally. See gtk_widget_set_hexpand().
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    pub fn is_focus(self, is_focus: bool) -> Self {
        Self {
            builder: self.builder.property("is-focus", is_focus),
        }
    }

    /// Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    pub fn margin(self, margin: i32) -> Self {
        Self {
            builder: self.builder.property("margin", margin),
        }
    }

    /// Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    pub fn margin_bottom(self, margin_bottom: i32) -> Self {
        Self {
            builder: self.builder.property("margin-bottom", margin_bottom),
        }
    }

    /// Margin on end of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    pub fn margin_end(self, margin_end: i32) -> Self {
        Self {
            builder: self.builder.property("margin-end", margin_end),
        }
    }

    /// Margin on start of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    pub fn margin_start(self, margin_start: i32) -> Self {
        Self {
            builder: self.builder.property("margin-start", margin_start),
        }
    }

    /// Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// gtk_widget_set_size_request() for example.
    pub fn margin_top(self, margin_top: i32) -> Self {
        Self {
            builder: self.builder.property("margin-top", margin_top),
        }
    }

    pub fn name(self, name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("name", name.into()),
        }
    }

    pub fn no_show_all(self, no_show_all: bool) -> Self {
        Self {
            builder: self.builder.property("no-show-all", no_show_all),
        }
    }

    /// The requested opacity of the widget. See gtk_widget_set_opacity() for
    /// more details about window opacity.
    ///
    /// Before 3.8 this was only available in GtkWindow
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    pub fn parent(self, parent: &impl IsA<gtk::Container>) -> Self {
        Self {
            builder: self.builder.property("parent", parent.clone().upcast()),
        }
    }

    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    pub fn sensitive(self, sensitive: bool) -> Self {
        Self {
            builder: self.builder.property("sensitive", sensitive),
        }
    }

    //pub fn style(self, style: &impl IsA</*Ignored*/gtk::Style>) -> Self {
    //    Self { builder: self.builder.property("style", style.clone().upcast()), }
    //}

    /// Sets the text of tooltip to be the given string, which is marked up
    /// with the [Pango text markup language][PangoMarkupFormat].
    /// Also see gtk_tooltip_set_markup().
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: #GtkWidget:has-tooltip
    /// will automatically be set to [`true`] and there will be taken care of
    /// #GtkWidget::query-tooltip in the default signal handler.
    ///
    /// Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
    /// are set, the last one wins.
    pub fn tooltip_markup(self, tooltip_markup: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("tooltip-markup", tooltip_markup.into()),
        }
    }

    /// Sets the text of tooltip to be the given string.
    ///
    /// Also see gtk_tooltip_set_text().
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: #GtkWidget:has-tooltip
    /// will automatically be set to [`true`] and there will be taken care of
    /// #GtkWidget::query-tooltip in the default signal handler.
    ///
    /// Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
    /// are set, the last one wins.
    pub fn tooltip_text(self, tooltip_text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("tooltip-text", tooltip_text.into()),
        }
    }

    /// How to distribute vertical space if widget gets extra space, see #GtkAlign
    pub fn valign(self, valign: gtk::Align) -> Self {
        Self {
            builder: self.builder.property("valign", valign),
        }
    }

    /// Whether to expand vertically. See gtk_widget_set_vexpand().
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`TabView`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> TabView {
        self.builder.build()
    }
}

impl fmt::Display for TabView {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("TabView")
    }
}