@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/menu-button.js

@@ -3,10 +3,81 @@ import { getObject } from "@gtkx/ffi";
 import { Popover } from "./popover.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Displays a popup when clicked.
+ *
+ *
+ *
+ * This popup can be provided either as a `GtkPopover` or as an abstract
+ * `GMenuModel`.
+ *
+ * The `GtkMenuButton` widget can show either an icon (set with the
+ * [property@Gtk.MenuButton:icon-name] property) or a label (set with the
+ * [property@Gtk.MenuButton:label] property). If neither is explicitly set,
+ * a [class@Gtk.Image] is automatically created, using an arrow image oriented
+ * according to [property@Gtk.MenuButton:direction] or the generic
+ * “open-menu-symbolic” icon if the direction is not set.
+ *
+ * The positioning of the popup is determined by the
+ * [property@Gtk.MenuButton:direction] property of the menu button.
+ *
+ * For menus, the [property@Gtk.Widget:halign] and [property@Gtk.Widget:valign]
+ * properties of the menu are also taken into account. For example, when the
+ * direction is %GTK_ARROW_DOWN and the horizontal alignment is %GTK_ALIGN_START,
+ * the menu will be positioned below the button, with the starting edge
+ * (depending on the text direction) of the menu aligned with the starting
+ * edge of the button. If there is not enough space below the button, the
+ * menu is popped up above the button instead. If the alignment would move
+ * part of the menu offscreen, it is “pushed in”.
+ *
+ * |           | start                | center                | end                |
+ * | -         | ---                  | ---                   | ---                |
+ * | **down**  |   |   |   |
+ * | **up**    |     |     |     |
+ * | **left**  |   |   |   |
+ * | **right** |  |  |  |
+ *
+ * # CSS nodes
+ *
+ * ```
+ * menubutton
+ * ╰── button.toggle
+ * ╰── <content>
+ * ╰── [arrow]
+ * ```
+ *
+ * `GtkMenuButton` has a single CSS node with name `menubutton`
+ * which contains a `button` node with a `.toggle` style class.
+ *
+ * If the button contains an icon, it will have the `.image-button` style class,
+ * if it contains text, it will have `.text-button` style class. If an arrow is
+ * visible in addition to an icon, text or a custom child, it will also have
+ * `.arrow-button` style class.
+ *
+ * Inside the toggle button content, there is an `arrow` node for
+ * the indicator, which will carry one of the `.none`, `.up`, `.down`,
+ * `.left` or `.right` style classes to indicate the direction that
+ * the menu will appear in. The CSS is expected to provide a suitable
+ * image for each of these cases using the `-gtk-icon-source` property.
+ *
+ * Optionally, the `menubutton` node can carry the `.circular` style class
+ * to request a round appearance.
+ *
+ * # Accessibility
+ *
+ * `GtkMenuButton` uses the [enum@Gtk.AccessibleRole.button] role.
+ */
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
 };
 export class MenuButton extends Widget {
+    /**
+     * Creates a new `GtkMenuButton` widget with downwards-pointing
+     * arrow as the only child.
+     *
+     * You can replace the child widget with another `GtkWidget`
+     * should you wish to.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -16,6 +87,9 @@ export class MenuButton extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Returns whether the menu button is active.
+     */
     getActive() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_active", [
             {
@@ -24,6 +98,10 @@ export class MenuButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether to show a dropdown arrow even when using an icon or a custom
+     * child.
+     */
     getAlwaysShowArrow() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_always_show_arrow", [
             {
@@ -32,6 +110,10 @@ export class MenuButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves whether the button can be smaller than the natural
+     * size of its contents.
+     */
     getCanShrink() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_can_shrink", [
             {
@@ -40,6 +122,9 @@ export class MenuButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the child widget of @menu_button.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_menu_button_get_child", [
             {
@@ -51,6 +136,9 @@ export class MenuButton extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns whether the button has a frame.
+     */
     getHasFrame() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_has_frame", [
             {
@@ -59,6 +147,9 @@ export class MenuButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the name of the icon shown in the button.
+     */
     getIconName() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_icon_name", [
             {
@@ -67,6 +158,9 @@ export class MenuButton extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the label shown in the button
+     */
     getLabel() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_label", [
             {
@@ -75,6 +169,9 @@ export class MenuButton extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns the `GMenuModel` used to generate the popup.
+     */
     getMenuModel() {
         const ptr = call("libgtk-4.so.1", "gtk_menu_button_get_menu_model", [
             {
@@ -86,6 +183,12 @@ export class MenuButton extends Widget {
             return null;
         return getObject(ptr, Gio.MenuModel);
     }
+    /**
+     * Returns the `GtkPopover` that pops out of the button.
+     *
+     * If the button is not using a `GtkPopover`, this function
+     * returns %NULL.
+     */
     getPopover() {
         const ptr = call("libgtk-4.so.1", "gtk_menu_button_get_popover", [
             {
@@ -97,6 +200,9 @@ export class MenuButton extends Widget {
             return null;
         return getObject(ptr, Popover);
     }
+    /**
+     * Returns whether the menu button acts as a primary menu.
+     */
     getPrimary() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_primary", [
             {
@@ -105,6 +211,10 @@ export class MenuButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether an embedded underline in the text indicates a
+     * mnemonic.
+     */
     getUseUnderline() {
         return call("libgtk-4.so.1", "gtk_menu_button_get_use_underline", [
             {
@@ -113,6 +223,9 @@ export class MenuButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Dismiss the menu.
+     */
     popdown() {
         call("libgtk-4.so.1", "gtk_menu_button_popdown", [
             {
@@ -121,6 +234,9 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Pop up the menu.
+     */
     popup() {
         call("libgtk-4.so.1", "gtk_menu_button_popup", [
             {
@@ -129,6 +245,10 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the menu button is active.
+     * @param active - whether the menu button is active
+     */
     setActive(active) {
         call("libgtk-4.so.1", "gtk_menu_button_set_active", [
             {
@@ -141,6 +261,11 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to show a dropdown arrow even when using an icon or a custom
+     * child.
+     * @param alwaysShowArrow - whether to show a dropdown arrow even when using an icon
+     */
     setAlwaysShowArrow(alwaysShowArrow) {
         call("libgtk-4.so.1", "gtk_menu_button_set_always_show_arrow", [
             {
@@ -153,6 +278,15 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the button size can be smaller than the natural size of
+     * its contents.
+     *
+     * For text buttons, setting `can_shrink` to true will ellipsize the label.
+     *
+     * For icon buttons, this function has no effect.
+     * @param canShrink - whether the button can shrink
+     */
     setCanShrink(canShrink) {
         call("libgtk-4.so.1", "gtk_menu_button_set_can_shrink", [
             {
@@ -165,6 +299,17 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the child widget of @menu_button.
+     *
+     * Setting a child resets [property@Gtk.MenuButton:label] and
+     * [property@Gtk.MenuButton:icon-name].
+     *
+     * If [property@Gtk.MenuButton:always-show-arrow] is set to `TRUE` and
+     * [property@Gtk.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
+     * will be shown next to the child.
+     * @param child - the child widget
+     */
     setChild(child) {
         call("libgtk-4.so.1", "gtk_menu_button_set_child", [
             {
@@ -178,6 +323,23 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `func` to be called when a popup is about to be shown.
+     *
+     * `func` should use one of
+     *
+     * - [method@Gtk.MenuButton.set_popover]
+     * - [method@Gtk.MenuButton.set_menu_model]
+     *
+     * to set a popup for @menu_button.
+     * If `func` is non-%NULL, `menu_button` will always be sensitive.
+     *
+     * Using this function will not reset the menu widget attached to
+     * @menu_button. Instead, this can be done manually in @func.
+     * @param func - function
+     * @param userData - user data to pass to @func
+     * @param destroyNotify - destroy notify for @user_data
+     */
     setCreatePopupFunc(func, userData, destroyNotify) {
         call("libgtk-4.so.1", "gtk_menu_button_set_create_popup_func", [
             {
@@ -201,6 +363,10 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the style of the button.
+     * @param hasFrame - whether the button should have a visible frame
+     */
     setHasFrame(hasFrame) {
         call("libgtk-4.so.1", "gtk_menu_button_set_has_frame", [
             {
@@ -213,6 +379,17 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the name of an icon to show inside the menu button.
+     *
+     * Setting icon name resets [property@Gtk.MenuButton:label] and
+     * [property@Gtk.MenuButton:child].
+     *
+     * If [property@Gtk.MenuButton:always-show-arrow] is set to `TRUE` and
+     * [property@Gtk.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
+     * will be shown next to the icon.
+     * @param iconName - the icon name
+     */
     setIconName(iconName) {
         call("libgtk-4.so.1", "gtk_menu_button_set_icon_name", [
             {
@@ -225,6 +402,16 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the label to show inside the menu button.
+     *
+     * Setting a label resets [property@Gtk.MenuButton:icon-name] and
+     * [property@Gtk.MenuButton:child].
+     *
+     * If [property@Gtk.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown
+     * arrow will be shown next to the label.
+     * @param label - the label
+     */
     setLabel(label) {
         call("libgtk-4.so.1", "gtk_menu_button_set_label", [
             {
@@ -237,6 +424,19 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GMenuModel` from which the popup will be constructed.
+     *
+     * If `menu_model` is %NULL, the button is disabled.
+     *
+     * A [class@Gtk.Popover] will be created from the menu model with
+     * [ctor@Gtk.PopoverMenu.new_from_model]. Actions will be connected
+     * as documented for this function.
+     *
+     * If [property@Gtk.MenuButton:popover] is already set, it will be
+     * dissociated from the @menu_button, and the property is set to %NULL.
+     * @param menuModel - a `GMenuModel`, or %NULL to unset and disable the
+     */
     setMenuModel(menuModel) {
         call("libgtk-4.so.1", "gtk_menu_button_set_menu_model", [
             {
@@ -250,6 +450,15 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkPopover` that will be popped up when the `menu_button` is clicked.
+     *
+     * If `popover` is %NULL, the button is disabled.
+     *
+     * If [property@Gtk.MenuButton:menu-model] is set, the menu model is dissociated
+     * from the @menu_button, and the property is set to %NULL.
+     * @param popover - a `GtkPopover`, or %NULL to unset and
+     */
     setPopover(popover) {
         call("libgtk-4.so.1", "gtk_menu_button_set_popover", [
             {
@@ -263,6 +472,12 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether menu button acts as a primary menu.
+     *
+     * Primary menus can be opened with the `F10` key.
+     * @param primary - whether the menubutton should act as a primary menu
+     */
     setPrimary(primary) {
         call("libgtk-4.so.1", "gtk_menu_button_set_primary", [
             {
@@ -275,6 +490,10 @@ export class MenuButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If true, an underline in the text indicates a mnemonic.
+     * @param useUnderline - %TRUE if underlines in the text indicate mnemonics
+     */
     setUseUnderline(useUnderline) {
         call("libgtk-4.so.1", "gtk_menu_button_set_use_underline", [
             {

package/dist/generated/gtk/message-dialog.d.ts

@@ -4,7 +4,19 @@ import { Dialog } from "./dialog.js";
 export declare class MessageDialog extends Dialog {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns the message area of the dialog.
+     *
+     * This is the box where the dialog’s primary and secondary labels
+     * are packed. You can add your own extra content to that box and it
+     * will appear below those labels. See [method@Gtk.Dialog.get_content_area]
+     * for the corresponding function in the parent [class@Gtk.Dialog].
+     */
     getMessageArea(): Widget;
+    /**
+     * Sets the text of the message dialog.
+     * @param str - string with Pango markup
+     */
     setMarkup(str: string): void;
     connect(signal: "close", handler: (self: MessageDialog) => void, after?: boolean): number;
     connect(signal: "response", handler: (self: MessageDialog, responseId: number) => void, after?: boolean): number;

package/dist/generated/gtk/message-dialog.js

@@ -2,6 +2,64 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 import { Dialog } from "./dialog.js";
+/**
+ * `GtkMessageDialog` presents a dialog with some message text.
+ *
+ *
+ *
+ * It’s simply a convenience widget; you could construct the equivalent of
+ * `GtkMessageDialog` from `GtkDialog` without too much effort, but
+ * `GtkMessageDialog` saves typing.
+ *
+ * The easiest way to do a modal message dialog is to use the %GTK_DIALOG_MODAL
+ * flag, which will call [method@Gtk.Window.set_modal] internally. The dialog will
+ * prevent interaction with the parent window until it's hidden or destroyed.
+ * You can use the [signal@Gtk.Dialog::response] signal to know when the user
+ * dismissed the dialog.
+ *
+ * An example for using a modal dialog:
+ * ```c
+ * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL;
+ * dialog = gtk_message_dialog_new (parent_window,
+ * flags,
+ * GTK_MESSAGE_ERROR,
+ * GTK_BUTTONS_CLOSE,
+ * "Error reading “%s”: %s",
+ * filename,
+ * g_strerror (errno));
+ * // Destroy the dialog when the user responds to it
+ * // (e.g. clicks a button)
+ *
+ * g_signal_connect (dialog, "response",
+ * G_CALLBACK (gtk_window_destroy),
+ * NULL);
+ * ```
+ *
+ * You might do a non-modal `GtkMessageDialog` simply by omitting the
+ * %GTK_DIALOG_MODAL flag:
+ *
+ * ```c
+ * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
+ * dialog = gtk_message_dialog_new (parent_window,
+ * flags,
+ * GTK_MESSAGE_ERROR,
+ * GTK_BUTTONS_CLOSE,
+ * "Error reading “%s”: %s",
+ * filename,
+ * g_strerror (errno));
+ *
+ * // Destroy the dialog when the user responds to it
+ * // (e.g. clicks a button)
+ * g_signal_connect (dialog, "response",
+ * G_CALLBACK (gtk_window_destroy),
+ * NULL);
+ * ```
+ *
+ * # GtkMessageDialog as GtkBuildable
+ *
+ * The `GtkMessageDialog` implementation of the `GtkBuildable` interface exposes
+ * the message area as an internal child with the name “message_area”.
+ */
 const SIGNAL_META = {
     close: { params: [], returnType: { type: "undefined" } },
     response: {
@@ -32,6 +90,14 @@ export class MessageDialog extends Dialog {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Returns the message area of the dialog.
+     *
+     * This is the box where the dialog’s primary and secondary labels
+     * are packed. You can add your own extra content to that box and it
+     * will appear below those labels. See [method@Gtk.Dialog.get_content_area]
+     * for the corresponding function in the parent [class@Gtk.Dialog].
+     */
     getMessageArea() {
         const ptr = call("libgtk-4.so.1", "gtk_message_dialog_get_message_area", [
             {
@@ -41,6 +107,10 @@ export class MessageDialog extends Dialog {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Widget);
     }
+    /**
+     * Sets the text of the message dialog.
+     * @param str - string with Pango markup
+     */
     setMarkup(str) {
         call("libgtk-4.so.1", "gtk_message_dialog_set_markup", [
             {

package/dist/generated/gtk/mnemonic-action.d.ts

@@ -1,6 +1,17 @@
 import { ShortcutAction } from "./shortcut-action.js";
+/**
+ * Activates a widget with a mnemonic.
+ *
+ * This means that [method@Gtk.Widget.mnemonic_activate] is called.
+ */
 export declare class MnemonicAction extends ShortcutAction {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the mnemonic action.
+     *
+     * This is an action that calls gtk_widget_mnemonic_activate()
+     * on the given widget upon activation.
+     */
     static get(): MnemonicAction;
 }

package/dist/generated/gtk/mnemonic-action.js

@@ -1,6 +1,11 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { ShortcutAction } from "./shortcut-action.js";
+/**
+ * Activates a widget with a mnemonic.
+ *
+ * This means that [method@Gtk.Widget.mnemonic_activate] is called.
+ */
 export class MnemonicAction extends ShortcutAction {
     constructor(...args) {
         super(...args);
@@ -16,6 +21,12 @@ export class MnemonicAction extends ShortcutAction {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the mnemonic action.
+     *
+     * This is an action that calls gtk_widget_mnemonic_activate()
+     * on the given widget upon activation.
+     */
     static get() {
         const ptr = call("libgtk-4.so.1", "gtk_mnemonic_action_get", [], {
             type: "gobject",

package/dist/generated/gtk/mnemonic-trigger.d.ts

@@ -1,7 +1,24 @@
 import { ShortcutTrigger } from "./shortcut-trigger.js";
+/**
+ * Triggers when a specific mnemonic is pressed.
+ *
+ * Mnemonics require a *mnemonic modifier* (typically `Alt`) to be
+ * pressed together with the mnemonic key.
+ */
 export declare class MnemonicTrigger extends ShortcutTrigger {
+    /**
+     * Creates a `GtkShortcutTrigger` that will trigger whenever the key with
+     * the given `keyval` is pressed and mnemonics have been activated.
+     *
+     * Mnemonics are activated by calling code when a key event with the right
+     * modifiers is detected.
+     * @param keyval - The keyval to trigger for
+     */
     constructor(keyval: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the keyval that must be pressed to succeed triggering @self.
+     */
     getKeyval(): number;
 }

package/dist/generated/gtk/mnemonic-trigger.js

@@ -1,5 +1,11 @@
 import { call } from "@gtkx/native";
 import { ShortcutTrigger } from "./shortcut-trigger.js";
+/**
+ * Triggers when a specific mnemonic is pressed.
+ *
+ * Mnemonics require a *mnemonic modifier* (typically `Alt`) to be
+ * pressed together with the mnemonic key.
+ */
 export class MnemonicTrigger extends ShortcutTrigger {
     constructor(...args) {
         super(...args);
@@ -13,6 +19,9 @@ export class MnemonicTrigger extends ShortcutTrigger {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the keyval that must be pressed to succeed triggering @self.
+     */
     getKeyval() {
         return call("libgtk-4.so.1", "gtk_mnemonic_trigger_get_keyval", [
             {

package/dist/generated/gtk/mount-operation.d.ts

@@ -2,14 +2,53 @@ import { Window } from "./window.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * Asks the user for passwords and other information required to
+ * mount a volume.
+ *
+ * `GtkMountOperation` is needed when mounting volumes:
+ * It is an implementation of `GMountOperation` that can be used with
+ * GIO functions for mounting volumes such as
+ * [method@Gio.File.mount_enclosing_volume],
+ * [method@Gio.File.mount_mountable],
+ * [method@Gio.Volume.mount],
+ * [method@Gio.Mount.unmount_with_operation] and others.
+ *
+ * When necessary, `GtkMountOperation` shows dialogs to let the user
+ * enter passwords, ask questions or show processes blocking unmount.
+ */
 export declare class MountOperation extends Gio.MountOperation {
+    /**
+     * Creates a new `GtkMountOperation`.
+     * @param parent - transient parent of the window
+     */
     constructor(parent?: Window | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the display on which windows of the `GtkMountOperation`
+     * will be shown.
+     */
     getDisplay(): Gdk.Display;
+    /**
+     * Gets the transient parent used by the `GtkMountOperation`.
+     */
     getParent(): Window | null;
+    /**
+     * Returns whether the `GtkMountOperation` is currently displaying
+     * a window.
+     */
     isShowing(): boolean;
+    /**
+     * Sets the display to show windows of the `GtkMountOperation` on.
+     * @param display - a `GdkDisplay`
+     */
     setDisplay(display: Gdk.Display): void;
+    /**
+     * Sets the transient parent for windows shown by the
+     * `GtkMountOperation`.
+     * @param parent - transient parent of the window
+     */
     setParent(parent?: Window | null): void;
     connect(signal: "notify", handler: (self: MountOperation, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;