@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -3,6 +3,72 @@ import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { ListBoxRow } from "./list-box-row.js";
 import { Widget } from "./widget.js";
+/**
+ * Shows a vertical list.
+ *
+ *
+ *
+ * A `GtkListBox` only contains `GtkListBoxRow` children. These rows can
+ * by dynamically sorted and filtered, and headers can be added dynamically
+ * depending on the row content. It also allows keyboard and mouse navigation
+ * and selection like a typical list.
+ *
+ * Using `GtkListBox` is often an alternative to `GtkTreeView`, especially
+ * when the list contents has a more complicated layout than what is allowed
+ * by a `GtkCellRenderer`, or when the contents is interactive (i.e. has a
+ * button in it).
+ *
+ * Although a `GtkListBox` must have only `GtkListBoxRow` children, you can
+ * add any kind of widget to it via [method@Gtk.ListBox.prepend],
+ * [method@Gtk.ListBox.append] and [method@Gtk.ListBox.insert] and a
+ * `GtkListBoxRow` widget will automatically be inserted between the list
+ * and the widget.
+ *
+ * `GtkListBoxRows` can be marked as activatable or selectable. If a row is
+ * activatable, [signal@Gtk.ListBox::row-activated] will be emitted for it when
+ * the user tries to activate it. If it is selectable, the row will be marked
+ * as selected when the user tries to select it.
+ *
+ * # GtkListBox as GtkBuildable
+ *
+ * The `GtkListBox` implementation of the `GtkBuildable` interface supports
+ * setting a child as the placeholder by specifying “placeholder” as the “type”
+ * attribute of a `<child>` element. See [method@Gtk.ListBox.set_placeholder]
+ * for info.
+ *
+ * # Shortcuts and Gestures
+ *
+ * The following signals have default keybindings:
+ *
+ * - [signal@Gtk.ListBox::move-cursor]
+ * - [signal@Gtk.ListBox::select-all]
+ * - [signal@Gtk.ListBox::toggle-cursor-row]
+ * - [signal@Gtk.ListBox::unselect-all]
+ *
+ * # CSS nodes
+ *
+ * ```
+ * list[.separators][.rich-list][.navigation-sidebar][.boxed-list]
+ * ╰── row[.activatable]
+ * ```
+ *
+ * `GtkListBox` uses a single CSS node named list. It may carry the .separators
+ * style class, when the [property@Gtk.ListBox:show-separators] property is set.
+ * Each `GtkListBoxRow` uses a single CSS node named row. The row nodes get the
+ * .activatable style class added when appropriate.
+ *
+ * It may also carry the .boxed-list style class. In this case, the list will be
+ * automatically surrounded by a frame and have separators.
+ *
+ * The main list node may also carry style classes to select
+ * the style of list presentation:
+ * .rich-list, .navigation-sidebar or .data-table.
+ *
+ * # Accessibility
+ *
+ * `GtkListBox` uses the [enum@Gtk.AccessibleRole.list] role and `GtkListBoxRow` uses
+ * the [enum@Gtk.AccessibleRole.list_item] role.
+ */
 const SIGNAL_META = {
     "activate-cursor-row": { params: [], returnType: { type: "undefined" } },
     "move-cursor": {
@@ -32,6 +98,9 @@ const SIGNAL_META = {
     "unselect-all": { params: [], returnType: { type: "undefined" } },
 };
 export class ListBox extends Widget {
+    /**
+     * Creates a new `GtkListBox` container.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -41,6 +110,13 @@ export class ListBox extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Append a widget to the list.
+     *
+     * If a sort function is set, the widget will
+     * actually be inserted at the calculated position.
+     * @param child - the `GtkWidget` to add
+     */
     append(child) {
         call("libgtk-4.so.1", "gtk_list_box_append", [
             {
@@ -53,6 +129,27 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Binds `model` to @box.
+     *
+     * If `box` was already bound to a model, that previous binding is
+     * destroyed.
+     *
+     * The contents of `box` are cleared and then filled with widgets that
+     * represent items from @model. `box` is updated whenever `model` changes.
+     * If `model` is %NULL, `box` is left empty.
+     *
+     * It is undefined to add or remove widgets directly (for example, with
+     * [method@Gtk.ListBox.insert]) while `box` is bound to a model.
+     *
+     * Note that using a model is incompatible with the filtering and sorting
+     * functionality in `GtkListBox`. When using a model, filtering and sorting
+     * should be implemented by the model.
+     * @param model - the `GListModel` to be bound to @box
+     * @param createWidgetFunc - a function
+     * @param userData - user data passed to @create_widget_func
+     * @param userDataFreeFunc - function for freeing @user_data
+     */
     bindModel(userDataFreeFunc, model, createWidgetFunc, userData) {
         call("libgtk-4.so.1", "gtk_list_box_bind_model", [
             {
@@ -80,6 +177,18 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Add a drag highlight to a row.
+     *
+     * This is a helper function for implementing DnD onto a `GtkListBox`.
+     * The passed in `row` will be highlighted by setting the
+     * %GTK_STATE_FLAG_DROP_ACTIVE state and any previously highlighted
+     * row will be unhighlighted.
+     *
+     * The row will also be unhighlighted when the widget gets
+     * a drag leave event.
+     * @param row - a `GtkListBoxRow`
+     */
     dragHighlightRow(row) {
         call("libgtk-4.so.1", "gtk_list_box_drag_highlight_row", [
             {
@@ -92,6 +201,10 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If a row has previously been highlighted via gtk_list_box_drag_highlight_row(),
+     * it will have the highlight removed.
+     */
     dragUnhighlightRow() {
         call("libgtk-4.so.1", "gtk_list_box_drag_unhighlight_row", [
             {
@@ -100,6 +213,9 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether rows activate on single clicks.
+     */
     getActivateOnSingleClick() {
         return call("libgtk-4.so.1", "gtk_list_box_get_activate_on_single_click", [
             {
@@ -108,6 +224,10 @@ export class ListBox extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the adjustment (if any) that the widget uses to
+     * for vertical scrolling.
+     */
     getAdjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_list_box_get_adjustment", [
             {
@@ -119,6 +239,13 @@ export class ListBox extends Widget {
             return null;
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Gets the n-th child in the list (not counting headers).
+     *
+     * If `index_` is negative or larger than the number of items in the
+     * list, %NULL is returned.
+     * @param index_ - the index of the row
+     */
     getRowAtIndex(index_) {
         const ptr = call("libgtk-4.so.1", "gtk_list_box_get_row_at_index", [
             {
@@ -134,6 +261,10 @@ export class ListBox extends Widget {
             return null;
         return getObject(ptr, ListBoxRow);
     }
+    /**
+     * Gets the row at the `y` position.
+     * @param y - position
+     */
     getRowAtY(y) {
         const ptr = call("libgtk-4.so.1", "gtk_list_box_get_row_at_y", [
             {
@@ -149,6 +280,13 @@ export class ListBox extends Widget {
             return null;
         return getObject(ptr, ListBoxRow);
     }
+    /**
+     * Gets the selected row, or %NULL if no rows are selected.
+     *
+     * Note that the box may allow multiple selection, in which
+     * case you should use [method@Gtk.ListBox.selected_foreach] to
+     * find all selected rows.
+     */
     getSelectedRow() {
         const ptr = call("libgtk-4.so.1", "gtk_list_box_get_selected_row", [
             {
@@ -160,6 +298,9 @@ export class ListBox extends Widget {
             return null;
         return getObject(ptr, ListBoxRow);
     }
+    /**
+     * Creates a list of all selected children.
+     */
     getSelectedRows() {
         const ptrs = call("libgtk-4.so.1", "gtk_list_box_get_selected_rows", [
             {
@@ -174,6 +315,9 @@ export class ListBox extends Widget {
         });
         return ptrs.map((ptr) => getObject(ptr, ListBoxRow));
     }
+    /**
+     * Gets the selection mode of the listbox.
+     */
     getSelectionMode() {
         return call("libgtk-4.so.1", "gtk_list_box_get_selection_mode", [
             {
@@ -182,6 +326,10 @@ export class ListBox extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns whether the list box should show separators
+     * between rows.
+     */
     getShowSeparators() {
         return call("libgtk-4.so.1", "gtk_list_box_get_show_separators", [
             {
@@ -190,6 +338,9 @@ export class ListBox extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the behavior of the `Tab` and `Shift`+`Tab` keys.
+     */
     getTabBehavior() {
         return call("libgtk-4.so.1", "gtk_list_box_get_tab_behavior", [
             {
@@ -198,6 +349,17 @@ export class ListBox extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Insert the `child` into the `box` at @position.
+     *
+     * If a sort function is
+     * set, the widget will actually be inserted at the calculated position.
+     *
+     * If `position` is -1, or larger than the total number of items in the
+     * @box, then the `child` will be appended to the end.
+     * @param child - the `GtkWidget` to add
+     * @param position - the position to insert `child` in
+     */
     insert(child, position) {
         call("libgtk-4.so.1", "gtk_list_box_insert", [
             {
@@ -214,6 +376,15 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Update the filtering for all rows.
+     *
+     * Call this when result
+     * of the filter function on the `box` is changed due
+     * to an external factor. For instance, this would be used
+     * if the filter function just looked for a specific search
+     * string and the entry with the search string has changed.
+     */
     invalidateFilter() {
         call("libgtk-4.so.1", "gtk_list_box_invalidate_filter", [
             {
@@ -222,6 +393,13 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Update the separators for all rows.
+     *
+     * Call this when result
+     * of the header function on the `box` is changed due
+     * to an external factor.
+     */
     invalidateHeaders() {
         call("libgtk-4.so.1", "gtk_list_box_invalidate_headers", [
             {
@@ -230,6 +408,13 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Update the sorting for all rows.
+     *
+     * Call this when result
+     * of the sort function on the `box` is changed due
+     * to an external factor.
+     */
     invalidateSort() {
         call("libgtk-4.so.1", "gtk_list_box_invalidate_sort", [
             {
@@ -238,6 +423,13 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Prepend a widget to the list.
+     *
+     * If a sort function is set, the widget will
+     * actually be inserted at the calculated position.
+     * @param child - the `GtkWidget` to add
+     */
     prepend(child) {
         call("libgtk-4.so.1", "gtk_list_box_prepend", [
             {
@@ -250,6 +442,10 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes a child from @box.
+     * @param child - the child to remove
+     */
     remove(child) {
         call("libgtk-4.so.1", "gtk_list_box_remove", [
             {
@@ -262,6 +458,11 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes all rows from @box.
+     *
+     * This function does nothing if `box` is backed by a model.
+     */
     removeAll() {
         call("libgtk-4.so.1", "gtk_list_box_remove_all", [
             {
@@ -270,6 +471,9 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Select all children of @box, if the selection mode allows it.
+     */
     selectAll() {
         call("libgtk-4.so.1", "gtk_list_box_select_all", [
             {
@@ -278,6 +482,10 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Make `row` the currently selected row.
+     * @param row - The row to select
+     */
     selectRow(row) {
         call("libgtk-4.so.1", "gtk_list_box_select_row", [
             {
@@ -291,6 +499,13 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Calls a function for each selected child.
+     *
+     * Note that the selection cannot be modified from within this function.
+     * @param func - the function to call for each selected child
+     * @param data - user data to pass to the function
+     */
     selectedForeach(func, data) {
         call("libgtk-4.so.1", "gtk_list_box_selected_foreach", [
             {
@@ -308,6 +523,11 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If `single` is %TRUE, rows will be activated when you click on them,
+     * otherwise you need to double-click.
+     * @param single - a boolean
+     */
     setActivateOnSingleClick(single) {
         call("libgtk-4.so.1", "gtk_list_box_set_activate_on_single_click", [
             {
@@ -320,6 +540,19 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the adjustment (if any) that the widget uses to
+     * for vertical scrolling.
+     *
+     * For instance, this is used to get the page size for
+     * PageUp/Down key handling.
+     *
+     * In the normal case when the `box` is packed inside
+     * a `GtkScrolledWindow` the adjustment from that will
+     * be picked up automatically, so there is no need
+     * to manually do that.
+     * @param adjustment - the adjustment
+     */
     setAdjustment(adjustment) {
         call("libgtk-4.so.1", "gtk_list_box_set_adjustment", [
             {
@@ -333,6 +566,24 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * By setting a filter function on the `box` one can decide dynamically which
+     * of the rows to show.
+     *
+     * For instance, to implement a search function on a list that
+     * filters the original list to only show the matching rows.
+     *
+     * The `filter_func` will be called for each row after the call, and
+     * it will continue to be called each time a row changes (via
+     * [method@Gtk.ListBoxRow.changed]) or when [method@Gtk.ListBox.invalidate_filter]
+     * is called.
+     *
+     * Note that using a filter function is incompatible with using a model
+     * (see [method@Gtk.ListBox.bind_model]).
+     * @param filterFunc - callback
+     * @param userData - user data passed to @filter_func
+     * @param destroy - destroy notifier for @user_data
+     */
     setFilterFunc(destroy, filterFunc, userData) {
         call("libgtk-4.so.1", "gtk_list_box_set_filter_func", [
             {
@@ -355,6 +606,36 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a header function.
+     *
+     * By setting a header function on the `box` one can dynamically add headers
+     * in front of rows, depending on the contents of the row and its position
+     * in the list.
+     *
+     * For instance, one could use it to add headers in front of the first item
+     * of a new kind, in a list sorted by the kind.
+     *
+     * The `update_header` can look at the current header widget using
+     * [method@Gtk.ListBoxRow.get_header] and either update the state of the widget
+     * as needed, or set a new one using [method@Gtk.ListBoxRow.set_header]. If no
+     * header is needed, set the header to %NULL.
+     *
+     * Note that you may get many calls `update_header` to this for a particular
+     * row when e.g. changing things that don’t affect the header. In this case
+     * it is important for performance to not blindly replace an existing header
+     * with an identical one.
+     *
+     * The `update_header` function will be called for each row after the call,
+     * and it will continue to be called each time a row changes (via
+     * [method@Gtk.ListBoxRow.changed]) and when the row before changes (either
+     * by [method@Gtk.ListBoxRow.changed] on the previous row, or when the previous
+     * row becomes a different row). It is also called for all rows when
+     * [method@Gtk.ListBox.invalidate_headers] is called.
+     * @param updateHeader - callback
+     * @param userData - user data passed to @update_header
+     * @param destroy - destroy notifier for @user_data
+     */
     setHeaderFunc(destroy, updateHeader, userData) {
         call("libgtk-4.so.1", "gtk_list_box_set_header_func", [
             {
@@ -377,6 +658,11 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the placeholder widget that is shown in the list when
+     * it doesn't display any visible children.
+     * @param placeholder - a `GtkWidget`
+     */
     setPlaceholder(placeholder) {
         call("libgtk-4.so.1", "gtk_list_box_set_placeholder", [
             {
@@ -390,6 +676,10 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets how selection works in the listbox.
+     * @param mode - The `GtkSelectionMode`
+     */
     setSelectionMode(mode) {
         call("libgtk-4.so.1", "gtk_list_box_set_selection_mode", [
             {
@@ -402,6 +692,11 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the list box should show separators
+     * between rows.
+     * @param showSeparators - %TRUE to show separators
+     */
     setShowSeparators(showSeparators) {
         call("libgtk-4.so.1", "gtk_list_box_set_show_separators", [
             {
@@ -414,6 +709,23 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a sort function.
+     *
+     * By setting a sort function on the `box` one can dynamically reorder
+     * the rows of the list, based on the contents of the rows.
+     *
+     * The `sort_func` will be called for each row after the call, and will
+     * continue to be called each time a row changes (via
+     * [method@Gtk.ListBoxRow.changed]) and when [method@Gtk.ListBox.invalidate_sort]
+     * is called.
+     *
+     * Note that using a sort function is incompatible with using a model
+     * (see [method@Gtk.ListBox.bind_model]).
+     * @param sortFunc - the sort function
+     * @param userData - user data passed to @sort_func
+     * @param destroy - destroy notifier for @user_data
+     */
     setSortFunc(destroy, sortFunc, userData) {
         call("libgtk-4.so.1", "gtk_list_box_set_sort_func", [
             {
@@ -436,6 +748,10 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the behavior of the `Tab` and `Shift`+`Tab` keys.
+     * @param behavior - the tab behavior
+     */
     setTabBehavior(behavior) {
         call("libgtk-4.so.1", "gtk_list_box_set_tab_behavior", [
             {
@@ -448,6 +764,9 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unselect all children of @box, if the selection mode allows it.
+     */
     unselectAll() {
         call("libgtk-4.so.1", "gtk_list_box_unselect_all", [
             {
@@ -456,6 +775,10 @@ export class ListBox extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unselects a single row of @box, if the selection mode allows it.
+     * @param row - the row to unselect
+     */
     unselectRow(row) {
         call("libgtk-4.so.1", "gtk_list_box_unselect_row", [
             {

package/dist/generated/gtk/list-header.d.ts

@@ -1,13 +1,56 @@
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Used by list widgets to represent the headers they display.
+ *
+ * `GtkListHeader` objects are managed just like [class@Gtk.ListItem]
+ * objects via their factory, but provide a different set of properties suitable
+ * for managing the header instead of individual items.
+ */
 export declare class ListHeader extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the child previously set via gtk_list_header_set_child() or
+     * %NULL if none was set.
+     */
     getChild(): Widget | null;
+    /**
+     * Gets the end position in the model of the section that `self` is
+     * currently the header for.
+     *
+     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+     */
     getEnd(): number;
+    /**
+     * Gets the model item at the start of the section.
+     * This is the item that occupies the list model at position
+     * [property@Gtk.ListHeader:start].
+     *
+     * If `self` is unbound, this function returns %NULL.
+     */
     getItem(): GObject.GObject | null;
+    /**
+     * Gets the the number of items in the section.
+     *
+     * If `self` is unbound, 0 is returned.
+     */
     getNItems(): number;
+    /**
+     * Gets the start position in the model of the section that `self` is
+     * currently the header for.
+     *
+     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+     */
     getStart(): number;
+    /**
+     * Sets the child to be used for this listitem.
+     *
+     * This function is typically called by applications when
+     * setting up a header so that the widget can be reused when
+     * binding it multiple times.
+     * @param child - The list item's child or %NULL to unset
+     */
     setChild(child?: Widget | null): void;
     connect(signal: "notify", handler: (self: ListHeader, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/list-header.js

@@ -2,6 +2,13 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Used by list widgets to represent the headers they display.
+ *
+ * `GtkListHeader` objects are managed just like [class@Gtk.ListItem]
+ * objects via their factory, but provide a different set of properties suitable
+ * for managing the header instead of individual items.
+ */
 export class ListHeader extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -17,6 +24,10 @@ export class ListHeader extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the child previously set via gtk_list_header_set_child() or
+     * %NULL if none was set.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_list_header_get_child", [
             {
@@ -28,6 +39,12 @@ export class ListHeader extends GObject.GObject {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets the end position in the model of the section that `self` is
+     * currently the header for.
+     *
+     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+     */
     getEnd() {
         return call("libgtk-4.so.1", "gtk_list_header_get_end", [
             {
@@ -36,6 +53,13 @@ export class ListHeader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the model item at the start of the section.
+     * This is the item that occupies the list model at position
+     * [property@Gtk.ListHeader:start].
+     *
+     * If `self` is unbound, this function returns %NULL.
+     */
     getItem() {
         const ptr = call("libgtk-4.so.1", "gtk_list_header_get_item", [
             {
@@ -47,6 +71,11 @@ export class ListHeader extends GObject.GObject {
             return null;
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Gets the the number of items in the section.
+     *
+     * If `self` is unbound, 0 is returned.
+     */
     getNItems() {
         return call("libgtk-4.so.1", "gtk_list_header_get_n_items", [
             {
@@ -55,6 +84,12 @@ export class ListHeader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the start position in the model of the section that `self` is
+     * currently the header for.
+     *
+     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+     */
     getStart() {
         return call("libgtk-4.so.1", "gtk_list_header_get_start", [
             {
@@ -63,6 +98,14 @@ export class ListHeader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Sets the child to be used for this listitem.
+     *
+     * This function is typically called by applications when
+     * setting up a header so that the widget can be reused when
+     * binding it multiple times.
+     * @param child - The list item's child or %NULL to unset
+     */
     setChild(child) {
         call("libgtk-4.so.1", "gtk_list_header_set_child", [
             {