@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/cell-view.js

@@ -5,10 +5,45 @@ import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
 import { Widget } from "./widget.js";
+/**
+ * A widget displaying a single row of a GtkTreeModel
+ *
+ * A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
+ * and `GtkCellAreaContext`. A `GtkCellAreaContext` can be provided to the
+ * `GtkCellView` at construction time in order to keep the cellview in context
+ * of a group of cell views, this ensures that the renderers displayed will
+ * be properly aligned with each other (like the aligned cells in the menus
+ * of `GtkComboBox`).
+ *
+ * `GtkCellView` is `GtkOrientable` in order to decide in which orientation
+ * the underlying `GtkCellAreaContext` should be allocated. Taking the `GtkComboBox`
+ * menu as an example, cellviews should be oriented horizontally if the menus are
+ * listed top-to-bottom and thus all share the same width but may have separate
+ * individual heights (left-to-right menus should be allocated vertically since
+ * they all share the same height but may have variable widths).
+ *
+ * ## CSS nodes
+ *
+ * GtkCellView has a single CSS node with name cellview.
+ */
 export class CellView extends Widget {
+    /**
+     * Creates a new `GtkCellView` widget.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new `GtkCellView` widget with a specific `GtkCellArea`
+     * to layout cells and a specific `GtkCellAreaContext`.
+     *
+     * Specifying the same context for a handful of cells lets
+     * the underlying area synchronize the geometry for those cells,
+     * in this way alignments with cellviews for other rows are
+     * possible.
+     * @param area - the `GtkCellArea` to layout cells
+     * @param context - the `GtkCellAreaContext` in which to calculate cell geometry
+     */
     static viewNewWithContext(area, context) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_view_new_with_context", [
             {
@@ -22,6 +57,12 @@ export class CellView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, CellView);
     }
+    /**
+     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
+     * to it, and makes it show @markup. The text can be marked up with
+     * the Pango text markup language.
+     * @param markup - the text to display in the cell view
+     */
     static viewNewWithMarkup(markup) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_view_new_with_markup", [
             {
@@ -31,6 +72,11 @@ export class CellView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, CellView);
     }
+    /**
+     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
+     * to it, and makes it show @text.
+     * @param text - the text to display in the cell view
+     */
     static viewNewWithText(text) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_view_new_with_text", [
             {
@@ -40,6 +86,11 @@ export class CellView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, CellView);
     }
