@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/single-selection.js

@@ -3,6 +3,14 @@ import { getObject } from "@gtkx/ffi";
 import { Bitset } from "./bitset.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * A selection model that allows selecting a single item.
+ *
+ * Note that the selection is *persistent* -- if the selected item is removed
+ * and re-added in the same [signal@Gio.ListModel::items-changed] emission, it
+ * stays selected. In particular, this means that changing the sort order of an
+ * underlying sort model will preserve the selection.
+ */
 export class SingleSelection extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -17,6 +25,10 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Checks if autoselect has been enabled or disabled via
+     * gtk_single_selection_set_autoselect().
+     */
     getAutoselect() {
         return call("libgtk-4.so.1", "gtk_single_selection_get_autoselect", [
             {
@@ -25,6 +37,10 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * If %TRUE, gtk_selection_model_unselect_item() is supported and allows
+     * unselecting the selected item.
+     */
     getCanUnselect() {
         return call("libgtk-4.so.1", "gtk_single_selection_get_can_unselect", [
             {
@@ -33,6 +49,9 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the model that `self` is wrapping.
+     */
     getModel() {
         const ptr = call("libgtk-4.so.1", "gtk_single_selection_get_model", [
             {
@@ -44,6 +63,11 @@ export class SingleSelection extends GObject.GObject {
             return null;
         return getObject(ptr, Gio.ListModel);
     }
+    /**
+     * Gets the position of the selected item.
+     *
+     * If no item is selected, %GTK_INVALID_LIST_POSITION is returned.
+     */
     getSelected() {
         return call("libgtk-4.so.1", "gtk_single_selection_get_selected", [
             {
@@ -52,6 +76,11 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the selected item.
+     *
+     * If no item is selected, %NULL is returned.
+     */
     getSelectedItem() {
         const ptr = call("libgtk-4.so.1", "gtk_single_selection_get_selected_item", [
             {
@@ -63,6 +92,14 @@ export class SingleSelection extends GObject.GObject {
             return null;
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Enables or disables autoselect.
+     *
+     * If `autoselect` is %TRUE, `self` will enforce that an item is always
+     * selected. It will select a new item when the currently selected
+     * item is deleted and it will disallow unselecting the current item.
+     * @param autoselect - %TRUE to always select an item
+     */
     setAutoselect(autoselect) {
         call("libgtk-4.so.1", "gtk_single_selection_set_autoselect", [
             {
@@ -75,6 +112,15 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If %TRUE, unselecting the current item via
+     * gtk_selection_model_unselect_item() is supported.
+     *
+     * Note that setting [property@Gtk.SingleSelection:autoselect] will
+     * cause unselecting to not work, so it practically makes no sense
+     * to set both at the same time.
+     * @param canUnselect - %TRUE to allow unselecting
+     */
     setCanUnselect(canUnselect) {
         call("libgtk-4.so.1", "gtk_single_selection_set_can_unselect", [
             {
@@ -87,6 +133,12 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the model that `self` should wrap.
+     *
+     * If `model` is %NULL, `self` will be empty.
+     * @param model - A `GListModel` to wrap
+     */
     setModel(model) {
         call("libgtk-4.so.1", "gtk_single_selection_set_model", [
             {
@@ -100,6 +152,18 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Selects the item at the given position.
+     *
+     * If the list does not have an item at `position` or
+     * %GTK_INVALID_LIST_POSITION is given, the behavior depends on the
+     * value of the [property@Gtk.SingleSelection:autoselect] property:
+     * If it is set, no change will occur and the old item will stay
+     * selected. If it is unset, the selection will be unset and no item
+     * will be selected. This also applies if [property@Gtk.SingleSelection:can-unselect]
+     * is set to %FALSE.
+     * @param position - the item to select or %GTK_INVALID_LIST_POSITION
+     */
     setSelected(position) {
         call("libgtk-4.so.1", "gtk_single_selection_set_selected", [
             {
@@ -112,6 +176,16 @@ export class SingleSelection 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", [
             {
@@ -138,6 +212,25 @@ export class SingleSelection 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", [
             {
@@ -154,6 +247,13 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the set containing all currently selected items in the model.
+     *
+     * This function may be slow, so if you are only interested in single item,
+     * consider using [method@Gtk.SelectionModel.is_selected] or if you are only
+     * interested in a few, consider [method@Gtk.SelectionModel.get_selection_in_range].
+     */
     getSelection() {
         const ptr = call("libgtk-4.so.1", "gtk_selection_model_get_selection", [
             {
@@ -168,6 +268,17 @@ export class SingleSelection extends GObject.GObject {
         });
         return getObject(ptr, Bitset);
     }
+    /**
+     * Gets the set of selected items in a range.
+     *
+     * This function is an optimization for
+     * [method@Gtk.SelectionModel.get_selection] when you are only
+     * interested in part of the model's selected state. A common use
+     * case is in response to the [signal@Gtk.SelectionModel::selection-changed]
+     * signal.
+     * @param position - start of the queried range
+     * @param nItems - number of items in the queried range
+     */
     getSelectionInRange(position, nItems) {
         const ptr = call("libgtk-4.so.1", "gtk_selection_model_get_selection_in_range", [
             {
@@ -190,6 +301,10 @@ export class SingleSelection extends GObject.GObject {
         });
         return getObject(ptr, Bitset);
     }
+    /**
+     * Checks if the given item is selected.
+     * @param position - the position of the item to query
+     */
     isSelected(position) {
         return call("libgtk-4.so.1", "gtk_selection_model_is_selected", [
             {
@@ -202,6 +317,9 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to select all items in the model.
+     */
     selectAll() {
         return call("libgtk-4.so.1", "gtk_selection_model_select_all", [
             {
@@ -210,6 +328,11 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to select an item in the model.
+     * @param position - the position of the item to select
+     * @param unselectRest - whether previously selected items should be unselected
+     */
     selectItem(position, unselectRest) {
         return call("libgtk-4.so.1", "gtk_selection_model_select_item", [
             {
@@ -226,6 +349,12 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to select a range of items in the model.
+     * @param position - the first item to select
+     * @param nItems - the number of items to select
+     * @param unselectRest - whether previously selected items should be unselected
+     */
     selectRange(position, nItems, unselectRest) {
         return call("libgtk-4.so.1", "gtk_selection_model_select_range", [
             {
@@ -246,6 +375,14 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Helper function for implementations of `GtkSelectionModel`.
+     *
+     * Call this when the selection changes to emit the
+     * [signal@Gtk.SelectionModel::selection-changed] signal.
+     * @param position - the first changed item
+     * @param nItems - the number of changed items
+     */
     selectionChanged(position, nItems) {
         call("libgtk-4.so.1", "gtk_selection_model_selection_changed", [
             {
@@ -262,6 +399,42 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Make selection changes.
+     *
+     * This is the most advanced selection updating method that allows
+     * the most fine-grained control over selection changes. If you can,
+     * you should try the simpler versions, as implementations are more
+     * likely to implement support for those.
+     *
+     * Requests that the selection state of all positions set in `mask` be updated to the respective value in the `selected` bitmask.
+     *
+     * In pseudocode, it would look something like this:
+     *
+     * ```c
+     * for (i = 0; i < n_items; i++)
+     * {
+     * // don't change values not in the mask
+     * if (!gtk_bitset_contains (mask, i))
+     * continue;
+     *
+     * if (gtk_bitset_contains (selected, i))
+     * select_item (i);
+     * else
+     * unselect_item (i);
+     * }
+     *
+     * gtk_selection_model_selection_changed (model,
+     * first_changed_item,
+     * n_changed_items);
+     * ```
+     *
+     * `mask` and `selected` must not be modified. They may refer to the
+     * same bitset, which would mean that every item in the set should
+     * be selected.
+     * @param selected - bitmask specifying if items should be selected or unselected
+     * @param mask - bitmask specifying which items should be updated
+     */
     setSelection(selected, mask) {
         return call("libgtk-4.so.1", "gtk_selection_model_set_selection", [
             {
@@ -288,6 +461,9 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to unselect all items in the model.
+     */
     unselectAll() {
         return call("libgtk-4.so.1", "gtk_selection_model_unselect_all", [
             {
@@ -296,6 +472,10 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to unselect an item in the model.
+     * @param position - the position of the item to unselect
+     */
     unselectItem(position) {
         return call("libgtk-4.so.1", "gtk_selection_model_unselect_item", [
             {
@@ -308,6 +488,11 @@ export class SingleSelection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests to unselect a range of items in the model.
+     * @param position - the first item to unselect
+     * @param nItems - the number of items to unselect
+     */
     unselectRange(position, nItems) {
         return call("libgtk-4.so.1", "gtk_selection_model_unselect_range", [
             {

package/dist/generated/gtk/size-group.d.ts

@@ -1,15 +1,165 @@
 import { SizeGroupMode } from "./enums.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Groups widgets together so they all request the same size.
+ *
+ * This is typically useful when you want a column of widgets to have
+ * the same size, but you can’t use a [class@Gtk.Grid] or [class@Gtk.Box].
+ *
+ * In detail, the size requested for each widget in a `GtkSizeGroup` is
+ * the maximum of the sizes that would have been requested for each
+ * widget in the size group if they were not in the size group. The
+ * [mode][method@Gtk.SizeGroup.set_mode] of the size group determines
+ * whether this applies to the horizontal size, the vertical size, or
+ * both sizes.
+ *
+ * Note that size groups only affect the amount of space requested, not
+ * the size that the widgets finally receive. If you want the widgets in
+ * a `GtkSizeGroup` to actually be the same size, you need to pack them in
+ * such a way that they get the size they request and not more. In
+ * particular it doesn't make a lot of sense to set
+ * [the expand flags][method@Gtk.Widget.set_hexpand] on the widgets that
+ * are members of a size group.
+ *
+ * `GtkSizeGroup` objects are referenced by each widget in the size group,
+ * so once you have added all widgets to a `GtkSizeGroup`, you can drop
+ * the initial reference to the size group with
+ * [method@GObject.Object.unref]. If the widgets in the size group are
+ * subsequently destroyed, then they will be removed from the size group
+ * and drop their references on the size group; when all widgets have been
+ * removed, the size group will be freed.
+ *
+ * Widgets can be part of multiple size groups; GTK will compute the
+ * horizontal size of a widget from the horizontal requisition of all widgets
+ * that can be reached from the widget by a chain of size groups with mode
+ * [enum@Gtk.SizeGroupMode.HORIZONTAL] or [enum@Gtk.SizeGroupMode.BOTH], and
+ * the vertical size from the vertical requisition of all widgets that can be
+ * reached from the widget by a chain of size groups with mode
+ * [enum@Gtk.SizeGroupMode.VERTICAL] or [enum@Gtk.SizeGroupMode.BOTH].
+ *
+ * # Size groups and trading height-for-width
+ *
+ * ::: warning
+ * Generally, size groups don't interact well with widgets that
+ * trade height for width (or width for height), such as wrappable
+ * labels. Avoid using size groups with such widgets.
+ *
+ * A size group with mode [enum@Gtk.SizeGroupMode.HORIZONTAL] or
+ * [enum@Gtk.SizeGroupMode.VERTICAL] only consults non-contextual sizes
+ * of widgets other than the one being measured, since it has no
+ * knowledge of what size a widget will get allocated in the other
+ * orientation. This can lead to widgets in a group actually requesting
+ * different contextual sizes, contrary to the purpose of
+ * `GtkSizeGroup`.
+ *
+ * In contrast, a size group with mode [enum@Gtk.SizeGroupMode.BOTH] can
+ * properly propagate the available size in the opposite orientation
+ * when measuring widgets in the group, which results in consistent and
+ * accurate measurements.
+ *
+ * In case some mechanism other than a size group is already used to
+ * ensure that widgets in a group all get the same size in one
+ * orientation (for example, some common ancestor is known to allocate
+ * the same width to all its children), and the size group is only
+ * really needed to also make the widgets request the same size in the
+ * other orientation, it is beneficial to still set the group's mode to
+ * [enum@Gtk.SizeGroupMode.BOTH]. This lets the group assume and count
+ * on sizes of the widgets in the former orientation being the same,
+ * which enables it to propagate the available size as described above.
+ *
+ * # Alternatives to size groups
+ *
+ * Size groups have many limitations, such as only influencing size
+ * requests but not allocations, and poor height-for-width support. When
+ * possible, prefer using dedicated mechanisms that can properly ensure
+ * that the widgets get the same size.
+ *
+ * Various container widgets and layout managers support a homogeneous
+ * layout mode, where they will explicitly give the same size to their
+ * children (see [property@Gtk.Box:homogeneous]). Using homogeneous mode
+ * can also have large performance benefits compared to either the same
+ * container in non-homogeneous mode, or to size groups.
+ *
+ * [class@Gtk.Grid] can be used to position widgets into rows and
+ * columns. Members of each column will have the same width among them;
+ * likewise, members of each row will have the same height. On top of
+ * that, the heights can be made equal between all rows with
+ * [property@Gtk.Grid:row-homogeneous], and the widths can be made equal
+ * between all columns with [property@Gtk.Grid:column-homogeneous].
+ *
+ * # GtkSizeGroup as GtkBuildable
+ *
+ * Size groups can be specified in a UI definition by placing an `<object>`
+ * element with `class="GtkSizeGroup"` somewhere in the UI definition. The
+ * widgets that belong to the size group are specified by a `<widgets>` element
+ * that may contain multiple `<widget>` elements, one for each member of the
+ * size group. The ”name” attribute gives the id of the widget.
+ *
+ * An example of a UI definition fragment with `GtkSizeGroup`:
+ * ```xml
+ * <object class="GtkSizeGroup">
+ * <property name="mode">horizontal</property>
+ * <widgets>
+ * <widget name="radio1"/>
+ * <widget name="radio2"/>
+ * </widgets>
+ * </object>
+ * ```
+ */
 export declare class SizeGroup extends GObject.GObject {
+    /**
+     * Create a new `GtkSizeGroup`.
+     * @param mode - the mode for the new size group.
+     */
     constructor(mode: SizeGroupMode);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Adds a widget to a `GtkSizeGroup`.
+     *
+     * In the future, the requisition
+     * of the widget will be determined as the maximum of its requisition
+     * and the requisition of the other widgets in the size group.
+     * Whether this applies horizontally, vertically, or in both directions
+     * depends on the mode of the size group.
+     * See [method@Gtk.SizeGroup.set_mode].
+     *
+     * When the widget is destroyed or no longer referenced elsewhere, it
+     * will be removed from the size group.
+     * @param widget - the `GtkWidget` to add
+     */
     addWidget(widget: Widget): void;
+    /**
+     * Gets the current mode of the size group.
+     */
     getMode(): SizeGroupMode;
+    /**
+     * Returns the list of widgets associated with @size_group.
+     */
     getWidgets(): Widget[];
+    /**
+     * Removes a widget from a `GtkSizeGroup`.
+     * @param widget - the `GtkWidget` to remove
+     */
     removeWidget(widget: Widget): void;
+    /**
+     * Sets the `GtkSizeGroupMode` of the size group.
+     *
+     * The mode of the size group determines whether the widgets in the
+     * size group should all have the same horizontal requisition
+     * (%GTK_SIZE_GROUP_HORIZONTAL) all have the same vertical requisition
+     * (%GTK_SIZE_GROUP_VERTICAL), or should all have the same requisition
+     * in both directions (%GTK_SIZE_GROUP_BOTH).
+     * @param mode - the mode to set for the size group.
+     */
     setMode(mode: SizeGroupMode): void;
+    /**
+     * Gets the ID of the `buildable` object.
+     *
+     * `GtkBuilder` sets the name based on the ID attribute
+     * of the `<object>` tag used to construct the @buildable.
+     */
     getBuildableId(): string | null;
     connect(signal: "notify", handler: (self: SizeGroup, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/size-group.js

@@ -2,6 +2,112 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Groups widgets together so they all request the same size.
+ *
+ * This is typically useful when you want a column of widgets to have
+ * the same size, but you can’t use a [class@Gtk.Grid] or [class@Gtk.Box].
+ *
+ * In detail, the size requested for each widget in a `GtkSizeGroup` is
+ * the maximum of the sizes that would have been requested for each
+ * widget in the size group if they were not in the size group. The
+ * [mode][method@Gtk.SizeGroup.set_mode] of the size group determines
+ * whether this applies to the horizontal size, the vertical size, or
+ * both sizes.
+ *
+ * Note that size groups only affect the amount of space requested, not
+ * the size that the widgets finally receive. If you want the widgets in
+ * a `GtkSizeGroup` to actually be the same size, you need to pack them in
+ * such a way that they get the size they request and not more. In
+ * particular it doesn't make a lot of sense to set
+ * [the expand flags][method@Gtk.Widget.set_hexpand] on the widgets that
+ * are members of a size group.
+ *
+ * `GtkSizeGroup` objects are referenced by each widget in the size group,
+ * so once you have added all widgets to a `GtkSizeGroup`, you can drop
+ * the initial reference to the size group with
+ * [method@GObject.Object.unref]. If the widgets in the size group are
+ * subsequently destroyed, then they will be removed from the size group
+ * and drop their references on the size group; when all widgets have been
+ * removed, the size group will be freed.
+ *
+ * Widgets can be part of multiple size groups; GTK will compute the
+ * horizontal size of a widget from the horizontal requisition of all widgets
+ * that can be reached from the widget by a chain of size groups with mode
+ * [enum@Gtk.SizeGroupMode.HORIZONTAL] or [enum@Gtk.SizeGroupMode.BOTH], and
+ * the vertical size from the vertical requisition of all widgets that can be
+ * reached from the widget by a chain of size groups with mode
+ * [enum@Gtk.SizeGroupMode.VERTICAL] or [enum@Gtk.SizeGroupMode.BOTH].
+ *
+ * # Size groups and trading height-for-width
+ *
+ * ::: warning
+ * Generally, size groups don't interact well with widgets that
+ * trade height for width (or width for height), such as wrappable
+ * labels. Avoid using size groups with such widgets.
+ *
+ * A size group with mode [enum@Gtk.SizeGroupMode.HORIZONTAL] or
+ * [enum@Gtk.SizeGroupMode.VERTICAL] only consults non-contextual sizes
+ * of widgets other than the one being measured, since it has no
+ * knowledge of what size a widget will get allocated in the other
+ * orientation. This can lead to widgets in a group actually requesting
+ * different contextual sizes, contrary to the purpose of
+ * `GtkSizeGroup`.
+ *
+ * In contrast, a size group with mode [enum@Gtk.SizeGroupMode.BOTH] can
+ * properly propagate the available size in the opposite orientation
+ * when measuring widgets in the group, which results in consistent and
+ * accurate measurements.
+ *
+ * In case some mechanism other than a size group is already used to
+ * ensure that widgets in a group all get the same size in one
+ * orientation (for example, some common ancestor is known to allocate
+ * the same width to all its children), and the size group is only
+ * really needed to also make the widgets request the same size in the
+ * other orientation, it is beneficial to still set the group's mode to
+ * [enum@Gtk.SizeGroupMode.BOTH]. This lets the group assume and count
+ * on sizes of the widgets in the former orientation being the same,
+ * which enables it to propagate the available size as described above.
+ *
+ * # Alternatives to size groups
+ *
+ * Size groups have many limitations, such as only influencing size
+ * requests but not allocations, and poor height-for-width support. When
+ * possible, prefer using dedicated mechanisms that can properly ensure
+ * that the widgets get the same size.
+ *
+ * Various container widgets and layout managers support a homogeneous
+ * layout mode, where they will explicitly give the same size to their
+ * children (see [property@Gtk.Box:homogeneous]). Using homogeneous mode
+ * can also have large performance benefits compared to either the same
+ * container in non-homogeneous mode, or to size groups.
+ *
+ * [class@Gtk.Grid] can be used to position widgets into rows and
+ * columns. Members of each column will have the same width among them;
+ * likewise, members of each row will have the same height. On top of
+ * that, the heights can be made equal between all rows with
+ * [property@Gtk.Grid:row-homogeneous], and the widths can be made equal
+ * between all columns with [property@Gtk.Grid:column-homogeneous].
+ *
+ * # GtkSizeGroup as GtkBuildable
+ *
+ * Size groups can be specified in a UI definition by placing an `<object>`
+ * element with `class="GtkSizeGroup"` somewhere in the UI definition. The
+ * widgets that belong to the size group are specified by a `<widgets>` element
+ * that may contain multiple `<widget>` elements, one for each member of the
+ * size group. The ”name” attribute gives the id of the widget.
+ *
+ * An example of a UI definition fragment with `GtkSizeGroup`:
+ * ```xml
+ * <object class="GtkSizeGroup">
+ * <property name="mode">horizontal</property>
+ * <widgets>
+ * <widget name="radio1"/>
+ * <widget name="radio2"/>
+ * </widgets>
+ * </object>
+ * ```
+ */
 export class SizeGroup extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -15,6 +121,20 @@ export class SizeGroup extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Adds a widget to a `GtkSizeGroup`.
+     *
+     * In the future, the requisition
+     * of the widget will be determined as the maximum of its requisition
+     * and the requisition of the other widgets in the size group.
+     * Whether this applies horizontally, vertically, or in both directions
+     * depends on the mode of the size group.
+     * See [method@Gtk.SizeGroup.set_mode].
+     *
+     * When the widget is destroyed or no longer referenced elsewhere, it
+     * will be removed from the size group.
+     * @param widget - the `GtkWidget` to add
+     */
     addWidget(widget) {
         call("libgtk-4.so.1", "gtk_size_group_add_widget", [
             {
@@ -27,6 +147,9 @@ export class SizeGroup extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the current mode of the size group.
+     */
     getMode() {
         return call("libgtk-4.so.1", "gtk_size_group_get_mode", [
             {
@@ -35,6 +158,9 @@ export class SizeGroup extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the list of widgets associated with @size_group.
+     */
     getWidgets() {
         const ptrs = call("libgtk-4.so.1", "gtk_size_group_get_widgets", [
             {
@@ -49,6 +175,10 @@ export class SizeGroup extends GObject.GObject {
         });
         return ptrs.map((ptr) => getObject(ptr, Widget));
     }
+    /**
+     * Removes a widget from a `GtkSizeGroup`.
+     * @param widget - the `GtkWidget` to remove
+     */
     removeWidget(widget) {
         call("libgtk-4.so.1", "gtk_size_group_remove_widget", [
             {
@@ -61,6 +191,16 @@ export class SizeGroup extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkSizeGroupMode` of the size group.
+     *
+     * The mode of the size group determines whether the widgets in the
+     * size group should all have the same horizontal requisition
+     * (%GTK_SIZE_GROUP_HORIZONTAL) all have the same vertical requisition
+     * (%GTK_SIZE_GROUP_VERTICAL), or should all have the same requisition
+     * in both directions (%GTK_SIZE_GROUP_BOTH).
+     * @param mode - the mode to set for the size group.
+     */
     setMode(mode) {
         call("libgtk-4.so.1", "gtk_size_group_set_mode", [
             {
@@ -73,6 +213,12 @@ export class SizeGroup extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the ID of the `buildable` object.
+     *
+     * `GtkBuilder` sets the name based on the ID attribute
+     * of the `<object>` tag used to construct the @buildable.
+     */
     getBuildableId() {
         return call("libgtk-4.so.1", "gtk_buildable_get_buildable_id", [
             {