@gtkx/ffi 0.5.2 → 0.6.0

package/dist/generated/adw/tab-view.js

@@ -0,0 +1,892 @@
+import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { TabPage } from "./tab-page.js";
+import * as Gtk from "../gtk/index.js";
+/**
+ * A dynamic tabbed container.
+ *
+ * `AdwTabView` 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 switcher and relies on external widgets for that, such as
+ * [class@TabBar], [class@TabOverview] and [class@TabButton].
+ *
+ * `AdwTabView` maintains a [class@TabPage] object for each page, which holds
+ * additional per-page properties. You can obtain the `AdwTabPage` for a page
+ * with [method@TabView.get_page], and as the return value for
+ * [method@TabView.append] and other functions for adding children.
+ *
+ * `AdwTabView` 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 [class@Gtk.Notebook] for use
+ * cases such as tabbed dialogs.
+ *
+ * As such, it does not support disabling page reordering or detaching.
+ *
+ * `AdwTabView` adds a number of global page switching and reordering shortcuts.
+ * The [property@TabView:shortcuts] property can be used to manage them.
+ *
+ * See [flags@TabViewShortcuts] for the list of the available shortcuts. All of
+ * the shortcuts are enabled by default.
+ *
+ * [method@TabView.add_shortcuts] and [method@TabView.remove_shortcuts] can be
+ * used to manage shortcuts in a convenient way, for example:
+ *
+ * ```c
+ * adw_tab_view_remove_shortcuts (view, ADW_TAB_VIEW_SHORTCUT_CONTROL_HOME |
+ * ADW_TAB_VIEW_SHORTCUT_CONTROL_END);
+ * ```
+ *
+ * ## CSS nodes
+ *
+ * `AdwTabView` has a main CSS node with the name `tabview`.
+ *
+ * ## Accessibility
+ *
+ * `AdwTabView` uses the `GTK_ACCESSIBLE_ROLE_TAB_PANEL` for the tab pages which
+ * are the accessible parent objects of the child widgets.
+ */
+const SIGNAL_META = {
+    "close-page": {
+        params: [
+            { type: { type: "gobject", borrowed: true }, getCls: () => TabPage },
+        ],
+        returnType: { type: "boolean" },
+    },
+    "create-window": {
+        params: [],
+        returnType: { type: "gobject", borrowed: false },
+    },
+    "indicator-activated": {
+        params: [
+            { type: { type: "gobject", borrowed: true }, getCls: () => TabPage },
+        ],
+        returnType: { type: "undefined" },
+    },
+    "page-attached": {
+        params: [
+            { type: { type: "gobject", borrowed: true }, getCls: () => TabPage },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+    "page-detached": {
+        params: [
+            { type: { type: "gobject", borrowed: true }, getCls: () => TabPage },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+    "page-reordered": {
+        params: [
+            { type: { type: "gobject", borrowed: true }, getCls: () => TabPage },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+    "setup-menu": {
+        params: [
+            { type: { type: "gobject", borrowed: true }, getCls: () => TabPage },
+        ],
+        returnType: { type: "undefined" },
+    },
+};
+export class TabView extends Gtk.Widget {
+    static glibTypeName = "AdwTabView";
+    /**
+     * Creates a new `AdwTabView`.
+     */
+    constructor() {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            this.id = call("libadwaita-1.so.0", "adw_tab_view_new", [], {
+                type: "gobject",
+                borrowed: true,
+            });
+        }
+        else {
+            // @ts-ignore
+            super();
+        }
+    }
+    /**
+     * 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
+     * [method@TabView.close_page]).
+     *
+     * If `parent` is `NULL`, this function is equivalent to [method@TabView.append].
+     * @param child - a widget to add
+     * @param parent - a parent page for @child
+     */
+    addPage(child, parent) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_add_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: parent?.id ?? parent,
+                optional: true,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Adds `shortcuts` for @self.
+     *
+     * See [property@TabView:shortcuts] for details.
+     * @param shortcuts - the shortcuts to add
+     */
+    addShortcuts(shortcuts) {
+        call("libadwaita-1.so.0", "adw_tab_view_add_shortcuts", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: shortcuts,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Inserts `child` as the last non-pinned page.
+     * @param child - a widget to add
+     */
+    append(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_append", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Inserts `child` as the last pinned page.
+     * @param child - a widget to add
+     */
+    appendPinned(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_append_pinned", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Requests to close all pages other than @page.
+     * @param page - a page of @self
+     */
+    closeOtherPages(page) {
+        call("libadwaita-1.so.0", "adw_tab_view_close_other_pages", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Requests to close @page.
+     *
+     * Calling this function will result in the [signal@TabView::close-page] signal
+     * being emitted for @page. Closing the page can then be confirmed or
+     * denied via [method@TabView.close_page_finish].
+     *
+     * If the page is waiting for a [method@TabView.close_page_finish] call, this
+     * function will do nothing.
+     *
+     * The default handler for [signal@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 [property@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.
+     * @param page - a page of @self
+     */
+    closePage(page) {
+        call("libadwaita-1.so.0", "adw_tab_view_close_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Completes a [method@TabView.close_page] call for @page.
+     *
+     * If `confirm` is `TRUE`, `page` will be closed. If it's `FALSE`, it will be
+     * reverted to its previous state and [method@TabView.close_page] can be called
+     * for it again.
+     *
+     * This function should not be called unless a custom handler for
+     * [signal@TabView::close-page] is used.
+     * @param page - a page of @self
+     * @param confirm - whether to confirm or deny closing @page
+     */
+    closePageFinish(page, confirm) {
+        call("libadwaita-1.so.0", "adw_tab_view_close_page_finish", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+            {
+                type: { type: "boolean" },
+                value: confirm,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Requests to close all pages after @page.
+     * @param page - a page of @self
+     */
+    closePagesAfter(page) {
+        call("libadwaita-1.so.0", "adw_tab_view_close_pages_after", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Requests to close all pages before @page.
+     * @param page - a page of @self
+     */
+    closePagesBefore(page) {
+        call("libadwaita-1.so.0", "adw_tab_view_close_pages_before", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Gets the default icon of @self.
+     */
+    getDefaultIcon() {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_get_default_icon", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Whether a page is being transferred.
+     *
+     * The corresponding property will be set to `TRUE` when a drag-n-drop tab
+     * transfer starts on any `AdwTabView`, 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.
+     */
+    getIsTransferringPage() {
+        return call("libadwaita-1.so.0", "adw_tab_view_get_is_transferring_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Gets the tab context menu model for @self.
+     */
+    getMenuModel() {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_get_menu_model", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets the number of pages in @self.
+     */
+    getNPages() {
+        return call("libadwaita-1.so.0", "adw_tab_view_get_n_pages", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets the number of pinned pages in @self.
+     *
+     * See [method@TabView.set_page_pinned].
+     */
+    getNPinnedPages() {
+        return call("libadwaita-1.so.0", "adw_tab_view_get_n_pinned_pages", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets the [class@TabPage] representing the child at @position.
+     * @param position - the index of the page in @self, starting from 0
+     */
+    getNthPage(position) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_get_nth_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: position,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Gets the [class@TabPage] object representing @child.
+     * @param child - a child in @self
+     */
+    getPage(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_get_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Finds the position of `page` in @self, starting from 0.
+     * @param page - a page of @self
+     */
+    getPagePosition(page) {
+        return call("libadwaita-1.so.0", "adw_tab_view_get_page_position", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Returns a [iface@Gio.ListModel] that contains the pages of @self.
+     *
+     * This can be used to keep an up-to-date view. The model also implements
+     * [iface@Gtk.SelectionModel] and can be used to track and change the selected
+     * page.
+     */
+    getPages() {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_get_pages", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Gets the currently selected page in @self.
+     */
+    getSelectedPage() {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_get_selected_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (ptr === null)
+            return null;
+        return getObject(ptr);
+    }
+    /**
+     * Gets the enabled shortcuts for @self.
+     */
+    getShortcuts() {
+        return call("libadwaita-1.so.0", "adw_tab_view_get_shortcuts", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Inserts a non-pinned page at @position.
+     *
+     * It's an error to try to insert a page before a pinned page, in that case
+     * [method@TabView.insert_pinned] should be used instead.
+     * @param child - a widget to add
+     * @param position - the position to add `child` at, starting from 0
+     */
+    insert(child, position) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_insert", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: position,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * 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 [method@TabView.insert] should be used instead.
+     * @param child - a widget to add
+     * @param position - the position to add `child` at, starting from 0
+     */
+    insertPinned(child, position) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_insert_pinned", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: position,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Invalidates thumbnails for all pages in @self.
+     *
+     * This is a convenience method, equivalent to calling
+     * [method@TabPage.invalidate_thumbnail] on each page.
+     */
+    invalidateThumbnails() {
+        call("libadwaita-1.so.0", "adw_tab_view_invalidate_thumbnails", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Inserts `child` as the first non-pinned page.
+     * @param child - a widget to add
+     */
+    prepend(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_prepend", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Inserts `child` as the first pinned page.
+     * @param child - a widget to add
+     */
+    prependPinned(child) {
+        const ptr = call("libadwaita-1.so.0", "adw_tab_view_prepend_pinned", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: child?.id ?? child,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getObject(ptr);
+    }
+    /**
+     * Removes `shortcuts` from @self.
+     *
+     * See [property@TabView:shortcuts] for details.
+     * @param shortcuts - the shortcuts to remove
+     */
+    removeShortcuts(shortcuts) {
+        call("libadwaita-1.so.0", "adw_tab_view_remove_shortcuts", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: shortcuts,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Reorders `page` to before its previous page if possible.
+     * @param page - a page of @self
+     */
+    reorderBackward(page) {
+        return call("libadwaita-1.so.0", "adw_tab_view_reorder_backward", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Reorders `page` to the first possible position.
+     * @param page - a page of @self
+     */
+    reorderFirst(page) {
+        return call("libadwaita-1.so.0", "adw_tab_view_reorder_first", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Reorders `page` to after its next page if possible.
+     * @param page - a page of @self
+     */
+    reorderForward(page) {
+        return call("libadwaita-1.so.0", "adw_tab_view_reorder_forward", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Reorders `page` to the last possible position.
+     * @param page - a page of @self
+     */
+    reorderLast(page) {
+        return call("libadwaita-1.so.0", "adw_tab_view_reorder_last", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * 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.
+     * @param page - a page of @self
+     * @param position - the position to insert the page at, starting at 0
+     */
+    reorderPage(page, position) {
+        return call("libadwaita-1.so.0", "adw_tab_view_reorder_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: position,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Selects the page after the currently selected page.
+     *
+     * If the last page was already selected, this function does nothing.
+     */
+    selectNextPage() {
+        return call("libadwaita-1.so.0", "adw_tab_view_select_next_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Selects the page before the currently selected page.
+     *
+     * If the first page was already selected, this function does nothing.
+     */
+    selectPreviousPage() {
+        return call("libadwaita-1.so.0", "adw_tab_view_select_previous_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "boolean" });
+    }
+    /**
+     * Sets the default page icon for @self.
+     *
+     * If a page doesn't provide its own icon via [property@TabPage:icon], a default
+     * icon may be used instead for contexts where having an icon is necessary.
+     *
+     * [class@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.
+     *
+     * [class@TabOverview] will use default icon for pages with missing thumbnails.
+     *
+     * By default, the `adw-tab-icon-missing-symbolic` icon is used.
+     * @param defaultIcon - the default icon
+     */
+    setDefaultIcon(defaultIcon) {
+        call("libadwaita-1.so.0", "adw_tab_view_set_default_icon", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: defaultIcon?.id ?? defaultIcon,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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 the [signal@TabView::setup-menu] signal to set up
+     * the menu actions for the particular tab.
+     * @param menuModel - a menu model
+     */
+    setMenuModel(menuModel) {
+        call("libadwaita-1.so.0", "adw_tab_view_set_menu_model", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: menuModel?.id ?? menuModel,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Pins or unpins @page.
+     *
+     * Pinned pages are guaranteed to be placed before all non-pinned pages; at any
+     * given moment the first [property@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.
+     *
+     * [class@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. [property@TabPage:indicator-icon]
+     * 2. A spinner if [property@TabPage:loading] is `TRUE`
+     * 3. [property@TabPage:icon]
+     * 4. [property@TabView:default-icon]
+     *
+     * [class@TabOverview] will not show a thumbnail for pinned pages, and replace
+     * the close button with an unpin button. Unlike `AdwTabBar`, it will still
+     * display the page's title, icon and indicator separately.
+     *
+     * Pinned pages cannot be closed by default, see [signal@TabView::close-page]
+     * for how to override that behavior.
+     *
+     * Changes the value of the [property@TabPage:pinned] property.
+     * @param page - a page of @self
+     * @param pinned - whether `page` should be pinned
+     */
+    setPagePinned(page, pinned) {
+        call("libadwaita-1.so.0", "adw_tab_view_set_page_pinned", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+            {
+                type: { type: "boolean" },
+                value: pinned,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the currently selected page in @self.
+     * @param selectedPage - a page in @self
+     */
+    setSelectedPage(selectedPage) {
+        call("libadwaita-1.so.0", "adw_tab_view_set_selected_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: selectedPage?.id ?? selectedPage,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the enabled shortcuts for @self.
+     *
+     * See [flags@TabViewShortcuts] for the list of the available shortcuts. All of
+     * the shortcuts are enabled by default.
+     *
+     * [method@TabView.add_shortcuts] and [method@TabView.remove_shortcuts] provide
+     * a convenient way to manage individual shortcuts.
+     * @param shortcuts - the new shortcuts
+     */
+    setShortcuts(shortcuts) {
+        call("libadwaita-1.so.0", "adw_tab_view_set_shortcuts", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: shortcuts,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * 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.
+     * @param page - a page of @self
+     * @param otherView - the tab view to transfer the page to
+     * @param position - the position to insert the page at, starting at 0
+     */
+    transferPage(page, otherView, position) {
+        call("libadwaita-1.so.0", "adw_tab_view_transfer_page", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: page?.id ?? page,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: otherView?.id ?? otherView,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: position,
+            },
+        ], { type: "undefined" });
+    }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0]);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(signalArgs[i]);
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libadwaita-1.so.0", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.id },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
+}
+registerType(TabView);