@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/filter-list-model.js

@@ -3,6 +3,18 @@ import { getObject } from "@gtkx/ffi";
 import { Filter } from "./filter.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * A list model that filters the elements of another model.
+ *
+ * It hides some elements from the underlying model according to
+ * criteria given by a `GtkFilter`.
+ *
+ * The model can be set up to do incremental filtering, so that
+ * filtering long lists doesn't block the UI. See
+ * [method@Gtk.FilterListModel.set_incremental] for details.
+ *
+ * `GtkFilterListModel` passes through sections from the underlying model.
+ */
 export class FilterListModel extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -22,6 +34,9 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the `GtkFilter` currently set on @self.
+     */
     getFilter() {
         const ptr = call("libgtk-4.so.1", "gtk_filter_list_model_get_filter", [
             {
@@ -33,6 +48,11 @@ export class FilterListModel extends GObject.GObject {
             return null;
         return getObject(ptr, Filter);
     }
+    /**
+     * Returns whether incremental filtering is enabled.
+     *
+     * See [method@Gtk.FilterListModel.set_incremental].
+     */
     getIncremental() {
         return call("libgtk-4.so.1", "gtk_filter_list_model_get_incremental", [
             {
@@ -41,6 +61,9 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the model currently filtered or %NULL if none.
+     */
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_filter_list_model_get_model", [
             {
@@ -52,6 +75,24 @@ export class FilterListModel extends GObject.GObject {
             return null;
         return getObject(ptr, Gio.ListModel);
     }
+    /**
+     * Returns the number of items that have not been filtered yet.
+     *
+     * You can use this value to check if `self` is busy filtering by
+     * comparing the return value to 0 or you can compute the percentage
+     * of the filter remaining by dividing the return value by the total
+     * number of items in the underlying model:
+     *
+     * ```c
+     * pending = gtk_filter_list_model_get_pending (self);
+     * model = gtk_filter_list_model_get_model (self);
+     * percentage = pending / (double) g_list_model_get_n_items (model);
+     * ```
+     *
+     * If no filter operation is ongoing - in particular when
+     * [property@Gtk.FilterListModel:incremental] is %FALSE - this
+     * function returns 0.
+     */
     getPending() {
         return call("libgtk-4.so.1", "gtk_filter_list_model_get_pending", [
             {
@@ -60,6 +101,11 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Returns whether watching items is enabled.
+     *
+     * See [method@Gtk.FilterListModel.set_watch_items].
+     */
     getWatchItems() {
         return call("libgtk-4.so.1", "gtk_filter_list_model_get_watch_items", [
             {
@@ -68,6 +114,10 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets the filter used to filter items.
+     * @param filter - filter to use
+     */
     setFilter(filter) {
         call("libgtk-4.so.1", "gtk_filter_list_model_set_filter", [
             {
@@ -81,6 +131,25 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the filter model to do an incremental sort.
+     *
+     * When incremental filtering is enabled, the `GtkFilterListModel` will not
+     * run filters immediately, but will instead queue an idle handler that
+     * incrementally filters the items and adds them to the list. This of course
+     * means that items are not instantly added to the list, but only appear
+     * incrementally.
+     *
+     * When your filter blocks the UI while filtering, you might consider
+     * turning this on. Depending on your model and filters, this may become
+     * interesting around 10,000 to 100,000 items.
+     *
+     * By default, incremental filtering is disabled.
+     *
+     * See [method@Gtk.FilterListModel.get_pending] for progress information
+     * about an ongoing incremental filtering operation.
+     * @param incremental - %TRUE to enable incremental filtering
+     */
     setIncremental(incremental) {
         call("libgtk-4.so.1", "gtk_filter_list_model_set_incremental", [
             {
@@ -93,6 +162,15 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the model to be filtered.
+     *
+     * Note that GTK makes no effort to ensure that `model` conforms to
+     * the item type of @self. It assumes that the caller knows what they
+     * are doing and have set up an appropriate filter to ensure that item
+     * types match.
+     * @param model - The model to be filtered
+     */
     setModel(model) {
         call("libgtk-4.so.1", "gtk_filter_list_model_set_model", [
             {
@@ -106,6 +184,16 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the filter model to monitor properties of its items.
+     *
+     * This allows implementations of [class@Gtk.Filter] that support expression
+     * watching to react to property changes. This property has no effect if the
+     * current filter doesn't support watching items.
+     *
+     * By default, watching items is disabled.
+     * @param watchItems - %TRUE to watch items for property changes
+     */
     setWatchItems(watchItems) {
         call("libgtk-4.so.1", "gtk_filter_list_model_set_watch_items", [
             {
@@ -118,6 +206,16 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Query the section that covers the given position. The number of
+     * items in the section can be computed by `out_end - out_start`.
+     *
+     * If the position is larger than the number of items, a single
+     * range from n_items to G_MAXUINT will be returned.
+     * @param position - the position of the item to query
+     * @param outStart - the position of the first item in the section
+     * @param outEnd - the position of the first item not part of the section
+     */
     getSection(position, outStart, outEnd) {
         call("libgtk-4.so.1", "gtk_section_model_get_section", [
             {
@@ -144,6 +242,25 @@ export class FilterListModel extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * This function emits the [signal@Gtk.SectionModel::sections-changed]
+     * signal to notify about changes to sections.
+     *
+     * It must cover all positions that used to be a section start or that
+     * are now a section start. It does not have to cover all positions for
+     * which the section has changed.
+     *
+     * The [signal@Gio.ListModel::items-changed] implies the effect of the
+     * [signal@Gtk.SectionModel::sections-changed] signal for all the items
+     * it covers.
+     *
+     * It is recommended that when changes to the items cause section changes
+     * in a larger range, that the larger range is included in the emission
+     * of the [signal@Gio.ListModel::items-changed] instead of emitting
+     * two signals.
+     * @param position - the first changed item
+     * @param nItems - the number of changed items
+     */
     sectionsChanged(position, nItems) {
         call("libgtk-4.so.1", "gtk_section_model_sections_changed", [
             {

package/dist/generated/gtk/filter.d.ts

@@ -3,8 +3,38 @@ import * as GObject from "../gobject/index.js";
 export declare class Filter extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Notifies all users of the filter that it has changed.
+     *
+     * This emits the [signal@Gtk.Filter::changed] signal. Users
+     * of the filter should then check items again via
+     * [method@Gtk.Filter.match].
+     *
+     * Depending on the `change` parameter, not all items need to
+     * be changed, but only some. Refer to the [enum@Gtk.FilterChange]
+     * documentation for details.
+     *
+     * This function is intended for implementers of `GtkFilter`
+     * subclasses and should not be called from other functions.
+     * @param change - how the filter changed
+     */
     changed(change: FilterChange): void;
+    /**
+     * Gets the known strictness of a filter.
+     *
+     * If the strictness is not known, [enum@Gtk.FilterMatch.some] is returned.
+     *
+     * This value may change after emission of the [signal@Gtk.Filter::changed]
+     * signal.
+     *
+     * This function is meant purely for optimization purposes. Filters can
+     * choose to omit implementing it, but `GtkFilterListModel` uses it.
+     */
     getStrictness(): FilterMatch;
+    /**
+     * Checks if the given `item` is matched by the filter or not.
+     * @param item - The item to check
+     */
     match(item: GObject.GObject): boolean;
     connect(signal: "changed", handler: (self: Filter, change: FilterChange) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Filter, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/gtk/filter.js

@@ -1,6 +1,25 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+/**
+ * Describes the filtering to be performed by a [class@Gtk.FilterListModel].
+ *
+ * The model will use the filter to determine if it should include items
+ * or not by calling [method@Gtk.Filter.match] for each item and only
+ * keeping the ones that the function returns true for.
+ *
+ * Filters may change what items they match through their lifetime. In that
+ * case, they will emit the [signal@Gtk.Filter::changed] signal to notify
+ * that previous filter results are no longer valid and that items should
+ * be checked again via [method@Gtk.Filter.match].
+ *
+ * GTK provides various pre-made filter implementations for common filtering
+ * operations. These filters often include properties that can be linked to
+ * various widgets to easily allow searches.
+ *
+ * However, in particular for large lists or complex search methods, it is
+ * also possible to subclass `GtkFilter` and provide one's own filter.
+ */
 const SIGNAL_META = {
     changed: {
         params: [{ type: { type: "int", size: 32, unsigned: false } }],
@@ -22,6 +41,21 @@ export class Filter extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Notifies all users of the filter that it has changed.
+     *
+     * This emits the [signal@Gtk.Filter::changed] signal. Users
+     * of the filter should then check items again via
+     * [method@Gtk.Filter.match].
+     *
+     * Depending on the `change` parameter, not all items need to
+     * be changed, but only some. Refer to the [enum@Gtk.FilterChange]
+     * documentation for details.
+     *
+     * This function is intended for implementers of `GtkFilter`
+     * subclasses and should not be called from other functions.
+     * @param change - how the filter changed
+     */
     changed(change) {
         call("libgtk-4.so.1", "gtk_filter_changed", [
             {
@@ -34,6 +68,17 @@ export class Filter extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the known strictness of a filter.
+     *
+     * If the strictness is not known, [enum@Gtk.FilterMatch.some] is returned.
+     *
+     * This value may change after emission of the [signal@Gtk.Filter::changed]
+     * signal.
+     *
+     * This function is meant purely for optimization purposes. Filters can
+     * choose to omit implementing it, but `GtkFilterListModel` uses it.
+     */
     getStrictness() {
         return call("libgtk-4.so.1", "gtk_filter_get_strictness", [
             {
@@ -42,6 +87,10 @@ export class Filter extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Checks if the given `item` is matched by the filter or not.
+     * @param item - The item to check
+     */
     match(item) {
         return call("libgtk-4.so.1", "gtk_filter_match", [
             {

package/dist/generated/gtk/fixed-layout-child.d.ts

@@ -1,8 +1,16 @@
 import * as Gsk from "../gsk/index.js";
 import { LayoutChild } from "./layout-child.js";
+/** `GtkLayoutChild` subclass for children in a `GtkFixedLayout`. */
 export declare class FixedLayoutChild extends LayoutChild {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Retrieves the transformation of the child.
+     */
     getTransform(): Gsk.Transform | null;
+    /**
+     * Sets the transformation of the child of a `GtkFixedLayout`.
+     * @param transform - a `GskTransform`
+     */
     setTransform(transform: Gsk.Transform): void;
 }

package/dist/generated/gtk/fixed-layout-child.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Gsk from "../gsk/index.js";
 import { LayoutChild } from "./layout-child.js";
+/** `GtkLayoutChild` subclass for children in a `GtkFixedLayout`. */
 export class FixedLayoutChild extends LayoutChild {
     constructor(...args) {
         super(...args);
@@ -17,6 +18,9 @@ export class FixedLayoutChild extends LayoutChild {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Retrieves the transformation of the child.
+     */
     getTransform() {
         const ptr = call("libgtk-4.so.1", "gtk_fixed_layout_child_get_transform", [
             {
@@ -33,6 +37,10 @@ export class FixedLayoutChild extends LayoutChild {
             return null;
         return getObject(ptr, Gsk.Transform);
     }
+    /**
+     * Sets the transformation of the child of a `GtkFixedLayout`.
+     * @param transform - a `GskTransform`
+     */
     setTransform(transform) {
         call("libgtk-4.so.1", "gtk_fixed_layout_child_set_transform", [
             {

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

@@ -1,5 +1,40 @@
 import { LayoutManager } from "./layout-manager.js";
+/**
+ * Places child widgets at fixed positions.
+ *
+ * Most applications should never use this layout manager; fixed positioning
+ * and sizing requires constant recalculations on where children need to be
+ * positioned and sized. Other layout managers perform this kind of work
+ * internally so that application developers don't need to do it. Specifically,
+ * widgets positioned in a fixed layout manager will need to take into account:
+ *
+ * - Themes, which may change widget sizes.
+ *
+ * - Fonts other than the one you used to write the app will of course
+ * change the size of widgets containing text; keep in mind that
+ * users may use a larger font because of difficulty reading the
+ * default, or they may be using a different OS that provides different
+ * fonts.
+ *
+ * - Translation of text into other languages changes its size. Also,
+ * display of non-English text will use a different font in many
+ * cases.
+ *
+ * In addition, `GtkFixedLayout` does not pay attention to text direction and
+ * thus may produce unwanted results if your app is run under right-to-left
+ * languages such as Hebrew or Arabic. That is: normally GTK will order
+ * containers appropriately depending on the text direction, e.g. to put labels
+ * to the right of the thing they label when using an RTL language;
+ * `GtkFixedLayout` won't be able to do that for you.
+ *
+ * Finally, fixed positioning makes it kind of annoying to add/remove UI
+ * elements, since you have to reposition all the other  elements. This is a
+ * long-term maintenance problem for your application.
+ */
 export declare class FixedLayout extends LayoutManager {
+    /**
+     * Creates a new `GtkFixedLayout`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
 }

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

@@ -1,6 +1,41 @@
 import { call } from "@gtkx/native";
 import { LayoutManager } from "./layout-manager.js";
+/**
+ * Places child widgets at fixed positions.
+ *
+ * Most applications should never use this layout manager; fixed positioning
+ * and sizing requires constant recalculations on where children need to be
+ * positioned and sized. Other layout managers perform this kind of work
+ * internally so that application developers don't need to do it. Specifically,
+ * widgets positioned in a fixed layout manager will need to take into account:
+ *
+ * - Themes, which may change widget sizes.
+ *
+ * - Fonts other than the one you used to write the app will of course
+ * change the size of widgets containing text; keep in mind that
+ * users may use a larger font because of difficulty reading the
+ * default, or they may be using a different OS that provides different
+ * fonts.
+ *
+ * - Translation of text into other languages changes its size. Also,
+ * display of non-English text will use a different font in many
+ * cases.
+ *
+ * In addition, `GtkFixedLayout` does not pay attention to text direction and
+ * thus may produce unwanted results if your app is run under right-to-left
+ * languages such as Hebrew or Arabic. That is: normally GTK will order
+ * containers appropriately depending on the text direction, e.g. to put labels
+ * to the right of the thing they label when using an RTL language;
+ * `GtkFixedLayout` won't be able to do that for you.
+ *
+ * Finally, fixed positioning makes it kind of annoying to add/remove UI
+ * elements, since you have to reposition all the other  elements. This is a
+ * long-term maintenance problem for your application.
+ */
 export class FixedLayout extends LayoutManager {
+    /**
+     * Creates a new `GtkFixedLayout`.
+     */
     constructor(...args) {
         super(...args);
     }

package/dist/generated/gtk/fixed.d.ts

@@ -2,14 +2,95 @@ import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import * as Gsk from "../gsk/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Places its child widgets at fixed positions and with fixed sizes.
+ *
+ * `GtkFixed` performs no automatic layout management.
+ *
+ * For most applications, you should not use this container! It keeps
+ * you from having to learn about the other GTK containers, but it
+ * results in broken applications.  With `GtkFixed`, the following
+ * things will result in truncated text, overlapping widgets, and
+ * other display bugs:
+ *
+ * - Themes, which may change widget sizes.
+ *
+ * - Fonts other than the one you used to write the app will of course
+ * change the size of widgets containing text; keep in mind that
+ * users may use a larger font because of difficulty reading the
+ * default, or they may be using a different OS that provides different fonts.
+ *
+ * - Translation of text into other languages changes its size. Also,
+ * display of non-English text will use a different font in many
+ * cases.
+ *
+ * In addition, `GtkFixed` does not pay attention to text direction and
+ * thus may produce unwanted results if your app is run under right-to-left
+ * languages such as Hebrew or Arabic. That is: normally GTK will order
+ * containers appropriately for the text direction, e.g. to put labels to
+ * the right of the thing they label when using an RTL language, but it can’t
+ * do that with `GtkFixed`. So if you need to reorder widgets depending on
+ * the text direction, you would need to manually detect it and adjust child
+ * positions accordingly.
+ *
+ * Finally, fixed positioning makes it kind of annoying to add/remove
+ * UI elements, since you have to reposition all the other elements. This
+ * is a long-term maintenance problem for your application.
+ *
+ * If you know none of these things are an issue for your application,
+ * and prefer the simplicity of `GtkFixed`, by all means use the
+ * widget. But you should be aware of the tradeoffs.
+ */
 export declare class Fixed extends Widget {
+    /**
+     * Creates a new `GtkFixed`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Retrieves the translation transformation of the
+     * given child `GtkWidget` in the `GtkFixed`.
+     *
+     * See also: [method@Gtk.Fixed.get_child_transform].
+     * @param widget - a child of @fixed
+     * @param x - the horizontal position of the @widget
+     * @param y - the vertical position of the @widget
+     */
     getChildPosition(widget: Widget, x: Ref<number>, y: Ref<number>): void;
+    /**
+     * Retrieves the transformation for `widget` set using
+     * gtk_fixed_set_child_transform().
+     * @param widget - a `GtkWidget`, child of @fixed
+     */
     getChildTransform(widget: Widget): Gsk.Transform | null;
+    /**
+     * Sets a translation transformation to the given `x` and `y` coordinates to the child `widget` of the `GtkFixed`.
+     * @param widget - the child widget
+     * @param x - the horizontal position to move the widget to
+     * @param y - the vertical position to move the widget to
+     */
     move(widget: Widget, x: number, y: number): void;
+    /**
+     * Adds a widget to a `GtkFixed` at the given position.
+     * @param widget - the widget to add
+     * @param x - the horizontal position to place the widget at
+     * @param y - the vertical position to place the widget at
+     */
     put(widget: Widget, x: number, y: number): void;
+    /**
+     * Removes a child from @fixed.
+     * @param widget - the child widget to remove
+     */
     remove(widget: Widget): void;
+    /**
+     * Sets the transformation for @widget.
+     *
+     * This is a convenience function that retrieves the
+     * [class@Gtk.FixedLayoutChild] instance associated to
+     * `widget` and calls [method@Gtk.FixedLayoutChild.set_transform].
+     * @param widget - a `GtkWidget`, child of @fixed
+     * @param transform - the transformation assigned to `widget`   to reset @widget's transform
+     */
     setChildTransform(widget: Widget, transform?: Gsk.Transform | null): void;
     connect(signal: "notify", handler: (self: Fixed, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/fixed.js

@@ -2,7 +2,49 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Gsk from "../gsk/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Places its child widgets at fixed positions and with fixed sizes.
+ *
+ * `GtkFixed` performs no automatic layout management.
+ *
+ * For most applications, you should not use this container! It keeps
+ * you from having to learn about the other GTK containers, but it
+ * results in broken applications.  With `GtkFixed`, the following
+ * things will result in truncated text, overlapping widgets, and
+ * other display bugs:
+ *
+ * - Themes, which may change widget sizes.
+ *
+ * - Fonts other than the one you used to write the app will of course
+ * change the size of widgets containing text; keep in mind that
+ * users may use a larger font because of difficulty reading the
+ * default, or they may be using a different OS that provides different fonts.
+ *
+ * - Translation of text into other languages changes its size. Also,
+ * display of non-English text will use a different font in many
+ * cases.
+ *
+ * In addition, `GtkFixed` does not pay attention to text direction and
+ * thus may produce unwanted results if your app is run under right-to-left
+ * languages such as Hebrew or Arabic. That is: normally GTK will order
+ * containers appropriately for the text direction, e.g. to put labels to
+ * the right of the thing they label when using an RTL language, but it can’t
+ * do that with `GtkFixed`. So if you need to reorder widgets depending on
+ * the text direction, you would need to manually detect it and adjust child
+ * positions accordingly.
+ *
+ * Finally, fixed positioning makes it kind of annoying to add/remove
+ * UI elements, since you have to reposition all the other elements. This
+ * is a long-term maintenance problem for your application.
+ *
+ * If you know none of these things are an issue for your application,
+ * and prefer the simplicity of `GtkFixed`, by all means use the
+ * widget. But you should be aware of the tradeoffs.
+ */
 export class Fixed extends Widget {
+    /**
+     * Creates a new `GtkFixed`.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -12,6 +54,15 @@ export class Fixed extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Retrieves the translation transformation of the
+     * given child `GtkWidget` in the `GtkFixed`.
+     *
+     * See also: [method@Gtk.Fixed.get_child_transform].
+     * @param widget - a child of @fixed
+     * @param x - the horizontal position of the @widget
+     * @param y - the vertical position of the @widget
+     */
     getChildPosition(widget, x, y) {
         call("libgtk-4.so.1", "gtk_fixed_get_child_position", [
             {
@@ -32,6 +83,11 @@ export class Fixed extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the transformation for `widget` set using
+     * gtk_fixed_set_child_transform().
+     * @param widget - a `GtkWidget`, child of @fixed
+     */
     getChildTransform(widget) {
         const ptr = call("libgtk-4.so.1", "gtk_fixed_get_child_transform", [
             {
@@ -52,6 +108,12 @@ export class Fixed extends Widget {
             return null;
         return getObject(ptr, Gsk.Transform);
     }
+    /**
+     * Sets a translation transformation to the given `x` and `y` coordinates to the child `widget` of the `GtkFixed`.
+     * @param widget - the child widget
+     * @param x - the horizontal position to move the widget to
+     * @param y - the vertical position to move the widget to
+     */
     move(widget, x, y) {
         call("libgtk-4.so.1", "gtk_fixed_move", [
             {
@@ -72,6 +134,12 @@ export class Fixed extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a widget to a `GtkFixed` at the given position.
+     * @param widget - the widget to add
+     * @param x - the horizontal position to place the widget at
+     * @param y - the vertical position to place the widget at
+     */
     put(widget, x, y) {
         call("libgtk-4.so.1", "gtk_fixed_put", [
             {
@@ -92,6 +160,10 @@ export class Fixed extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes a child from @fixed.
+     * @param widget - the child widget to remove
+     */
     remove(widget) {
         call("libgtk-4.so.1", "gtk_fixed_remove", [
             {
@@ -104,6 +176,15 @@ export class Fixed extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the transformation for @widget.
+     *
+     * This is a convenience function that retrieves the
+     * [class@Gtk.FixedLayoutChild] instance associated to
+     * `widget` and calls [method@Gtk.FixedLayoutChild.set_transform].
+     * @param widget - a `GtkWidget`, child of @fixed
+     * @param transform - the transformation assigned to `widget`   to reset @widget's transform
+     */
     setChildTransform(widget, transform) {
         call("libgtk-4.so.1", "gtk_fixed_set_child_transform", [
             {