@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/spin-button.js

@@ -3,6 +3,125 @@ import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { Editable } from "./editable.js";
 import { Widget } from "./widget.js";
+/**
+ * Allows to enter or change numeric values.
+ *
+ *
+ *
+ * Rather than having to directly type a number into a `GtkEntry`,
+ * `GtkSpinButton` allows the user to click on one of two arrows
+ * to increment or decrement the displayed value. A value can still be
+ * typed in, with the bonus that it can be checked to ensure it is in a
+ * given range.
+ *
+ * The main properties of a `GtkSpinButton` are through an adjustment.
+ * See the [class@Gtk.Adjustment] documentation for more details about
+ * an adjustment's properties.
+ *
+ * Note that `GtkSpinButton` will by default make its entry large enough
+ * to accommodate the lower and upper bounds of the adjustment. If this
+ * is not desired, the automatic sizing can be turned off by explicitly
+ * setting [property@Gtk.Editable:width-chars] to a value != -1.
+ *
+ * ## Using a GtkSpinButton to get an integer
+ *
+ * ```c
+ * // Provides a function to retrieve an integer value from a GtkSpinButton
+ * // and creates a spin button to model percentage values.
+ *
+ * int
+ * grab_int_value (GtkSpinButton *button,
+ * gpointer       user_data)
+ * {
+ * return gtk_spin_button_get_value_as_int (button);
+ * }
+ *
+ * void
+ * create_integer_spin_button (void)
+ * {
+ *
+ * GtkWidget *window, *button;
+ * GtkAdjustment *adjustment;
+ *
+ * adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);
+ *
+ * window = gtk_window_new ();
+ *
+ * // creates the spinbutton, with no decimal places
+ * button = gtk_spin_button_new (adjustment, 1.0, 0);
+ * gtk_window_set_child (GTK_WINDOW (window), button);
+ *
+ * gtk_window_present (GTK_WINDOW (window));
+ * }
+ * ```
+ *
+ * ## Using a GtkSpinButton to get a floating point value
+ *
+ * ```c
+ * // Provides a function to retrieve a floating point value from a
+ * // GtkSpinButton, and creates a high precision spin button.
+ *
+ * float
+ * grab_float_value (GtkSpinButton *button,
+ * gpointer       user_data)
+ * {
+ * return gtk_spin_button_get_value (button);
+ * }
+ *
+ * void
+ * create_floating_spin_button (void)
+ * {
+ * GtkWidget *window, *button;
+ * GtkAdjustment *adjustment;
+ *
+ * adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);
+ *
+ * window = gtk_window_new ();
+ *
+ * // creates the spinbutton, with three decimal places
+ * button = gtk_spin_button_new (adjustment, 0.001, 3);
+ * gtk_window_set_child (GTK_WINDOW (window), button);
+ *
+ * gtk_window_present (GTK_WINDOW (window));
+ * }
+ * ```
+ *
+ * # Shortcuts and Gestures
+ *
+ * The following signals have default keybindings:
+ *
+ * - [signal@Gtk.SpinButton::change-value]
+ *
+ * # CSS nodes
+ *
+ * ```
+ * spinbutton.horizontal
+ * ├── text
+ * │    ├── undershoot.left
+ * │    ╰── undershoot.right
+ * ├── button.down
+ * ╰── button.up
+ * ```
+ *
+ * ```
+ * spinbutton.vertical
+ * ├── button.up
+ * ├── text
+ * │    ├── undershoot.left
+ * │    ╰── undershoot.right
+ * ╰── button.down
+ * ```
+ *
+ * `GtkSpinButton`s main CSS node has the name spinbutton. It creates subnodes
+ * for the entry and the two buttons, with these names. The button nodes have
+ * the style classes .up and .down. The `GtkText` subnodes (if present) are put
+ * below the text node. The orientation of the spin button is reflected in
+ * the .vertical or .horizontal style class on the main node.
+ *
+ * # Accessibility
+ *
+ * `GtkSpinButton` uses the [enum@Gtk.AccessibleRole.spin_button] role.
+ */
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     "change-value": {
@@ -21,6 +140,24 @@ export class SpinButton extends Widget {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new `GtkSpinButton` with the given properties.
+     *
+     * This is a convenience constructor that allows creation
+     * of a numeric `GtkSpinButton` without manually creating
+     * an adjustment. The value is initially set to the minimum
+     * value and a page increment of 10 * `step` is the default.
+     * The precision of the spin button is equivalent to the
+     * precision of @step.
+     *
+     * Note that the way in which the precision is derived works
+     * best if `step` is a power of ten. If the resulting precision
+     * is not suitable for your needs, use
+     * [method@Gtk.SpinButton.set_digits] to correct it.
+     * @param min - Minimum allowable value
+     * @param max - Maximum allowable value
+     * @param step - Increment added or subtracted by spinning the widget
+     */
     static buttonNewWithRange(min, max, step) {
         const ptr = call("libgtk-4.so.1", "gtk_spin_button_new_with_range", [
             {
@@ -56,6 +193,15 @@ export class SpinButton extends Widget {
             },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Changes the properties of an existing spin button.
+     *
+     * The adjustment, climb rate, and number of decimal places
+     * are updated accordingly.
+     * @param adjustment - a `GtkAdjustment` to replace the spin button’s
+     * @param climbRate - the new climb rate
+     * @param digits - the number of decimal places to display in the spin button
+     */
     configure(climbRate, digits, adjustment) {
         call("libgtk-4.so.1", "gtk_spin_button_configure", [
             {
@@ -77,6 +223,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the value set by [method@Gtk.SpinButton.set_activates_default].
+     */
     getActivatesDefault() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_activates_default", [
             {
@@ -85,6 +234,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Get the adjustment associated with a `GtkSpinButton`.
+     */
     getAdjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_spin_button_get_adjustment", [
             {
@@ -94,6 +246,9 @@ export class SpinButton extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Returns the acceleration rate for repeated changes.
+     */
     getClimbRate() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_climb_rate", [
             {
@@ -102,6 +257,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Fetches the precision of @spin_button.
+     */
     getDigits() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_digits", [
             {
@@ -110,6 +268,14 @@ export class SpinButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the current step and page the increments
+     * used by @spin_button.
+     *
+     * See [method@Gtk.SpinButton.set_increments].
+     * @param step - location to store step increment
+     * @param page - location to store page increment
+     */
     getIncrements(step, page) {
         call("libgtk-4.so.1", "gtk_spin_button_get_increments", [
             {
@@ -128,6 +294,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether non-numeric text can be typed into the spin button.
+     */
     getNumeric() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_numeric", [
             {
@@ -136,6 +305,13 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the range allowed for @spin_button.
+     *
+     * See [method@Gtk.SpinButton.set_range].
+     * @param min - location to store minimum allowed value
+     * @param max - location to store maximum allowed value
+     */
     getRange(min, max) {
         call("libgtk-4.so.1", "gtk_spin_button_get_range", [
             {
@@ -154,6 +330,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether the values are corrected to the nearest step.
+     */
     getSnapToTicks() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_snap_to_ticks", [
             {
@@ -162,6 +341,11 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the update behavior of a spin button.
+     *
+     * See [method@Gtk.SpinButton.set_update_policy].
+     */
     getUpdatePolicy() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_update_policy", [
             {
@@ -170,6 +354,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Get the value in the @spin_button.
+     */
     getValue() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_value", [
             {
@@ -178,6 +365,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Get the value `spin_button` represented as an integer.
+     */
     getValueAsInt() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_value_as_int", [
             {
@@ -186,6 +376,11 @@ export class SpinButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns whether the spin button’s value wraps around to the
+     * opposite limit when the upper or lower limit of the range is
+     * exceeded.
+     */
     getWrap() {
         return call("libgtk-4.so.1", "gtk_spin_button_get_wrap", [
             {
@@ -194,6 +389,13 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets whether activating the spin button will activate the default
+     * widget for the window containing the spin button.
+     *
+     * See [signal@Gtk.SpinButton::activate] for what counts as activation.
+     * @param activatesDefault - %TRUE to activate window’s default widget on activation
+     */
     setActivatesDefault(activatesDefault) {
         call("libgtk-4.so.1", "gtk_spin_button_set_activates_default", [
             {
@@ -206,6 +408,10 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Replaces the `GtkAdjustment` associated with @spin_button.
+     * @param adjustment - a `GtkAdjustment` to replace the existing adjustment
+     */
     setAdjustment(adjustment) {
         call("libgtk-4.so.1", "gtk_spin_button_set_adjustment", [
             {
@@ -218,6 +424,11 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the acceleration rate for repeated changes when you
+     * hold down a button or key.
+     * @param climbRate - the rate of acceleration, must be >= 0
+     */
     setClimbRate(climbRate) {
         call("libgtk-4.so.1", "gtk_spin_button_set_climb_rate", [
             {
@@ -230,6 +441,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the precision to be displayed by @spin_button.
+     *
+     * Up to 20 digit precision is allowed.
+     * @param digits - the number of digits after the decimal point to be
+     */
     setDigits(digits) {
         call("libgtk-4.so.1", "gtk_spin_button_set_digits", [
             {
@@ -242,6 +459,14 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the step and page increments for spin_button.
+     *
+     * This affects how quickly the value changes when
+     * the spin button’s arrows are activated.
+     * @param step - increment applied for a button 1 press.
+     * @param page - increment applied for a button 2 press.
+     */
     setIncrements(step, page) {
         call("libgtk-4.so.1", "gtk_spin_button_set_increments", [
             {
@@ -258,6 +483,11 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the flag that determines if non-numeric text can be typed
+     * into the spin button.
+     * @param numeric - flag indicating if only numeric entry is allowed
+     */
     setNumeric(numeric) {
         call("libgtk-4.so.1", "gtk_spin_button_set_numeric", [
             {
@@ -270,6 +500,14 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the minimum and maximum allowable values for @spin_button.
+     *
+     * If the current value is outside this range, it will be adjusted
+     * to fit within the range, otherwise it will remain unchanged.
+     * @param min - minimum allowable value
+     * @param max - maximum allowable value
+     */
     setRange(min, max) {
         call("libgtk-4.so.1", "gtk_spin_button_set_range", [
             {
@@ -286,6 +524,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the policy as to whether values are corrected to the
+     * nearest step increment when a spin button is activated after
+     * providing an invalid value.
+     * @param snapToTicks - a flag indicating if invalid values should be corrected
+     */
     setSnapToTicks(snapToTicks) {
         call("libgtk-4.so.1", "gtk_spin_button_set_snap_to_ticks", [
             {
@@ -298,6 +542,13 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the update behavior of a spin button.
+     *
+     * This determines whether the spin button is always
+     * updated or only when a valid value is set.
+     * @param policy - a `GtkSpinButtonUpdatePolicy` value
+     */
     setUpdatePolicy(policy) {
         call("libgtk-4.so.1", "gtk_spin_button_set_update_policy", [
             {
@@ -310,6 +561,10 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the value of @spin_button.
+     * @param value - the new value
+     */
     setValue(value) {
         call("libgtk-4.so.1", "gtk_spin_button_set_value", [
             {
@@ -322,6 +577,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the flag that determines if a spin button value wraps
+     * around to the opposite limit when the upper or lower limit
+     * of the range is exceeded.
+     * @param wrap - a flag indicating if wrapping behavior is performed
+     */
     setWrap(wrap) {
         call("libgtk-4.so.1", "gtk_spin_button_set_wrap", [
             {
@@ -334,6 +595,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Increment or decrement a spin button’s value in a specified
+     * direction by a specified amount.
+     * @param direction - a `GtkSpinType` indicating the direction to spin
+     * @param increment - step increment to apply in the specified direction
+     */
     spin(direction, increment) {
         call("libgtk-4.so.1", "gtk_spin_button_spin", [
             {
@@ -350,6 +617,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Manually force an update of the spin button.
+     */
     update() {
         call("libgtk-4.so.1", "gtk_spin_button_update", [
             {
@@ -358,6 +628,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the `GtkCellEditable::editing-done` signal.
+     */
     editingDone() {
         call("libgtk-4.so.1", "gtk_cell_editable_editing_done", [
             {
@@ -366,6 +639,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the `GtkCellEditable::remove-widget` signal.
+     */
     removeWidget() {
         call("libgtk-4.so.1", "gtk_cell_editable_remove_widget", [
             {
@@ -374,6 +650,19 @@ export class SpinButton extends Widget {
             },
         ], { 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", [
             {
@@ -387,6 +676,41 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the accessible platform state from the editable delegate.
+     *
+     * This is an helper function to retrieve the accessible state for
+     * `GtkEditable` interface implementations using a delegate pattern.
+     *
+     * You should call this function in your editable widget implementation
+     * of the [vfunc@Gtk.Accessible.get_platform_state] virtual function, for
+     * instance:
+     *
+     * ```c
+     * static void
+     * accessible_interface_init (GtkAccessibleInterface *iface)
+     * {
+     * iface->get_platform_state = your_editable_get_accessible_platform_state;
+     * }
+     *
+     * static gboolean
+     * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+     * GtkAccessiblePlatformState state)
+     * {
+     * return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+     * }
+     * ```
+     *
+     * Note that the widget which is the delegate *must* be a direct child of
+     * this widget, otherwise your implementation of [vfunc@Gtk.Accessible.get_platform_state]
+     * might not even be called, as the platform change will originate from
+     * the parent of the delegate, and, as a result, will not work properly.
+     *
+     * So, if you can't ensure the direct child condition, you should give the
+     * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+     * change your tree to allow this function to work.
+     * @param state - what kind of accessible state to retrieve
+     */
     delegateGetAccessiblePlatformState(state) {
         return call("libgtk-4.so.1", "gtk_editable_delegate_get_accessible_platform_state", [
             {
@@ -399,6 +723,11 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Deletes the currently selected text of the editable.
+     *
+     * This call doesn’t do anything if there is no selected text.
+     */
     deleteSelection() {
         call("libgtk-4.so.1", "gtk_editable_delete_selection", [
             {
@@ -407,6 +736,18 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Deletes a sequence of characters.
+     *
+     * The characters that are deleted are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is
+     * negative, then the characters deleted are those from `start_pos` to
+     * the end of the text.
+     *
+     * Note that the positions are specified in characters, not bytes.
+     * @param startPos - start position
+     * @param endPos - end position
+     */
     deleteText(startPos, endPos) {
         call("libgtk-4.so.1", "gtk_editable_delete_text", [
             {
@@ -423,6 +764,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Undoes the setup done by [method@Gtk.Editable.init_delegate].
+     *
+     * This is a helper function that should be called from dispose,
+     * before removing the delegate object.
+     */
     finishDelegate() {
         call("libgtk-4.so.1", "gtk_editable_finish_delegate", [
             {
@@ -431,6 +778,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the alignment of the editable.
+     */
     getAlignment() {
         return call("libgtk-4.so.1", "gtk_editable_get_alignment", [
             {
@@ -439,6 +789,18 @@ export class SpinButton extends Widget {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves a sequence of characters.
+     *
+     * The characters that are retrieved are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is negative,
+     * then the characters retrieved are those characters from `start_pos` to
+     * the end of the text.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - start of text
+     * @param endPos - end of text
+     */
     getChars(startPos, endPos) {
         return call("libgtk-4.so.1", "gtk_editable_get_chars", [
             {
@@ -455,6 +817,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the `GtkEditable` that `editable` is delegating its
+     * implementation to.
+     *
+     * Typically, the delegate is a [class@Gtk.Text] widget.
+     */
     getDelegate() {
         const ptr = call("libgtk-4.so.1", "gtk_editable_get_delegate", [
             {
@@ -466,6 +834,9 @@ export class SpinButton extends Widget {
             return null;
         return getObject(ptr, Editable);
     }
+    /**
+     * Retrieves whether `editable` is editable.
+     */
     getEditable() {
         return call("libgtk-4.so.1", "gtk_editable_get_editable", [
             {
@@ -474,6 +845,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets if undo/redo actions are enabled for @editable
+     */
     getEnableUndo() {
         return call("libgtk-4.so.1", "gtk_editable_get_enable_undo", [
             {
@@ -482,6 +856,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the desired maximum width of @editable, in characters.
+     */
     getMaxWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_max_width_chars", [
             {
@@ -490,6 +867,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the current position of the cursor relative
+     * to the start of the content of the editable.
+     *
+     * Note that this position is in characters, not in bytes.
+     */
     getPosition() {
         return call("libgtk-4.so.1", "gtk_editable_get_position", [
             {
@@ -498,6 +881,17 @@ export class SpinButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the selection bound of the editable.
+     *
+     * `start_pos` will be filled with the start of the selection and
+     * `end_pos` with end. If no text was selected both will be identical
+     * and %FALSE will be returned.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - location to store the starting position
+     * @param endPos - location to store the end position
+     */
     getSelectionBounds(startPos, endPos) {
         return call("libgtk-4.so.1", "gtk_editable_get_selection_bounds", [
             {
@@ -522,6 +916,11 @@ export class SpinButton extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the contents of @editable.
+     *
+     * The returned string is owned by GTK and must not be modified or freed.
+     */
     getText() {
         return call("libgtk-4.so.1", "gtk_editable_get_text", [
             {
@@ -530,6 +929,10 @@ export class SpinButton extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the number of characters of space reserved
+     * for the contents of the editable.
+     */
     getWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_width_chars", [
             {
@@ -538,6 +941,15 @@ export class SpinButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets up a delegate for `GtkEditable`.
+     *
+     * This is assuming that the get_delegate vfunc in the `GtkEditable`
+     * interface has been set up for the @editable's type.
+     *
+     * This is a helper function that should be called in instance init,
+     * after creating the delegate object.
+     */
     initDelegate() {
         call("libgtk-4.so.1", "gtk_editable_init_delegate", [
             {
@@ -546,6 +958,17 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Inserts `length` bytes of `text` into the contents of the
+     * widget, at position @position.
+     *
+     * Note that the position is in characters, not in bytes.
+     * The function updates `position` to point after the newly
+     * inserted text.
+     * @param text - the text to insert
+     * @param length - the length of the text in bytes, or -1
+     * @param position - location of the position text will be inserted at
+     */
     insertText(text, length, position) {
         call("libgtk-4.so.1", "gtk_editable_insert_text", [
             {
@@ -569,6 +992,18 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Selects a region of text.
+     *
+     * The characters that are selected are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is
+     * negative, then the characters selected are those characters from
+     * `start_pos` to  the end of the text.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - start of region
+     * @param endPos - end of region
+     */
     selectRegion(startPos, endPos) {
         call("libgtk-4.so.1", "gtk_editable_select_region", [
             {
@@ -585,6 +1020,13 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the alignment for the contents of the editable.
+     *
+     * This controls the horizontal positioning of the contents when
+     * the displayed text is shorter than the width of the editable.
+     * @param xalign - The horizontal alignment, from 0 (left) to 1 (right).
+     */
     setAlignment(xalign) {
         call("libgtk-4.so.1", "gtk_editable_set_alignment", [
             {
@@ -597,6 +1039,10 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Determines if the user can edit the text in the editable widget.
+     * @param isEditable - %TRUE if the user is allowed to edit the text
+     */
     setEditable(isEditable) {
         call("libgtk-4.so.1", "gtk_editable_set_editable", [
             {
@@ -609,6 +1055,15 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If enabled, changes to `editable` will be saved for undo/redo
+     * actions.
+     *
+     * This results in an additional copy of text changes and are not
+     * stored in secure memory. As such, undo is forcefully disabled
+     * when [property@Gtk.Text:visibility] is set to %FALSE.
+     * @param enableUndo - if undo/redo should be enabled
+     */
     setEnableUndo(enableUndo) {
         call("libgtk-4.so.1", "gtk_editable_set_enable_undo", [
             {
@@ -621,6 +1076,10 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the desired maximum width in characters of @editable.
+     * @param nChars - the new desired maximum width, in characters
+     */
     setMaxWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_editable_set_max_width_chars", [
             {
@@ -633,6 +1092,16 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the cursor position in the editable to the given value.
+     *
+     * The cursor is displayed before the character with the given (base 0)
+     * index in the contents of the editable. The value must be less than
+     * or equal to the number of characters in the editable. A value of -1
+     * indicates that the position should be set after the last character
+     * of the editable. Note that `position` is in characters, not in bytes.
+     * @param position - the position of the cursor
+     */
     setPosition(position) {
         call("libgtk-4.so.1", "gtk_editable_set_position", [
             {
@@ -645,6 +1114,12 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text in the editable to the given value.
+     *
+     * This is replacing the current contents.
+     * @param text - the text to set
+     */
     setText(text) {
         call("libgtk-4.so.1", "gtk_editable_set_text", [
             {
@@ -657,6 +1132,15 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes the size request of the editable to be about the
+     * right size for `n_chars` characters.
+     *
+     * Note that it changes the size request, the size can still
+     * be affected by how you pack the widget into containers.
+     * If `n_chars` is -1, the size reverts to the default size.
+     * @param nChars - width in chars
+     */
     setWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_editable_set_width_chars", [
             {
@@ -669,6 +1153,9 @@ export class SpinButton extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_orientable_get_orientation", [
             {
@@ -677,6 +1164,10 @@ export class SpinButton extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation) {
         call("libgtk-4.so.1", "gtk_orientable_set_orientation", [
             {