+    /**
+     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererPixbuf`
+     * to it, and makes it show @texture.
+     * @param texture - the image to display in the cell view
+     */
     static viewNewWithTexture(texture) {
         const ptr = call("libgtk-4.so.1", "gtk_cell_view_new_with_texture", [
             {
@@ -55,6 +106,11 @@ export class CellView extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Returns a `GtkTreePath` referring to the currently
+     * displayed row. If no row is currently displayed,
+     * %NULL is returned.
+     */
     getDisplayedRow() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_view_get_displayed_row", [
             {
@@ -71,6 +127,10 @@ export class CellView extends Widget {
             return null;
         return getObject(ptr, TreePath);
     }
+    /**
+     * Gets whether `cell_view` is configured to draw all of its
+     * cells in a sensitive state.
+     */
     getDrawSensitive() {
         return call("libgtk-4.so.1", "gtk_cell_view_get_draw_sensitive", [
             {
@@ -79,6 +139,10 @@ export class CellView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether `cell_view` is configured to request space
+     * to fit the entire `GtkTreeModel`.
+     */
     getFitModel() {
         return call("libgtk-4.so.1", "gtk_cell_view_get_fit_model", [
             {
@@ -87,6 +151,10 @@ export class CellView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the model for @cell_view. If no model is used %NULL is
+     * returned.
+     */
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_view_get_model", [
             {
@@ -98,6 +166,15 @@ export class CellView extends Widget {
             return null;
         return getObject(ptr, TreeModel);
     }
+    /**
+     * Sets the row of the model that is currently displayed
+     * by the `GtkCellView`. If the path is unset, then the
+     * contents of the cellview “stick” at their last value;
+     * this is not normally a desired result, but may be
+     * a needed intermediate state if say, the model for
+     * the `GtkCellView` becomes temporarily empty.
+     * @param path - a `GtkTreePath` or %NULL to unset.
+     */
     setDisplayedRow(path) {
         call("libgtk-4.so.1", "gtk_cell_view_set_displayed_row", [
             {
@@ -116,6 +193,13 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether `cell_view` should draw all of its
+     * cells in a sensitive state, this is used by `GtkComboBox` menus
+     * to ensure that rows with insensitive cells that contain
+     * children appear sensitive in the parent menu item.
+     * @param drawSensitive - whether to draw all cells in a sensitive state.
+     */
     setDrawSensitive(drawSensitive) {
         call("libgtk-4.so.1", "gtk_cell_view_set_draw_sensitive", [
             {
@@ -128,6 +212,14 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether `cell_view` should request space to fit the entire `GtkTreeModel`.
+     *
+     * This is used by `GtkComboBox` to ensure that the cell view displayed on
+     * the combo box’s button always gets enough space and does not resize
+     * when selection changes.
+     * @param fitModel - whether `cell_view` should request space for the whole model.
+     */
     setFitModel(fitModel) {
         call("libgtk-4.so.1", "gtk_cell_view_set_fit_model", [
             {
@@ -140,6 +232,12 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the model for @cell_view.  If `cell_view` already has a model
+     * set, it will remove it before setting the new model.  If `model` is
+     * %NULL, then it will unset the old model.
+     * @param model - a `GtkTreeModel`
+     */
     setModel(model) {
         call("libgtk-4.so.1", "gtk_cell_view_set_model", [
             {
@@ -153,6 +251,18 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds an attribute mapping to the list in @cell_layout.
+     *
+     * The `column` is the column of the model to get a value from, and the
+     * `attribute` is the property on `cell` to be set from that value. So for
+     * example if column 2 of the model contains strings, you could have the
+     * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+     * In this context "attribute" and "property" are used interchangeably.
+     * @param cell - a `GtkCellRenderer`
+     * @param attribute - a property on the renderer
+     * @param column - the column position on the model to get the attribute from
+     */
     addAttribute(cell, attribute, column) {
         call("libgtk-4.so.1", "gtk_cell_layout_add_attribute", [
             {
@@ -173,6 +283,10 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unsets all the mappings on all renderers on `cell_layout` and
+     * removes all renderers from @cell_layout.
+     */
     clear() {
         call("libgtk-4.so.1", "gtk_cell_layout_clear", [
             {
@@ -181,6 +295,11 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Clears all existing attributes previously set with
+     * gtk_cell_layout_set_attributes().
+     * @param cell - a `GtkCellRenderer` to clear the attribute mapping on
+     */
     clearAttributes(cell) {
         call("libgtk-4.so.1", "gtk_cell_layout_clear_attributes", [
             {
@@ -193,6 +312,10 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the underlying `GtkCellArea` which might be `cell_layout` if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+     * is used by @cell_layout.
+     */
     getArea() {
         const ptr = call("libgtk-4.so.1", "gtk_cell_layout_get_area", [
             {
@@ -204,6 +327,9 @@ export class CellView extends Widget {
             return null;
         return getObject(ptr, CellArea);
     }
+    /**
+     * Returns the cell renderers which have been added to @cell_layout.
+     */
     getCells() {
         const ptrs = call("libgtk-4.so.1", "gtk_cell_layout_get_cells", [
             {
@@ -218,6 +344,15 @@ export class CellView extends Widget {
         });
         return ptrs.map((ptr) => getObject(ptr, CellRenderer));
     }
+    /**
+     * Adds the `cell` to the end of @cell_layout. If `expand` is %FALSE, then the
+     * `cell` is allocated no more space than it needs. Any unused space is
+     * divided evenly between cells for which `expand` is %TRUE.
+     *
+     * Note that reusing the same cell renderer is not supported.
+     * @param cell - a `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @cell_layout
+     */
     packEnd(cell, expand) {
         call("libgtk-4.so.1", "gtk_cell_layout_pack_end", [
             {
@@ -234,6 +369,15 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Packs the `cell` into the beginning of @cell_layout. If `expand` is %FALSE,
+     * then the `cell` is allocated no more space than it needs. Any unused space
+     * is divided evenly between cells for which `expand` is %TRUE.
+     *
+     * Note that reusing the same cell renderer is not supported.
+     * @param cell - a `GtkCellRenderer`
+     * @param expand - %TRUE if `cell` is to be given extra space allocated to @cell_layout
+     */
     packStart(cell, expand) {
         call("libgtk-4.so.1", "gtk_cell_layout_pack_start", [
             {
@@ -250,6 +394,13 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Re-inserts `cell` at @position.
+     *
+     * Note that `cell` has already to be packed into `cell_layout` for this to function properly.
+     * @param cell - a `GtkCellRenderer` to reorder
+     * @param position - new position to insert `cell` at
+     */
     reorder(cell, position) {
         call("libgtk-4.so.1", "gtk_cell_layout_reorder", [
             {
@@ -266,6 +417,19 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkCellLayout`DataFunc to use for @cell_layout.
+     *
+     * This function is used instead of the standard attributes mapping
+     * for setting the column value, and should set the value of @cell_layout’s
+     * cell renderer(s) as appropriate.
+     *
+     * `func` may be %NULL to remove a previously set function.
+     * @param cell - a `GtkCellRenderer`
+     * @param func - the `GtkCellLayout`DataFunc to use
+     * @param funcData - user data for @func
+     * @param destroy - destroy notify for @func_data
+     */
     setCellDataFunc(cell, destroy, func, funcData) {
         call("libgtk-4.so.1", "gtk_cell_layout_set_cell_data_func", [
             {
@@ -292,6 +456,9 @@ export class CellView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_orientable_get_orientation", [
             {
@@ -300,6 +467,10 @@ export class CellView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation) {
         call("libgtk-4.so.1", "gtk_orientable_set_orientation", [
             {

package/dist/generated/gtk/center-box.d.ts

@@ -1,20 +1,123 @@
 import { BaselinePosition, Orientation } from "./enums.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Arranges three children in a row, keeping the middle child
+ * centered as well as possible.
+ *
+ *
+ *
+ * To add children to `GtkCenterBox`, use [method@Gtk.CenterBox.set_start_widget],
+ * [method@Gtk.CenterBox.set_center_widget] and
+ * [method@Gtk.CenterBox.set_end_widget].
+ *
+ * The sizing and positioning of children can be influenced with the
+ * align and expand properties of the children.
+ *
+ * # GtkCenterBox as GtkBuildable
+ *
+ * The `GtkCenterBox` implementation of the `GtkBuildable` interface
+ * supports placing children in the 3 positions by specifying “start”, “center”
+ * or “end” as the “type” attribute of a `<child>` element.
+ *
+ * # CSS nodes
+ *
+ * `GtkCenterBox` uses a single CSS node with the name “box”,
+ *
+ * The first child of the `GtkCenterBox` will be allocated depending on the
+ * text direction, i.e. in left-to-right layouts it will be allocated on the
+ * left and in right-to-left layouts on the right.
+ *
+ * In vertical orientation, the nodes of the children are arranged from top to
+ * bottom.
+ *
+ * # Accessibility
+ *
+ * Until GTK 4.10, `GtkCenterBox` used the [enum@Gtk.AccessibleRole.group] role.
+ *
+ * Starting from GTK 4.12, `GtkCenterBox` uses the [enum@Gtk.AccessibleRole.generic]
+ * role.
+ */
 export declare class CenterBox extends Widget {
+    /**
+     * Creates a new `GtkCenterBox`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the baseline position of the center box.
+     *
+     * See [method@Gtk.CenterBox.set_baseline_position].
+     */
     getBaselinePosition(): BaselinePosition;
+    /**
+     * Gets the center widget.
+     */
     getCenterWidget(): Widget | null;
+    /**
+     * Gets the end widget.
+     */
     getEndWidget(): Widget | null;
+    /**
+     * Gets whether the center widget shrinks after other children.
+     */
     getShrinkCenterLast(): boolean;
+    /**
+     * Gets the start widget.
+     */
     getStartWidget(): Widget | null;
+    /**
+     * Sets the baseline position of a center box.
+     *
+     * This affects only horizontal boxes with at least one baseline
+     * aligned child. If there is more vertical space available than
+     * requested, and the baseline is not allocated by the parent then
+     * `position` is used to allocate the baseline with respect to the
+     * extra space available.
+     * @param position - the baseline position
+     */
     setBaselinePosition(position: BaselinePosition): void;
+    /**
+     * Sets the center widget.
+     *
+     * To remove the existing center widget, pass `NULL`.
+     * @param child - the new center widget
+     */
     setCenterWidget(child?: Widget | null): void;
+    /**
+     * Sets the end widget.
+     *
+     * To remove the existing end widget, pass `NULL`.
+     * @param child - the new end widget
+     */
     setEndWidget(child?: Widget | null): void;
+    /**
+     * Sets whether to shrink the center widget after other children.
+     *
+     * By default, when there's no space to give all three children their
+     * natural widths, the start and end widgets start shrinking and the
+     * center child keeps natural width until they reach minimum width.
+     *
+     * If `shrink_center_last` is false, start and end widgets keep natural
+     * width and the center widget starts shrinking instead.
+     * @param shrinkCenterLast - whether to shrink the center widget after others
+     */
     setShrinkCenterLast(shrinkCenterLast: boolean): void;
+    /**
+     * Sets the start widget.
+     *
+     * To remove the existing start widget, pass `NULL`.
+     * @param child - the new start widget
+     */
     setStartWidget(child?: Widget | null): void;
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation(): Orientation;
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation: Orientation): void;
     connect(signal: "notify", handler: (self: CenterBox, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/center-box.js

@@ -1,7 +1,47 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
+/**
+ * Arranges three children in a row, keeping the middle child
+ * centered as well as possible.
+ *
+ *
+ *
+ * To add children to `GtkCenterBox`, use [method@Gtk.CenterBox.set_start_widget],
+ * [method@Gtk.CenterBox.set_center_widget] and
+ * [method@Gtk.CenterBox.set_end_widget].
+ *
+ * The sizing and positioning of children can be influenced with the
+ * align and expand properties of the children.
+ *
+ * # GtkCenterBox as GtkBuildable
+ *
+ * The `GtkCenterBox` implementation of the `GtkBuildable` interface
+ * supports placing children in the 3 positions by specifying “start”, “center”
+ * or “end” as the “type” attribute of a `<child>` element.
+ *
+ * # CSS nodes
+ *
+ * `GtkCenterBox` uses a single CSS node with the name “box”,
+ *
+ * The first child of the `GtkCenterBox` will be allocated depending on the
+ * text direction, i.e. in left-to-right layouts it will be allocated on the
+ * left and in right-to-left layouts on the right.
+ *
+ * In vertical orientation, the nodes of the children are arranged from top to
+ * bottom.
+ *
+ * # Accessibility
+ *
+ * Until GTK 4.10, `GtkCenterBox` used the [enum@Gtk.AccessibleRole.group] role.
+ *
+ * Starting from GTK 4.12, `GtkCenterBox` uses the [enum@Gtk.AccessibleRole.generic]
+ * role.
+ */
 export class CenterBox extends Widget {
+    /**
+     * Creates a new `GtkCenterBox`.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -11,6 +51,11 @@ export class CenterBox extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Gets the baseline position of the center box.
+     *
+     * See [method@Gtk.CenterBox.set_baseline_position].
+     */
     getBaselinePosition() {
         return call("libgtk-4.so.1", "gtk_center_box_get_baseline_position", [
             {
@@ -19,6 +64,9 @@ export class CenterBox extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the center widget.
+     */
     getCenterWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_center_box_get_center_widget", [
             {
@@ -30,6 +78,9 @@ export class CenterBox extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets the end widget.
+     */
     getEndWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_center_box_get_end_widget", [
             {
@@ -41,6 +92,9 @@ export class CenterBox extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets whether the center widget shrinks after other children.
+     */
     getShrinkCenterLast() {
         return call("libgtk-4.so.1", "gtk_center_box_get_shrink_center_last", [
             {
@@ -49,6 +103,9 @@ export class CenterBox extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the start widget.
+     */
     getStartWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_center_box_get_start_widget", [
             {
@@ -60,6 +117,16 @@ export class CenterBox extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Sets the baseline position of a center box.
+     *
+     * This affects only horizontal boxes with at least one baseline
+     * aligned child. If there is more vertical space available than
+     * requested, and the baseline is not allocated by the parent then
+     * `position` is used to allocate the baseline with respect to the
+     * extra space available.
+     * @param position - the baseline position
+     */
     setBaselinePosition(position) {
         call("libgtk-4.so.1", "gtk_center_box_set_baseline_position", [
             {
@@ -72,6 +139,12 @@ export class CenterBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the center widget.
+     *
+     * To remove the existing center widget, pass `NULL`.
+     * @param child - the new center widget
+     */
     setCenterWidget(child) {
         call("libgtk-4.so.1", "gtk_center_box_set_center_widget", [
             {
@@ -85,6 +158,12 @@ export class CenterBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the end widget.
+     *
+     * To remove the existing end widget, pass `NULL`.
+     * @param child - the new end widget
+     */
     setEndWidget(child) {
         call("libgtk-4.so.1", "gtk_center_box_set_end_widget", [
             {
@@ -98,6 +177,17 @@ export class CenterBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to shrink the center widget after other children.
+     *
+     * By default, when there's no space to give all three children their
+     * natural widths, the start and end widgets start shrinking and the
+     * center child keeps natural width until they reach minimum width.
+     *
+     * If `shrink_center_last` is false, start and end widgets keep natural
+     * width and the center widget starts shrinking instead.
+     * @param shrinkCenterLast - whether to shrink the center widget after others
+     */
     setShrinkCenterLast(shrinkCenterLast) {
         call("libgtk-4.so.1", "gtk_center_box_set_shrink_center_last", [
             {
@@ -110,6 +200,12 @@ export class CenterBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the start widget.
+     *
+     * To remove the existing start widget, pass `NULL`.
+     * @param child - the new start widget
+     */
     setStartWidget(child) {
         call("libgtk-4.so.1", "gtk_center_box_set_start_widget", [
             {
@@ -123,6 +219,9 @@ export class CenterBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_orientable_get_orientation", [
             {
@@ -131,6 +230,10 @@ export class CenterBox extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation) {
         call("libgtk-4.so.1", "gtk_orientable_set_orientation", [
             {