@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/cell-editable.d.ts

@@ -1,9 +1,35 @@
 import * as Gdk from "../gdk/index.js";
+/**
+ * Interface for widgets that can be used for editing cells
+ *
+ * The `GtkCellEditable` interface must be implemented for widgets to be usable
+ * to edit the contents of a `GtkTreeView` cell. It provides a way to specify how
+ * temporary widgets should be configured for editing, get the new value, etc.
+ */
 export declare class CellEditable {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): CellEditable;
+    /**
+     * Emits the `GtkCellEditable::editing-done` signal.
+     */
     editingDone(): void;
+    /**
+     * Emits the `GtkCellEditable::remove-widget` signal.
+     */
     removeWidget(): void;
+    /**
+     * Begins editing on a @cell_editable.
+     *
+     * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+     * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+     *
+     * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+     * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+     *
+     * Note that the `cell_editable` is created on-demand for the current edit; its
+     * lifetime is temporary and does not persist across other edits and/or cells.
+     * @param event - The `GdkEvent` that began the editing process, or
+     */
     startEditing(event?: Gdk.Event | null): void;
 }

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

@@ -1,4 +1,11 @@
 import { call } from "@gtkx/native";
+/**
+ * Interface for widgets that can be used for editing cells
+ *
+ * The `GtkCellEditable` interface must be implemented for widgets to be usable
+ * to edit the contents of a `GtkTreeView` cell. It provides a way to specify how
+ * temporary widgets should be configured for editing, get the new value, etc.
+ */
 export class CellEditable {
     ptr;
     constructor(ptr) {
@@ -7,6 +14,9 @@ export class CellEditable {
     static fromPtr(ptr) {
         return new CellEditable(ptr);
     }
+    /**
+     * Emits the `GtkCellEditable::editing-done` signal.
+     */
     editingDone() {
         call("libgtk-4.so.1", "gtk_cell_editable_editing_done", [
             {
@@ -15,6 +25,9 @@ export class CellEditable {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the `GtkCellEditable::remove-widget` signal.
+     */
     removeWidget() {
         call("libgtk-4.so.1", "gtk_cell_editable_remove_widget", [
             {
@@ -23,6 +36,19 @@ export class CellEditable {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Begins editing on a @cell_editable.
+     *
+     * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+     * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+     *
+     * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+     * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+     *
+     * Note that the `cell_editable` is created on-demand for the current edit; its
+     * lifetime is temporary and does not persist across other edits and/or cells.
+     * @param event - The `GdkEvent` that began the editing process, or
+     */
     startEditing(event) {
         call("libgtk-4.so.1", "gtk_cell_editable_start_editing", [
             {

package/dist/generated/gtk/cell-layout.d.ts

@@ -1,16 +1,192 @@
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * An interface for packing cells
+ *
+ * `GtkCellLayout` is an interface to be implemented by all objects which
+ * want to provide a `GtkTreeViewColumn` like API for packing cells,
+ * setting attributes and data funcs.
+ *
+ * One of the notable features provided by implementations of
+ * `GtkCellLayout` are attributes. Attributes let you set the properties
+ * in flexible ways. They can just be set to constant values like regular
+ * properties. But they can also be mapped to a column of the underlying
+ * tree model with gtk_cell_layout_set_attributes(), which means that the value
+ * of the attribute can change from cell to cell as they are rendered by
+ * the cell renderer. Finally, it is possible to specify a function with
+ * gtk_cell_layout_set_cell_data_func() that is called to determine the
+ * value of the attribute for each cell that is rendered.
+ *
+ * ## GtkCellLayouts as GtkBuildable
+ *
+ * Implementations of GtkCellLayout which also implement the GtkBuildable
+ * interface (`GtkCellView`, `GtkIconView`, `GtkComboBox`,
+ * `GtkEntryCompletion`, `GtkTreeViewColumn`) accept `GtkCellRenderer` objects
+ * as `<child>` elements in UI definitions. They support a custom `<attributes>`
+ * element for their children, which can contain multiple `<attribute>`
+ * elements. Each `<attribute>` element has a name attribute which specifies
+ * a property of the cell renderer; the content of the element is the
+ * attribute value.
+ *
+ * This is an example of a UI definition fragment specifying attributes:
+ *
+ * ```xml
+ * <object class="GtkCellView">
+ * <child>
+ * <object class="GtkCellRendererText"/>
+ * <attributes>
+ * <attribute name="text">0</attribute>
+ * </attributes>
+ * </child>
+ * </object>
+ * ```
+ *
+ * Furthermore for implementations of `GtkCellLayout` that use a `GtkCellArea`
+ * to lay out cells (all `GtkCellLayout`s in GTK use a `GtkCellArea`)
+ * cell properties can also be defined
+ * in the format by specifying the custom `<cell-packing>` attribute which can
+ * contain multiple `<property>` elements.
+ *
+ * Here is a UI definition fragment specifying cell properties:
+ *
+ * ```xml
+ * <object class="GtkTreeViewColumn">
+ * <child>
+ * <object class="GtkCellRendererText"/>
+ * <cell-packing>
+ * <property name="align">True</property>
+ * <property name="expand">False</property>
+ * </cell-packing>
+ * </child>
+ * </object>
+ * ```
+ *
+ * ## Subclassing GtkCellLayout implementations
+ *
+ * When subclassing a widget that implements `GtkCellLayout` like
+ * `GtkIconView` or `GtkComboBox`, there are some considerations related
+ * to the fact that these widgets internally use a `GtkCellArea`.
+ * The cell area is exposed as a construct-only property by these
+ * widgets. This means that it is possible to e.g. do
+ *
+ * ```c
+ * GtkWIdget *combo =
+ * g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL);
+ * ```
+ *
+ * to use a custom cell area with a combo box. But construct properties
+ * are only initialized after instance `init()`
+ * functions have run, which means that using functions which rely on
+ * the existence of the cell area in your subclass `init()` function will
+ * cause the default cell area to be instantiated. In this case, a provided
+ * construct property value will be ignored (with a warning, to alert
+ * you to the problem).
+ *
+ * ```c
+ * static void
+ * my_combo_box_init (MyComboBox *b)
+ * {
+ * GtkCellRenderer *cell;
+ *
+ * cell = gtk_cell_renderer_pixbuf_new ();
+ *
+ * // The following call causes the default cell area for combo boxes,
+ * // a GtkCellAreaBox, to be instantiated
+ * gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE);
+ * ...
+ * }
+ *
+ * GtkWidget *
+ * my_combo_box_new (GtkCellArea *area)
+ * {
+ * // This call is going to cause a warning about area being ignored
+ * return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL);
+ * }
+ * ```
+ *
+ * If supporting alternative cell areas with your derived widget is
+ * not important, then this does not have to concern you. If you want
+ * to support alternative cell areas, you can do so by moving the
+ * problematic calls out of `init()` and into a `constructor()`
+ * for your class.
+ */
 export declare class CellLayout {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): CellLayout;
+    /**
+     * 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: CellRenderer, attribute: string, column: number): void;
+    /**
+     * Unsets all the mappings on all renderers on `cell_layout` and
+     * removes all renderers from @cell_layout.
+     */
     clear(): void;
+    /**
+     * Clears all existing attributes previously set with
+     * gtk_cell_layout_set_attributes().
+     * @param cell - a `GtkCellRenderer` to clear the attribute mapping on
+     */
     clearAttributes(cell: CellRenderer): void;
+    /**
+     * 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(): CellArea | null;
+    /**
+     * Returns the cell renderers which have been added to @cell_layout.
+     */
     getCells(): 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: CellRenderer, expand: boolean): void;
+    /**
+     * 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: CellRenderer, expand: boolean): void;
+    /**
+     * 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: CellRenderer, position: number): void;
+    /**
+     * 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: CellRenderer, destroy: () => void, func?: (...args: unknown[]) => unknown | null, funcData?: number | null): void;
 }

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

@@ -2,6 +2,116 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * An interface for packing cells
+ *
+ * `GtkCellLayout` is an interface to be implemented by all objects which
+ * want to provide a `GtkTreeViewColumn` like API for packing cells,
+ * setting attributes and data funcs.
+ *
+ * One of the notable features provided by implementations of
+ * `GtkCellLayout` are attributes. Attributes let you set the properties
+ * in flexible ways. They can just be set to constant values like regular
+ * properties. But they can also be mapped to a column of the underlying
+ * tree model with gtk_cell_layout_set_attributes(), which means that the value
+ * of the attribute can change from cell to cell as they are rendered by
+ * the cell renderer. Finally, it is possible to specify a function with
+ * gtk_cell_layout_set_cell_data_func() that is called to determine the
+ * value of the attribute for each cell that is rendered.
+ *
+ * ## GtkCellLayouts as GtkBuildable
+ *
+ * Implementations of GtkCellLayout which also implement the GtkBuildable
+ * interface (`GtkCellView`, `GtkIconView`, `GtkComboBox`,
+ * `GtkEntryCompletion`, `GtkTreeViewColumn`) accept `GtkCellRenderer` objects
+ * as `<child>` elements in UI definitions. They support a custom `<attributes>`
+ * element for their children, which can contain multiple `<attribute>`
+ * elements. Each `<attribute>` element has a name attribute which specifies
+ * a property of the cell renderer; the content of the element is the
+ * attribute value.
+ *
+ * This is an example of a UI definition fragment specifying attributes:
+ *
+ * ```xml
+ * <object class="GtkCellView">
+ * <child>
+ * <object class="GtkCellRendererText"/>
+ * <attributes>
+ * <attribute name="text">0</attribute>
+ * </attributes>
+ * </child>
+ * </object>
+ * ```
+ *
+ * Furthermore for implementations of `GtkCellLayout` that use a `GtkCellArea`
+ * to lay out cells (all `GtkCellLayout`s in GTK use a `GtkCellArea`)
+ * cell properties can also be defined
+ * in the format by specifying the custom `<cell-packing>` attribute which can
+ * contain multiple `<property>` elements.
+ *
+ * Here is a UI definition fragment specifying cell properties:
+ *
+ * ```xml
+ * <object class="GtkTreeViewColumn">
+ * <child>
+ * <object class="GtkCellRendererText"/>
+ * <cell-packing>
+ * <property name="align">True</property>
+ * <property name="expand">False</property>
+ * </cell-packing>
+ * </child>
+ * </object>
+ * ```
+ *
+ * ## Subclassing GtkCellLayout implementations
+ *
+ * When subclassing a widget that implements `GtkCellLayout` like
+ * `GtkIconView` or `GtkComboBox`, there are some considerations related
+ * to the fact that these widgets internally use a `GtkCellArea`.
+ * The cell area is exposed as a construct-only property by these
+ * widgets. This means that it is possible to e.g. do
+ *
+ * ```c
+ * GtkWIdget *combo =
+ * g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL);
+ * ```
+ *
+ * to use a custom cell area with a combo box. But construct properties
+ * are only initialized after instance `init()`
+ * functions have run, which means that using functions which rely on
+ * the existence of the cell area in your subclass `init()` function will
+ * cause the default cell area to be instantiated. In this case, a provided
+ * construct property value will be ignored (with a warning, to alert
+ * you to the problem).
+ *
+ * ```c
+ * static void
+ * my_combo_box_init (MyComboBox *b)
+ * {
+ * GtkCellRenderer *cell;
+ *
+ * cell = gtk_cell_renderer_pixbuf_new ();
+ *
+ * // The following call causes the default cell area for combo boxes,
+ * // a GtkCellAreaBox, to be instantiated
+ * gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE);
+ * ...
+ * }
+ *
+ * GtkWidget *
+ * my_combo_box_new (GtkCellArea *area)
+ * {
+ * // This call is going to cause a warning about area being ignored
+ * return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL);
+ * }
+ * ```
+ *
+ * If supporting alternative cell areas with your derived widget is
+ * not important, then this does not have to concern you. If you want
+ * to support alternative cell areas, you can do so by moving the
+ * problematic calls out of `init()` and into a `constructor()`
+ * for your class.
+ */
 export class CellLayout {
     ptr;
     constructor(ptr) {
@@ -10,6 +120,18 @@ export class CellLayout {
     static fromPtr(ptr) {
         return new CellLayout(ptr);
     }
+    /**
+     * 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", [
             {
@@ -30,6 +152,10 @@ export class CellLayout {
             },
         ], { 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", [
             {
@@ -38,6 +164,11 @@ export class CellLayout {
             },
         ], { 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", [
             {
@@ -50,6 +181,10 @@ export class CellLayout {
             },
         ], { 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", [
             {
@@ -61,6 +196,9 @@ export class CellLayout {
             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", [
             {
@@ -75,6 +213,15 @@ export class CellLayout {
         });
         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", [
             {
@@ -91,6 +238,15 @@ export class CellLayout {
             },
         ], { 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", [
             {
@@ -107,6 +263,13 @@ export class CellLayout {
             },
         ], { 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", [
             {
@@ -123,6 +286,19 @@ export class CellLayout {
             },
         ], { 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", [
             {

package/dist/generated/gtk/cell-renderer-accel.d.ts

@@ -2,6 +2,9 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { CellRendererText } from "./cell-renderer-text.js";
 export declare class CellRendererAccel extends CellRendererText {
+    /**
+     * Creates a new `GtkCellRendererAccel`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "accel-cleared", handler: (self: CellRendererAccel, pathString: string) => void, after?: boolean): number;

package/dist/generated/gtk/cell-renderer-accel.js

@@ -1,6 +1,13 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRendererText } from "./cell-renderer-text.js";
+/**
+ * Renders a keyboard accelerator in a cell
+ *
+ * `GtkCellRendererAccel` displays a keyboard accelerator (i.e. a key
+ * combination like `Control + a`). If the cell renderer is editable,
+ * the accelerator can be changed by simply typing the new combination.
+ */
 const SIGNAL_META = {
     "accel-cleared": {
         params: [{ type: { type: "string", borrowed: false } }],
@@ -24,6 +31,9 @@ const SIGNAL_META = {
     },
 };
 export class CellRendererAccel extends CellRendererText {
+    /**
+     * Creates a new `GtkCellRendererAccel`.
+     */
     constructor(...args) {
         super(...args);
     }

package/dist/generated/gtk/cell-renderer-combo.d.ts

@@ -2,6 +2,15 @@ import { TreeIter } from "./tree-iter.js";
 import * as GObject from "../gobject/index.js";
 import { CellRendererText } from "./cell-renderer-text.js";
 export declare class CellRendererCombo extends CellRendererText {
+    /**
+     * Creates a new `GtkCellRendererCombo`.
+     * Adjust how text is drawn using object properties.
+     * Object properties can be set globally (with g_object_set()).
+     * Also, with `GtkTreeViewColumn`, you can bind a property to a value
+     * in a `GtkTreeModel`. For example, you can bind the “text” property
+     * on the cell renderer to a string value in the model, thus rendering
+     * a different string in each row of the `GtkTreeView`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "changed", handler: (self: CellRendererCombo, pathString: string, newIter: TreeIter) => void, after?: boolean): number;

package/dist/generated/gtk/cell-renderer-combo.js

@@ -1,6 +1,20 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRendererText } from "./cell-renderer-text.js";
+/**
+ * Renders a combobox in a cell
+ *
+ * `GtkCellRendererCombo` renders text in a cell like `GtkCellRendererText` from
+ * which it is derived. But while `GtkCellRendererText` offers a simple entry to
+ * edit the text, `GtkCellRendererCombo` offers a `GtkComboBox`
+ * widget to edit the text. The values to display in the combo box are taken from
+ * the tree model specified in the `GtkCellRendererCombo`:model property.
+ *
+ * The combo cell renderer takes care of adding a text cell renderer to the combo
+ * box and sets it to display the column specified by its
+ * `GtkCellRendererCombo`:text-column property. Further properties of the combo box
+ * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
+ */
 const SIGNAL_META = {
     changed: {
         params: [
@@ -18,6 +32,15 @@ const SIGNAL_META = {
     },
 };
 export class CellRendererCombo extends CellRendererText {
+    /**
+     * Creates a new `GtkCellRendererCombo`.
+     * Adjust how text is drawn using object properties.
+     * Object properties can be set globally (with g_object_set()).
+     * Also, with `GtkTreeViewColumn`, you can bind a property to a value
+     * in a `GtkTreeModel`. For example, you can bind the “text” property
+     * on the cell renderer to a string value in the model, thus rendering
+     * a different string in each row of the `GtkTreeView`.
+     */
     constructor(...args) {
         super(...args);
     }

package/dist/generated/gtk/cell-renderer-pixbuf.d.ts

@@ -1,6 +1,31 @@
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders a pixbuf in a cell
+ *
+ * A `GtkCellRendererPixbuf` can be used to render an image in a cell. It allows
+ * to render either a given `GdkPixbuf` (set via the
+ * `GtkCellRendererPixbuf:pixbuf` property) or a named icon (set via the
+ * `GtkCellRendererPixbuf:icon-name` property).
+ *
+ * To support the tree view, `GtkCellRendererPixbuf` also supports rendering two
+ * alternative pixbufs, when the `GtkCellRenderer:is-expander` property is %TRUE.
+ * If the `GtkCellRenderer:is-expanded property` is %TRUE and the
+ * `GtkCellRendererPixbuf:pixbuf-expander-open` property is set to a pixbuf, it
+ * renders that pixbuf, if the `GtkCellRenderer:is-expanded` property is %FALSE
+ * and the `GtkCellRendererPixbuf:pixbuf-expander-closed` property is set to a
+ * pixbuf, it renders that one.
+ */
 export declare class CellRendererPixbuf extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererPixbuf`. Adjust rendering
+     * parameters using object properties. Object properties can be set
+     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
+     * can bind a property to a value in a `GtkTreeModel`. For example, you
+     * can bind the “pixbuf” property on the cell renderer to a pixbuf value
+     * in the model, thus rendering a different image in each row of the
+     * `GtkTreeView`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "notify", handler: (self: CellRendererPixbuf, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/gtk/cell-renderer-pixbuf.js

@@ -1,7 +1,32 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { CellRenderer } from "./cell-renderer.js";
+/**
+ * Renders a pixbuf in a cell
+ *
+ * A `GtkCellRendererPixbuf` can be used to render an image in a cell. It allows
+ * to render either a given `GdkPixbuf` (set via the
+ * `GtkCellRendererPixbuf:pixbuf` property) or a named icon (set via the
+ * `GtkCellRendererPixbuf:icon-name` property).
+ *
+ * To support the tree view, `GtkCellRendererPixbuf` also supports rendering two
+ * alternative pixbufs, when the `GtkCellRenderer:is-expander` property is %TRUE.
+ * If the `GtkCellRenderer:is-expanded property` is %TRUE and the
+ * `GtkCellRendererPixbuf:pixbuf-expander-open` property is set to a pixbuf, it
+ * renders that pixbuf, if the `GtkCellRenderer:is-expanded` property is %FALSE
+ * and the `GtkCellRendererPixbuf:pixbuf-expander-closed` property is set to a
+ * pixbuf, it renders that one.
+ */
 export class CellRendererPixbuf extends CellRenderer {
+    /**
+     * Creates a new `GtkCellRendererPixbuf`. Adjust rendering
+     * parameters using object properties. Object properties can be set
+     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
+     * can bind a property to a value in a `GtkTreeModel`. For example, you
+     * can bind the “pixbuf” property on the cell renderer to a pixbuf value
+     * in the model, thus rendering a different image in each row of the
+     * `GtkTreeView`.
+     */
     constructor(...args) {
         super(...args);
     }