@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/no-selection.js

@@ -3,6 +3,14 @@ import { getObject } from "@gtkx/ffi";
 import { Bitset } from "./bitset.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * A selection model that does not allow selecting anything.
+ *
+ * This model is meant to be used as a simple wrapper around a `GListModel`
+ * when a `GtkSelectionModel` is required.
+ *
+ * `GtkNoSelection` passes through sections from the underlying model.
+ */
 export class NoSelection extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -17,6 +25,9 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the model that `self` is wrapping.
+     */
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_no_selection_get_model", [
             {
@@ -28,6 +39,12 @@ export class NoSelection extends GObject.GObject {
             return null;
         return getObject(ptr, Gio.ListModel);
     }
+    /**
+     * Sets the model that `self` should wrap.
+     *
+     * If `model` is %NULL, this model will be empty.
+     * @param model - A `GListModel` to wrap
+     */
     setModel(model) {
         call("libgtk-4.so.1", "gtk_no_selection_set_model", [
             {
@@ -41,6 +58,16 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Query the section that covers the given position. The number of
+     * items in the section can be computed by `out_end - out_start`.
+     *
+     * If the position is larger than the number of items, a single
+     * range from n_items to G_MAXUINT will be returned.
+     * @param position - the position of the item to query
+     * @param outStart - the position of the first item in the section
+     * @param outEnd - the position of the first item not part of the section
+     */
     getSection(position, outStart, outEnd) {
         call("libgtk-4.so.1", "gtk_section_model_get_section", [
             {
@@ -67,6 +94,25 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * This function emits the [signal@Gtk.SectionModel::sections-changed]
+     * signal to notify about changes to sections.
+     *
+     * It must cover all positions that used to be a section start or that
+     * are now a section start. It does not have to cover all positions for
+     * which the section has changed.
+     *
+     * The [signal@Gio.ListModel::items-changed] implies the effect of the
+     * [signal@Gtk.SectionModel::sections-changed] signal for all the items
+     * it covers.
+     *
+     * It is recommended that when changes to the items cause section changes
+     * in a larger range, that the larger range is included in the emission
+     * of the [signal@Gio.ListModel::items-changed] instead of emitting
+     * two signals.
+     * @param position - the first changed item
+     * @param nItems - the number of changed items
+     */
     sectionsChanged(position, nItems) {
         call("libgtk-4.so.1", "gtk_section_model_sections_changed", [
             {
@@ -83,6 +129,13 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the set containing all currently selected items in the model.
+     *
+     * This function may be slow, so if you are only interested in single item,
+     * consider using [method@Gtk.SelectionModel.is_selected] or if you are only
+     * interested in a few, consider [method@Gtk.SelectionModel.get_selection_in_range].
+     */
     getSelection() {
         const ptr = call("libgtk-4.so.1", "gtk_selection_model_get_selection", [
             {
@@ -97,6 +150,17 @@ export class NoSelection extends GObject.GObject {
         });
         return getObject(ptr, Bitset);
     }
+    /**
+     * Gets the set of selected items in a range.
+     *
+     * This function is an optimization for
+     * [method@Gtk.SelectionModel.get_selection] when you are only
+     * interested in part of the model's selected state. A common use
+     * case is in response to the [signal@Gtk.SelectionModel::selection-changed]
+     * signal.
+     * @param position - start of the queried range
+     * @param nItems - number of items in the queried range
+     */
     getSelectionInRange(position, nItems) {
         const ptr = call("libgtk-4.so.1", "gtk_selection_model_get_selection_in_range", [
             {
@@ -119,6 +183,10 @@ export class NoSelection extends GObject.GObject {
         });
         return getObject(ptr, Bitset);
     }
+    /**
+     * Checks if the given item is selected.
+     * @param position - the position of the item to query
+     */
     isSelected(position) {
         return call("libgtk-4.so.1", "gtk_selection_model_is_selected", [
             {
@@ -131,6 +199,9 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to select all items in the model.
+     */
     selectAll() {
         return call("libgtk-4.so.1", "gtk_selection_model_select_all", [
             {
@@ -139,6 +210,11 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to select an item in the model.
+     * @param position - the position of the item to select
+     * @param unselectRest - whether previously selected items should be unselected
+     */
     selectItem(position, unselectRest) {
         return call("libgtk-4.so.1", "gtk_selection_model_select_item", [
             {
@@ -155,6 +231,12 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to select a range of items in the model.
+     * @param position - the first item to select
+     * @param nItems - the number of items to select
+     * @param unselectRest - whether previously selected items should be unselected
+     */
     selectRange(position, nItems, unselectRest) {
         return call("libgtk-4.so.1", "gtk_selection_model_select_range", [
             {
@@ -175,6 +257,14 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Helper function for implementations of `GtkSelectionModel`.
+     *
+     * Call this when the selection changes to emit the
+     * [signal@Gtk.SelectionModel::selection-changed] signal.
+     * @param position - the first changed item
+     * @param nItems - the number of changed items
+     */
     selectionChanged(position, nItems) {
         call("libgtk-4.so.1", "gtk_selection_model_selection_changed", [
             {
@@ -191,6 +281,42 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Make selection changes.
+     *
+     * This is the most advanced selection updating method that allows
+     * the most fine-grained control over selection changes. If you can,
+     * you should try the simpler versions, as implementations are more
+     * likely to implement support for those.
+     *
+     * Requests that the selection state of all positions set in `mask` be updated to the respective value in the `selected` bitmask.
+     *
+     * In pseudocode, it would look something like this:
+     *
+     * ```c
+     * for (i = 0; i < n_items; i++)
+     * {
+     * // don't change values not in the mask
+     * if (!gtk_bitset_contains (mask, i))
+     * continue;
+     *
+     * if (gtk_bitset_contains (selected, i))
+     * select_item (i);
+     * else
+     * unselect_item (i);
+     * }
+     *
+     * gtk_selection_model_selection_changed (model,
+     * first_changed_item,
+     * n_changed_items);
+     * ```
+     *
+     * `mask` and `selected` must not be modified. They may refer to the
+     * same bitset, which would mean that every item in the set should
+     * be selected.
+     * @param selected - bitmask specifying if items should be selected or unselected
+     * @param mask - bitmask specifying which items should be updated
+     */
     setSelection(selected, mask) {
         return call("libgtk-4.so.1", "gtk_selection_model_set_selection", [
             {
@@ -217,6 +343,9 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to unselect all items in the model.
+     */
     unselectAll() {
         return call("libgtk-4.so.1", "gtk_selection_model_unselect_all", [
             {
@@ -225,6 +354,10 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to unselect an item in the model.
+     * @param position - the position of the item to unselect
+     */
     unselectItem(position) {
         return call("libgtk-4.so.1", "gtk_selection_model_unselect_item", [
             {
@@ -237,6 +370,11 @@ export class NoSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to unselect a range of items in the model.
+     * @param position - the first item to unselect
+     * @param nItems - the number of items to unselect
+     */
     unselectRange(position, nItems) {
         return call("libgtk-4.so.1", "gtk_selection_model_unselect_range", [
             {

package/dist/generated/gtk/notebook-page.d.ts

@@ -1,8 +1,12 @@
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+/** An auxiliary object used by `GtkNotebook`. */
 export declare class NotebookPage extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns the notebook child to which `page` belongs.
+     */
     getChild(): Widget;
     connect(signal: "notify", handler: (self: NotebookPage, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/notebook-page.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+/** An auxiliary object used by `GtkNotebook`. */
 export class NotebookPage extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -17,6 +18,9 @@ export class NotebookPage extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Returns the notebook child to which `page` belongs.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_notebook_page_get_child", [
             {

package/dist/generated/gtk/notebook.d.ts

@@ -4,51 +4,334 @@ import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
 export declare class Notebook extends Widget {
+    /**
+     * Creates a new `GtkNotebook` widget with no pages.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Appends a page to @notebook.
+     * @param child - the `GtkWidget` to use as the contents of the page
+     * @param tabLabel - the `GtkWidget` to be used as the label
+     */
     appendPage(child: Widget, tabLabel?: Widget | null): number;
+    /**
+     * Appends a page to @notebook, specifying the widget to use as the
+     * label in the popup menu.
+     * @param child - the `GtkWidget` to use as the contents of the page
+     * @param tabLabel - the `GtkWidget` to be used as the label
+     * @param menuLabel - the widget to use as a label for the
+     */
     appendPageMenu(child: Widget, tabLabel?: Widget | null, menuLabel?: Widget | null): number;
+    /**
+     * Removes the child from the notebook.
+     *
+     * This function is very similar to [method@Gtk.Notebook.remove_page],
+     * but additionally informs the notebook that the removal
+     * is happening as part of a tab DND operation, which should
+     * not be cancelled.
+     * @param child - a child
+     */
     detachTab(child: Widget): void;
+    /**
+     * Gets one of the action widgets.
+     *
+     * See [method@Gtk.Notebook.set_action_widget].
+     * @param packType - pack type of the action widget to receive
+     */
     getActionWidget(packType: PackType): Widget | null;
+    /**
+     * Returns the page number of the current page.
+     */
     getCurrentPage(): number;
+    /**
+     * Gets the current group name for @notebook.
+     */
     getGroupName(): string | null;
+    /**
+     * Retrieves the menu label widget of the page containing @child.
+     * @param child - a widget contained in a page of @notebook
+     */
     getMenuLabel(child: Widget): Widget | null;
+    /**
+     * Retrieves the text of the menu label for the page containing
+     * @child.
+     * @param child - the child widget of a page of the notebook.
+     */
     getMenuLabelText(child: Widget): string | null;
+    /**
+     * Gets the number of pages in a notebook.
+     */
     getNPages(): number;
+    /**
+     * Returns the child widget contained in page number @page_num.
+     * @param pageNum - the index of a page in the notebook, or -1
+     */
     getNthPage(pageNum: number): Widget | null;
+    /**
+     * Returns the `GtkNotebookPage` for @child.
+     * @param child - a child of @notebook
+     */
     getPage(child: Widget): NotebookPage;
+    /**
+     * Returns a `GListModel` that contains the pages of the notebook.
+     *
+     * 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 modify the visible page.
+     */
     getPages(): Gio.ListModel;
+    /**
+     * Returns whether the tab label area has arrows for scrolling.
+     */
     getScrollable(): boolean;
+    /**
+     * Returns whether a bevel will be drawn around the notebook pages.
+     */
     getShowBorder(): boolean;
+    /**
+     * Returns whether the tabs of the notebook are shown.
+     */
     getShowTabs(): boolean;
+    /**
+     * Returns whether the tab contents can be detached from @notebook.
+     * @param child - a child `GtkWidget`
+     */
     getTabDetachable(child: Widget): boolean;
+    /**
+     * Returns the tab label widget for the page @child.
+     *
+     * %NULL is returned if `child` is not in `notebook` or
+     * if no tab label has specifically been set for @child.
+     * @param child - the page
+     */
     getTabLabel(child: Widget): Widget | null;
+    /**
+     * Retrieves the text of the tab label for the page containing
+     * @child.
+     * @param child - a widget contained in a page of @notebook
+     */
     getTabLabelText(child: Widget): string | null;
+    /**
+     * Gets the edge at which the tabs are drawn.
+     */
     getTabPos(): PositionType;
+    /**
+     * Gets whether the tab can be reordered via drag and drop or not.
+     * @param child - a child `GtkWidget`
+     */
     getTabReorderable(child: Widget): boolean;
+    /**
+     * Insert a page into `notebook` at the given position.
+     * @param child - the `GtkWidget` to use as the contents of the page
+     * @param tabLabel - the `GtkWidget` to be used as the label
+     * @param position - the index (starting at 0) at which to insert the page,
+     */
     insertPage(child: Widget, position: number, tabLabel?: Widget | null): number;
+    /**
+     * Insert a page into `notebook` at the given position, specifying
+     * the widget to use as the label in the popup menu.
+     * @param child - the `GtkWidget` to use as the contents of the page
+     * @param tabLabel - the `GtkWidget` to be used as the label
+     * @param menuLabel - the widget to use as a label for the
+     * @param position - the index (starting at 0) at which to insert the page,
+     */
     insertPageMenu(child: Widget, position: number, tabLabel?: Widget | null, menuLabel?: Widget | null): number;
+    /**
+     * Switches to the next page.
+     *
+     * Nothing happens if the current page is the last page.
+     */
     nextPage(): void;
+    /**
+     * Finds the index of the page which contains the given child
+     * widget.
+     * @param child - a `GtkWidget`
+     */
     pageNum(child: Widget): number;
+    /**
+     * Disables the popup menu.
+     */
     popupDisable(): void;
+    /**
+     * Enables the popup menu.
+     *
+     * If the user clicks with the right mouse button on the tab labels,
+     * a menu with all the pages will be popped up.
+     */
     popupEnable(): void;
+    /**
+     * Prepends a page to @notebook.
+     * @param child - the `GtkWidget` to use as the contents of the page
+     * @param tabLabel - the `GtkWidget` to be used as the label
+     */
     prependPage(child: Widget, tabLabel?: Widget | null): number;
+    /**
+     * Prepends a page to @notebook, specifying the widget to use as the
+     * label in the popup menu.
+     * @param child - the `GtkWidget` to use as the contents of the page
+     * @param tabLabel - the `GtkWidget` to be used as the label
+     * @param menuLabel - the widget to use as a label for the
+     */
     prependPageMenu(child: Widget, tabLabel?: Widget | null, menuLabel?: Widget | null): number;
+    /**
+     * Switches to the previous page.
+     *
+     * Nothing happens if the current page is the first page.
+     */
     prevPage(): void;
+    /**
+     * Removes a page from the notebook given its index
+     * in the notebook.
+     * @param pageNum - the index of a notebook page, starting
+     */
     removePage(pageNum: number): void;
+    /**
+     * Reorders the page containing @child, so that it appears in position
+     * @position.
+     *
+     * If `position` is greater than or equal to the number of children in
+     * the list or negative, `child` will be moved to the end of the list.
+     * @param child - the child to move
+     * @param position - the new position, or -1 to move to the end
+     */
     reorderChild(child: Widget, position: number): void;
+    /**
+     * Sets `widget` as one of the action widgets.
+     *
+     * Depending on the pack type the widget will be placed before
+     * or after the tabs. You can use a `GtkBox` if you need to pack
+     * more than one widget on the same side.
+     * @param widget - a `GtkWidget`
+     * @param packType - pack type of the action widget
+     */
     setActionWidget(widget: Widget, packType: PackType): void;
+    /**
+     * Switches to the page number @page_num.
+     *
+     * Note that due to historical reasons, GtkNotebook refuses
+     * to switch to a page unless the child widget is visible.
+     * Therefore, it is recommended to show child widgets before
+     * adding them to a notebook.
+     * @param pageNum - index of the page to switch to, starting from 0.
+     */
     setCurrentPage(pageNum: number): void;
+    /**
+     * Sets a group name for @notebook.
+     *
+     * Notebooks with the same name will be able to exchange tabs
+     * via drag and drop. A notebook with a %NULL group name will
+     * not be able to exchange tabs with any other notebook.
+     * @param groupName - the name of the notebook group,
+     */
     setGroupName(groupName?: string | null): void;
+    /**
+     * Changes the menu label for the page containing @child.
+     * @param child - the child widget
+     * @param menuLabel - the menu label, or %NULL for default
+     */
     setMenuLabel(child: Widget, menuLabel?: Widget | null): void;
+    /**
+     * Creates a new label and sets it as the menu label of @child.
+     * @param child - the child widget
+     * @param menuText - the label text
+     */
     setMenuLabelText(child: Widget, menuText: string): void;
+    /**
+     * Sets whether the tab label area will have arrows for
+     * scrolling if there are too many tabs to fit in the area.
+     * @param scrollable - %TRUE if scroll arrows should be added
+     */
     setScrollable(scrollable: boolean): void;
+    /**
+     * Sets whether a bevel will be drawn around the notebook pages.
+     *
+     * This only has a visual effect when the tabs are not shown.
+     * @param showBorder - %TRUE if a bevel should be drawn around the notebook
+     */
     setShowBorder(showBorder: boolean): void;
+    /**
+     * Sets whether to show the tabs for the notebook or not.
+     * @param showTabs - %TRUE if the tabs should be shown
+     */
     setShowTabs(showTabs: boolean): void;
+    /**
+     * Sets whether the tab can be detached from `notebook` to another
+     * notebook or widget.
+     *
+     * Note that two notebooks must share a common group identifier
+     * (see [method@Gtk.Notebook.set_group_name]) to allow automatic tabs
+     * interchange between them.
+     *
+     * If you want a widget to interact with a notebook through DnD
+     * (i.e.: accept dragged tabs from it) it must be set as a drop
+     * destination by adding to it a [class@Gtk.DropTarget] controller that accepts
+     * the GType `GTK_TYPE_NOTEBOOK_PAGE`. The `:value` of said drop target will be
+     * preloaded with a [class@Gtk.NotebookPage] object that corresponds to the
+     * dropped tab, so you can process the value via `::accept` or `::drop` signals.
+     *
+     * Note that you should use [method@Gtk.Notebook.detach_tab] instead
+     * of [method@Gtk.Notebook.remove_page] if you want to remove the tab
+     * from the source notebook as part of accepting a drop. Otherwise,
+     * the source notebook will think that the dragged tab was removed
+     * from underneath the ongoing drag operation, and will initiate a
+     * drag cancel animation.
+     *
+     * ```c
+     * static void
+     * on_drag_data_received (GtkWidget        *widget,
+     * GdkDrop          *drop,
+     * GtkSelectionData *data,
+     * guint             time,
+     * gpointer          user_data)
+     * {
+     * GtkDrag *drag;
+     * GtkWidget *notebook;
+     * GtkWidget **child;
+     *
+     * drag = gtk_drop_get_drag (drop);
+     * notebook = g_object_get_data (drag, "gtk-notebook-drag-origin");
+     * child = (void*) gtk_selection_data_get_data (data);
+     *
+     * // process_widget (*child);
+     *
+     * gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
+     * }
+     * ```
+     *
+     * If you want a notebook to accept drags from other widgets,
+     * you will have to set your own DnD code to do it.
+     * @param child - a child `GtkWidget`
+     * @param detachable - whether the tab is detachable or not
+     */
     setTabDetachable(child: Widget, detachable: boolean): void;
+    /**
+     * Changes the tab label for @child.
+     *
+     * If %NULL is specified for @tab_label, then the page will
+     * have the label “page N”.
+     * @param child - the page
+     * @param tabLabel - the tab label widget to use, or %NULL
+     */
     setTabLabel(child: Widget, tabLabel?: Widget | null): void;
+    /**
+     * Creates a new label and sets it as the tab label for the page
+     * containing @child.
+     * @param child - the page
+     * @param tabText - the label text
+     */
     setTabLabelText(child: Widget, tabText: string): void;
+    /**
+     * Sets the edge at which the tabs are drawn.
+     * @param pos - the edge to draw the tabs at
+     */
     setTabPos(pos: PositionType): void;
+    /**
+     * Sets whether the notebook tab can be reordered
+     * via drag and drop or not.
+     * @param child - a child `GtkWidget`
+     * @param reorderable - whether the tab is reorderable or not
+     */
     setTabReorderable(child: Widget, reorderable: boolean): void;
     connect(signal: "change-current-page", handler: (self: Notebook, page: number) => boolean, after?: boolean): number;
     connect(signal: "create-window", handler: (self: Notebook, page: Widget) => Notebook, after?: boolean): number;