@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -2,14 +2,86 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Places a label next to an indicator.
+ *
+ *
+ *
+ * A `GtkCheckButton` is created by calling either [ctor@Gtk.CheckButton.new]
+ * or [ctor@Gtk.CheckButton.new_with_label].
+ *
+ * The state of a `GtkCheckButton` can be set specifically using
+ * [method@Gtk.CheckButton.set_active], and retrieved using
+ * [method@Gtk.CheckButton.get_active].
+ *
+ * # Inconsistent state
+ *
+ * In addition to "on" and "off", check buttons can be an
+ * "in between" state that is neither on nor off. This can be used
+ * e.g. when the user has selected a range of elements (such as some
+ * text or spreadsheet cells) that are affected by a check button,
+ * and the current values in that range are inconsistent.
+ *
+ * To set a `GtkCheckButton` to inconsistent state, use
+ * [method@Gtk.CheckButton.set_inconsistent].
+ *
+ * # Grouping
+ *
+ * Check buttons can be grouped together, to form mutually exclusive
+ * groups - only one of the buttons can be toggled at a time, and toggling
+ * another one will switch the currently toggled one off.
+ *
+ * Grouped check buttons use a different indicator, and are commonly referred
+ * to as *radio buttons*.
+ *
+ *
+ *
+ * To add a `GtkCheckButton` to a group, use [method@Gtk.CheckButton.set_group].
+ *
+ * When the code must keep track of the state of a group of radio buttons, it
+ * is recommended to keep track of such state through a stateful
+ * `GAction` with a target for each button. Using the `toggled` signals to keep
+ * track of the group changes and state is discouraged.
+ *
+ * # Shortcuts and Gestures
+ *
+ * `GtkCheckButton` supports the following keyboard shortcuts:
+ *
+ * - `␣` or `Enter` activates the button.
+ *
+ * # CSS nodes
+ *
+ * ```
+ * checkbutton[.text-button][.grouped]
+ * ├── check
+ * ╰── [label]
+ * ```
+ *
+ * A `GtkCheckButton` has a main node with name checkbutton. If the
+ * [property@Gtk.CheckButton:label] or [property@Gtk.CheckButton:child]
+ * properties are set, it contains a child widget. The indicator node
+ * is named check when no group is set, and radio if the checkbutton
+ * is grouped together with other checkbuttons.
+ *
+ * # Accessibility
+ *
+ * `GtkCheckButton` uses the [enum@Gtk.AccessibleRole.checkbox] role.
+ */
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     toggled: { params: [], returnType: { type: "undefined" } },
 };
 export class CheckButton extends Widget {
+    /**
+     * Creates a new `GtkCheckButton`.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new `GtkCheckButton` with the given text.
+     * @param label - the text for the check button.
+     */
     static buttonNewWithLabel(label) {
         const ptr = call("libgtk-4.so.1", "gtk_check_button_new_with_label", [
             {
@@ -20,6 +92,10 @@ export class CheckButton extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, CheckButton);
     }
+    /**
+     * Creates a new `GtkCheckButton` with the given text and a mnemonic.
+     * @param label - The text of the button, with an underscore
+     */
     static buttonNewWithMnemonic(label) {
         const ptr = call("libgtk-4.so.1", "gtk_check_button_new_with_mnemonic", [
             {
@@ -36,6 +112,9 @@ export class CheckButton extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Returns whether the check button is active.
+     */
     getActive() {
         return call("libgtk-4.so.1", "gtk_check_button_get_active", [
             {
@@ -44,6 +123,9 @@ export class CheckButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the child widget of `button` or `NULL` if [property@CheckButton:label] is set.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_check_button_get_child", [
             {
@@ -55,6 +137,9 @@ export class CheckButton extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns whether the check button is in an inconsistent state.
+     */
     getInconsistent() {
         return call("libgtk-4.so.1", "gtk_check_button_get_inconsistent", [
             {
@@ -63,6 +148,9 @@ export class CheckButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the label of the check button or `NULL` if [property@CheckButton:child] is set.
+     */
     getLabel() {
         return call("libgtk-4.so.1", "gtk_check_button_get_label", [
             {
@@ -71,6 +159,9 @@ export class CheckButton extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns whether underlines in the label indicate mnemonics.
+     */
     getUseUnderline() {
         return call("libgtk-4.so.1", "gtk_check_button_get_use_underline", [
             {
@@ -79,6 +170,10 @@ export class CheckButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Changes the check buttons active state.
+     * @param setting - the new value to set
+     */
     setActive(setting) {
         call("libgtk-4.so.1", "gtk_check_button_set_active", [
             {
@@ -91,6 +186,16 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the child widget of @button.
+     *
+     * Note that by using this API, you take full responsibility for setting
+     * up the proper accessibility label and description information for @button.
+     * Most likely, you'll either set the accessibility label or description
+     * for `button` explicitly, or you'll set a labelled-by or described-by
+     * relations from `child` to @button.
+     * @param child - the child widget
+     */
     setChild(child) {
         call("libgtk-4.so.1", "gtk_check_button_set_child", [
             {
@@ -104,6 +209,24 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds `self` to the group of @group.
+     *
+     * In a group of multiple check buttons, only one button can be active
+     * at a time. The behavior of a checkbutton in a group is also commonly
+     * known as a *radio button*.
+     *
+     * Setting the group of a check button also changes the css name of the
+     * indicator widget's CSS node to 'radio'.
+     *
+     * Setting up groups in a cycle leads to undefined behavior.
+     *
+     * Note that the same effect can be achieved via the [iface@Gtk.Actionable]
+     * API, by using the same action with parameter type and state type 's'
+     * for all buttons in the group, and giving each button its own target
+     * value.
+     * @param group - another `GtkCheckButton` to
+     */
     setGroup(group) {
         call("libgtk-4.so.1", "gtk_check_button_set_group", [
             {
@@ -117,6 +240,13 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkCheckButton` to inconsistent state.
+     *
+     * You should turn off the inconsistent state again if the user checks
+     * the check button. This has to be done manually.
+     * @param inconsistent - %TRUE if state is inconsistent
+     */
     setInconsistent(inconsistent) {
         call("libgtk-4.so.1", "gtk_check_button_set_inconsistent", [
             {
@@ -129,6 +259,14 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text of @self.
+     *
+     * If [property@Gtk.CheckButton:use-underline] is %TRUE, an underscore
+     * in `label` is interpreted as mnemonic indicator, see
+     * [method@Gtk.CheckButton.set_use_underline] for details on this behavior.
+     * @param label - The text shown next to the indicator, or %NULL
+     */
     setLabel(label) {
         call("libgtk-4.so.1", "gtk_check_button_set_label", [
             {
@@ -142,6 +280,14 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether underlines in the label indicate mnemonics.
+     *
+     * If `setting` is %TRUE, an underscore character in @self's label
+     * indicates a mnemonic accelerator key. This behavior is similar
+     * to [property@Gtk.Label:use-underline].
+     * @param setting - the new value to set
+     */
     setUseUnderline(setting) {
         call("libgtk-4.so.1", "gtk_check_button_set_use_underline", [
             {
@@ -154,6 +300,9 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the action name for @actionable.
+     */
     getActionName() {
         return call("libgtk-4.so.1", "gtk_actionable_get_action_name", [
             {
@@ -162,6 +311,9 @@ export class CheckButton extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the current target value of @actionable.
+     */
     getActionTargetValue() {
         const ptr = call("libgtk-4.so.1", "gtk_actionable_get_action_target_value", [
             {
@@ -178,6 +330,22 @@ export class CheckButton extends Widget {
             return null;
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Specifies the name of the action with which this widget should be
+     * associated.
+     *
+     * If `action_name` is %NULL then the widget will be unassociated from
+     * any previous action.
+     *
+     * Usually this function is used when the widget is located (or will be
+     * located) within the hierarchy of a `GtkApplicationWindow`.
+     *
+     * Names are of the form “win.save” or “app.quit” for actions on the
+     * containing [class@ApplicationWindow] or its associated [class@Application],
+     * respectively. This is the same form used for actions in the [class@Gio.Menu]
+     * associated with the window.
+     * @param actionName - an action name
+     */
     setActionName(actionName) {
         call("libgtk-4.so.1", "gtk_actionable_set_action_name", [
             {
@@ -191,6 +359,27 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the target value of an actionable widget.
+     *
+     * If `target_value` is %NULL then the target value is unset.
+     *
+     * The target value has two purposes. First, it is used as the parameter
+     * to activation of the action associated with the `GtkActionable` widget.
+     * Second, it is used to determine if the widget should be rendered as
+     * “active” — the widget is active if the state is equal to the given target.
+     *
+     * Consider the example of associating a set of buttons with a [iface@Gio.Action]
+     * with string state in a typical “radio button” situation. Each button
+     * will be associated with the same action, but with a different target
+     * value for that action. Clicking on a particular button will activate
+     * the action with the target of that button, which will typically cause
+     * the action’s state to change to that value. Since the action’s state
+     * is now equal to the target value of the button, the button will now
+     * be rendered as active (and the other buttons, with different targets,
+     * rendered inactive).
+     * @param targetValue - a [struct@GLib.Variant] to set as the target value
+     */
     setActionTargetValue(targetValue) {
         call("libgtk-4.so.1", "gtk_actionable_set_action_target_value", [
             {
@@ -209,6 +398,14 @@ export class CheckButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the action-name and associated string target value of an
+     * actionable widget.
+     *
+     * `detailed_action_name` is a string in the format accepted by
+     * [func@Gio.Action.parse_detailed_name].
+     * @param detailedActionName - the detailed action name
+     */
     setDetailedActionName(detailedActionName) {
         call("libgtk-4.so.1", "gtk_actionable_set_detailed_action_name", [
             {

package/dist/generated/gtk/closure-expression.d.ts

@@ -1,6 +1,20 @@
 import * as GObject from "../gobject/index.js";
 import { Expression } from "./expression.js";
+/**
+ * An expression using a custom `GClosure` to compute the value from
+ * its parameters.
+ */
 export declare class ClosureExpression extends Expression {
+    /**
+     * Creates a `GtkExpression` that calls `closure` when it is evaluated.
+     *
+     * `closure` is called with the `this` object and the results of evaluating
+     * the `params` expressions.
+     * @param valueType - the type of the value that this expression evaluates to
+     * @param closure - closure to call when evaluating this expression. If closure is floating, it is adopted
+     * @param nParams - the number of params needed for evaluating `closure`
+     * @param params - expressions for each parameter
+     */
     constructor(valueType: number, closure: GObject.Closure, nParams: number, params?: Expression[] | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;

package/dist/generated/gtk/closure-expression.js

@@ -1,5 +1,9 @@
 import { call } from "@gtkx/native";
 import { Expression } from "./expression.js";
+/**
+ * An expression using a custom `GClosure` to compute the value from
+ * its parameters.
+ */
 export class ClosureExpression extends Expression {
     constructor(...args) {
         super(...args);

package/dist/generated/gtk/color-button.d.ts

@@ -4,17 +4,82 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class ColorButton extends Widget {
+    /**
+     * Creates a new color button.
+     *
+     * This returns a widget in the form of a small button containing
+     * a swatch representing the current selected color. When the button
+     * is clicked, a color chooser dialog will open, allowing the user
+     * to select a color. The swatch will be updated to reflect the new
+     * color when the user finishes.
+     */
     constructor(...args: unknown[]);
+    /**
+     * Creates a new color button showing the given color.
+     * @param rgba - A `GdkRGBA` to set the current color with
+     */
     static buttonNewWithRgba(rgba: Gdk.RGBA): ColorButton;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets whether the dialog is modal.
+     */
     getModal(): boolean;
+    /**
+     * Gets the title of the color chooser dialog.
+     */
     getTitle(): string;
+    /**
+     * Sets whether the dialog should be modal.
+     * @param modal - %TRUE to make the dialog modal
+     */
     setModal(modal: boolean): void;
+    /**
+     * Sets the title for the color chooser dialog.
+     * @param title - String containing new window title
+     */
     setTitle(title: string): void;
+    /**
+     * Adds a palette to the color chooser.
+     *
+     * If `orientation` is horizontal, the colors are grouped in rows,
+     * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+     * the colors are grouped in columns instead.
+     *
+     * The default color palette of [class@Gtk.ColorChooserWidget] has
+     * 45 colors, organized in columns of 5 colors (this includes some
+     * grays).
+     *
+     * The layout of the color chooser widget works best when the
+     * palettes have 9-10 columns.
+     *
+     * Calling this function for the first time has the side effect
+     * of removing the default color palette from the color chooser.
+     *
+     * If `colors` is %NULL, removes all previously added palettes.
+     * @param orientation - %GTK_ORIENTATION_HORIZONTAL if the palette should
+     * @param colorsPerLine - the number of colors to show in each row/column
+     * @param nColors - the total number of elements in @colors
+     * @param colors - the colors of the palette
+     */
     addPalette(orientation: Orientation, colorsPerLine: number, nColors: number, colors?: Gdk.RGBA[] | null): void;
+    /**
+     * Gets the currently-selected color.
+     * @param color - a `GdkRGBA` to fill in with the current color
+     */
     getRgba(color: Ref<Gdk.RGBA>): void;
+    /**
+     * Returns whether the color chooser shows the alpha channel.
+     */
     getUseAlpha(): boolean;
+    /**
+     * Sets the color.
+     * @param color - the new color
+     */
     setRgba(color: Gdk.RGBA): void;
+    /**
+     * Sets whether or not the color chooser should use the alpha channel.
+     * @param useAlpha - %TRUE if color chooser should use alpha channel, %FALSE if not
+     */
     setUseAlpha(useAlpha: boolean): void;
     connect(signal: "activate", handler: (self: ColorButton) => void, after?: boolean): number;
     connect(signal: "color-set", handler: (self: ColorButton) => void, after?: boolean): number;

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

@@ -1,14 +1,47 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
+/**
+ * The `GtkColorButton` allows to open a color chooser dialog to change
+ * the color.
+ *
+ *
+ *
+ * It is suitable widget for selecting a color in a preference dialog.
+ *
+ * # CSS nodes
+ *
+ * ```
+ * colorbutton
+ * ╰── button.color
+ * ╰── [content]
+ * ```
+ *
+ * `GtkColorButton` has a single CSS node with name colorbutton which
+ * contains a button node. To differentiate it from a plain `GtkButton`,
+ * it gets the .color style class.
+ */
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     "color-set": { params: [], returnType: { type: "undefined" } },
 };
 export class ColorButton extends Widget {
+    /**
+     * Creates a new color button.
+     *
+     * This returns a widget in the form of a small button containing
+     * a swatch representing the current selected color. When the button
+     * is clicked, a color chooser dialog will open, allowing the user
+     * to select a color. The swatch will be updated to reflect the new
+     * color when the user finishes.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new color button showing the given color.
+     * @param rgba - A `GdkRGBA` to set the current color with
+     */
     static buttonNewWithRgba(rgba) {
         const ptr = call("libgtk-4.so.1", "gtk_color_button_new_with_rgba", [
             {
@@ -29,6 +62,9 @@ export class ColorButton extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Gets whether the dialog is modal.
+     */
     getModal() {
         return call("libgtk-4.so.1", "gtk_color_button_get_modal", [
             {
@@ -37,6 +73,9 @@ export class ColorButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the title of the color chooser dialog.
+     */
     getTitle() {
         return call("libgtk-4.so.1", "gtk_color_button_get_title", [
             {
@@ -45,6 +84,10 @@ export class ColorButton extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Sets whether the dialog should be modal.
+     * @param modal - %TRUE to make the dialog modal
+     */
     setModal(modal) {
         call("libgtk-4.so.1", "gtk_color_button_set_modal", [
             {
@@ -57,6 +100,10 @@ export class ColorButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the title for the color chooser dialog.
+     * @param title - String containing new window title
+     */
     setTitle(title) {
         call("libgtk-4.so.1", "gtk_color_button_set_title", [
             {
@@ -69,6 +116,29 @@ export class ColorButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a palette to the color chooser.
+     *
+     * If `orientation` is horizontal, the colors are grouped in rows,
+     * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+     * the colors are grouped in columns instead.
+     *
+     * The default color palette of [class@Gtk.ColorChooserWidget] has
+     * 45 colors, organized in columns of 5 colors (this includes some
+     * grays).
+     *
+     * The layout of the color chooser widget works best when the
+     * palettes have 9-10 columns.
+     *
+     * Calling this function for the first time has the side effect
+     * of removing the default color palette from the color chooser.
+     *
+     * If `colors` is %NULL, removes all previously added palettes.
+     * @param orientation - %GTK_ORIENTATION_HORIZONTAL if the palette should
+     * @param colorsPerLine - the number of colors to show in each row/column
+     * @param nColors - the total number of elements in @colors
+     * @param colors - the colors of the palette
+     */
     addPalette(orientation, colorsPerLine, nColors, colors) {
         call("libgtk-4.so.1", "gtk_color_chooser_add_palette", [
             {
@@ -101,6 +171,10 @@ export class ColorButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the currently-selected color.
+     * @param color - a `GdkRGBA` to fill in with the current color
+     */
     getRgba(color) {
         call("libgtk-4.so.1", "gtk_color_chooser_get_rgba", [
             {
@@ -120,6 +194,9 @@ export class ColorButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether the color chooser shows the alpha channel.
+     */
     getUseAlpha() {
         return call("libgtk-4.so.1", "gtk_color_chooser_get_use_alpha", [
             {
@@ -128,6 +205,10 @@ export class ColorButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets the color.
+     * @param color - the new color
+     */
     setRgba(color) {
         call("libgtk-4.so.1", "gtk_color_chooser_set_rgba", [
             {
@@ -145,6 +226,10 @@ export class ColorButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether or not the color chooser should use the alpha channel.
+     * @param useAlpha - %TRUE if color chooser should use alpha channel, %FALSE if not
+     */
     setUseAlpha(useAlpha) {
         call("libgtk-4.so.1", "gtk_color_chooser_set_use_alpha", [
             {

package/dist/generated/gtk/color-chooser-dialog.d.ts

@@ -5,13 +5,56 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Dialog } from "./dialog.js";
 export declare class ColorChooserDialog extends Dialog {
+    /**
+     * Creates a new `GtkColorChooserDialog`.
+     * @param title - Title of the dialog
+     * @param parent - Transient parent of the dialog
+     */
     constructor(title?: string | null, parent?: Window | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Adds a palette to the color chooser.
+     *
+     * If `orientation` is horizontal, the colors are grouped in rows,
+     * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+     * the colors are grouped in columns instead.
+     *
+     * The default color palette of [class@Gtk.ColorChooserWidget] has
+     * 45 colors, organized in columns of 5 colors (this includes some
+     * grays).
+     *
+     * The layout of the color chooser widget works best when the
+     * palettes have 9-10 columns.
+     *
+     * Calling this function for the first time has the side effect
+     * of removing the default color palette from the color chooser.
+     *
+     * If `colors` is %NULL, removes all previously added palettes.
+     * @param orientation - %GTK_ORIENTATION_HORIZONTAL if the palette should
+     * @param colorsPerLine - the number of colors to show in each row/column
+     * @param nColors - the total number of elements in @colors
+     * @param colors - the colors of the palette
+     */
     addPalette(orientation: Orientation, colorsPerLine: number, nColors: number, colors?: Gdk.RGBA[] | null): void;
+    /**
+     * Gets the currently-selected color.
+     * @param color - a `GdkRGBA` to fill in with the current color
+     */
     getRgba(color: Ref<Gdk.RGBA>): void;
+    /**
+     * Returns whether the color chooser shows the alpha channel.
+     */
     getUseAlpha(): boolean;
+    /**
+     * Sets the color.
+     * @param color - the new color
+     */
     setRgba(color: Gdk.RGBA): void;
+    /**
+     * Sets whether or not the color chooser should use the alpha channel.
+     * @param useAlpha - %TRUE if color chooser should use alpha channel, %FALSE if not
+     */
     setUseAlpha(useAlpha: boolean): void;
     connect(signal: "close", handler: (self: ColorChooserDialog) => void, after?: boolean): number;
     connect(signal: "response", handler: (self: ColorChooserDialog, responseId: number) => void, after?: boolean): number;