@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/text.js

@@ -5,6 +5,118 @@ import { EntryBuffer } from "./entry-buffer.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
+/**
+ * A single-line text entry.
+ *
+ * `GtkText` is the common implementation of single-line text editing
+ * that is shared between [class@Gtk.Entry], [class@Gtk.PasswordEntry],
+ * [class@Gtk.SpinButton], and other widgets. In all of these, a `GtkText`
+ * instance is used as the delegate for the [iface@Gtk.Editable] implementation.
+ *
+ * A large number of key bindings s supported by default. If the entered
+ * text is longer than the allocation of the widget, the widget will scroll
+ * so that the cursor position is visible.
+ *
+ * When using an entry for passwords and other sensitive information,
+ * it can be put into “password mode” using [method@Gtk.Text.set_visibility].
+ * In this mode, entered text is displayed using an “invisible” character.
+ * By default, GTK picks the best invisible character that is available
+ * in the current font, but it can be changed with
+ * [method@Gtk.Text.set_invisible_char].
+ *
+ * If you want to add icons or progress display in an entry, look at
+ * [class@Gtk.Entry]. There are other alternatives for more specialized
+ * use cases, such as [class@Gtk.SearchEntry].
+ *
+ * If you need multi-line editable text, use [class@Gtk.TextView].
+ *
+ * # Shortcuts and Gestures
+ *
+ * `GtkText` supports the following keyboard shortcuts:
+ *
+ * - `Shift`+`F10` or `Menu` opens the context menu.
+ * - `Ctrl`+`A` or `Ctrl`+`/`
+ * selects all the text.
+ * - `Ctrl`+`Shift`+`A` or
+ * `Ctrl`+`\` unselects all.
+ * - `Ctrl`+`Z` undoes the last modification.
+ * - `Ctrl`+`Y` or `Ctrl`+`Shift`+`Z`
+ * redoes the last undone modification.
+ * - `Ctrl`+`Shift`+`T` toggles the text direction.
+ * - `Clear` clears the content.
+ *
+ * Additionally, the following signals have default keybindings:
+ *
+ * - [signal@Gtk.Text::activate]
+ * - [signal@Gtk.Text::backspace]
+ * - [signal@Gtk.Text::copy-clipboard]
+ * - [signal@Gtk.Text::cut-clipboard]
+ * - [signal@Gtk.Text::delete-from-cursor]
+ * - [signal@Gtk.Text::insert-emoji]
+ * - [signal@Gtk.Text::move-cursor]
+ * - [signal@Gtk.Text::paste-clipboard]
+ * - [signal@Gtk.Text::toggle-overwrite]
+ *
+ * # Actions
+ *
+ * `GtkText` defines a set of built-in actions:
+ *
+ * - `clipboard.copy` copies the contents to the clipboard.
+ * - `clipboard.cut` copies the contents to the clipboard and deletes it from
+ * the widget.
+ * - `clipboard.paste` inserts the contents of the clipboard into the widget.
+ * - `menu.popup` opens the context menu.
+ * - `misc.insert-emoji` opens the Emoji chooser.
+ * - `misc.toggle-visibility` toggles the `GtkText`:visibility property.
+ * - `misc.toggle-direction` toggles the text direction.
+ * - `selection.delete` deletes the current selection.
+ * - `selection.select-all` selects all of the widgets content.
+ * - `text.redo` redoes the last change to the contents.
+ * - `text.undo` undoes the last change to the contents.
+ * - `text.clear` removes all content.
+ *
+ * # CSS nodes
+ *
+ * ```
+ * text[.read-only]
+ * ├── placeholder
+ * ├── undershoot.left
+ * ├── undershoot.right
+ * ├── [selection]
+ * ├── [cursor-handle[.top]
+ * ├── [cursor-handle.bottom]
+ * ├── [block-cursor]
+ * ├── [cursor-handle[.top/.bottom][.insertion-cursor]]
+ * ╰── [window.popup]
+ * ```
+ *
+ * `GtkText` has a main node with the name `text`. Depending on the properties
+ * of the widget, the `.read-only` style class may appear.
+ *
+ * When the entry has a selection, it adds a subnode with the name `selection`.
+ *
+ * When the entry is in overwrite mode, it adds a subnode with the name
+ * `block-cursor` that determines how the block cursor is drawn.
+ *
+ * The CSS node for a context menu is added as a subnode with the name `popup`.
+ *
+ * The `undershoot` nodes are used to draw the underflow indication when content
+ * is scrolled out of view. These nodes get the `.left` or `.right` style class
+ * added depending on where the indication is drawn.
+ *
+ * When touch is used and touch selection handles are shown, they are using
+ * CSS nodes with name `cursor-handle`. They get the `.top` or `.bottom` style
+ * class depending on where they are shown in relation to the selection. If
+ * there is just a single handle for the text cursor, it gets the style class
+ * `.insertion-cursor`.
+ *
+ * # Accessibility
+ *
+ * `GtkText` uses the [enum@Gtk.AccessibleRole.none] role, which causes it to be
+ * skipped for accessibility. This is because `GtkText` is expected to be used
+ * as a delegate for a `GtkEditable` implementation that will be represented
+ * to accessibility.
+ */
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     backspace: { params: [], returnType: { type: "undefined" } },
@@ -38,9 +150,16 @@ const SIGNAL_META = {
     "toggle-overwrite": { params: [], returnType: { type: "undefined" } },
 };
 export class Text extends Widget {
+    /**
+     * Creates a new `GtkText`.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new `GtkText` with the specified buffer.
+     * @param buffer - the buffer to use
+     */
     static newWithBuffer(buffer) {
         const ptr = call("libgtk-4.so.1", "gtk_text_new_with_buffer", [
             {
@@ -56,6 +175,21 @@ export class Text extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Determines the positions of the strong and weak cursors for a
+     * given character position.
+     *
+     * The position of each cursor is stored as a zero-width rectangle.
+     * The strong cursor location is the location where characters of
+     * the directionality equal to the base direction are inserted.
+     * The weak cursor location is the location where characters of
+     * the directionality opposite to the base direction are inserted.
+     *
+     * The rectangle positions are in widget coordinates.
+     * @param position - the character position
+     * @param strong - location to store the strong cursor position
+     * @param weak - location to store the weak cursor position
+     */
     computeCursorExtents(position, strong, weak) {
         call("libgtk-4.so.1", "gtk_text_compute_cursor_extents", [
             {
@@ -92,6 +226,12 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether pressing `Enter` will activate
+     * the default widget for the window containing the widget.
+     *
+     * See [method@Gtk.Text.set_activates_default].
+     */
     getActivatesDefault() {
         return call("libgtk-4.so.1", "gtk_text_get_activates_default", [
             {
@@ -100,6 +240,11 @@ export class Text extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the attribute list that was set on the text widget.
+     *
+     * See [method@Gtk.Text.set_attributes].
+     */
     getAttributes() {
         const ptr = call("libgtk-4.so.1", "gtk_text_get_attributes", [
             {
@@ -116,6 +261,10 @@ export class Text extends Widget {
             return null;
         return getObject(ptr, Pango.AttrList);
     }
+    /**
+     * Get the entry buffer object which holds the text for
+     * this widget.
+     */
     getBuffer() {
         const ptr = call("libgtk-4.so.1", "gtk_text_get_buffer", [
             {
@@ -125,6 +274,9 @@ export class Text extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, EntryBuffer);
     }
+    /**
+     * Returns whether Emoji completion is enabled.
+     */
     getEnableEmojiCompletion() {
         return call("libgtk-4.so.1", "gtk_text_get_enable_emoji_completion", [
             {
@@ -133,6 +285,11 @@ export class Text extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the extra menu model of the text widget.
+     *
+     * See [method@Gtk.Text.set_extra_menu].
+     */
     getExtraMenu() {
         const ptr = call("libgtk-4.so.1", "gtk_text_get_extra_menu", [
             {
@@ -144,6 +301,9 @@ export class Text extends Widget {
             return null;
         return getObject(ptr, Gio.MenuModel);
     }
+    /**
+     * Gets the input hints of the text widget.
+     */
     getInputHints() {
         return call("libgtk-4.so.1", "gtk_text_get_input_hints", [
             {
@@ -152,6 +312,9 @@ export class Text extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the input purpose of the text widget.
+     */
     getInputPurpose() {
         return call("libgtk-4.so.1", "gtk_text_get_input_purpose", [
             {
@@ -160,6 +323,13 @@ export class Text extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the character displayed when visibility is set to false.
+     *
+     * Note that GTK does not compute this value unless it needs it,
+     * so the value returned by this function is not very useful unless
+     * it has been explicitly set with [method@Gtk.Text.set_invisible_char].
+     */
     getInvisibleChar() {
         return call("libgtk-4.so.1", "gtk_text_get_invisible_char", [
             {
@@ -168,6 +338,14 @@ export class Text extends Widget {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Retrieves the maximum allowed length of the contents.
+     *
+     * See [method@Gtk.Text.set_max_length].
+     *
+     * This is equivalent to getting @self's `GtkEntryBuffer` and
+     * calling [method@Gtk.EntryBuffer.get_max_length] on it.
+     */
     getMaxLength() {
         return call("libgtk-4.so.1", "gtk_text_get_max_length", [
             {
@@ -176,6 +354,11 @@ export class Text extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets whether text is overwritten when typing.
+     *
+     * See [method@Gtk.Text.set_overwrite_mode].
+     */
     getOverwriteMode() {
         return call("libgtk-4.so.1", "gtk_text_get_overwrite_mode", [
             {
@@ -184,6 +367,12 @@ export class Text extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the text that will be displayed when the text widget
+     * is empty and unfocused
+     *
+     * See [method@Gtk.Text.set_placeholder_text].
+     */
     getPlaceholderText() {
         return call("libgtk-4.so.1", "gtk_text_get_placeholder_text", [
             {
@@ -192,6 +381,10 @@ export class Text extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns whether the text widget will grow and shrink
+     * with the content.
+     */
     getPropagateTextWidth() {
         return call("libgtk-4.so.1", "gtk_text_get_propagate_text_width", [
             {
@@ -200,6 +393,11 @@ export class Text extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the tab stops for the text widget.
+     *
+     * See [method@Gtk.Text.set_tabs].
+     */
     getTabs() {
         const ptr = call("libgtk-4.so.1", "gtk_text_get_tabs", [
             {
@@ -216,6 +414,12 @@ export class Text extends Widget {
             return null;
         return getObject(ptr, Pango.TabArray);
     }
+    /**
+     * Retrieves the length of the contents.
+     *
+     * This is equivalent to getting @self's `GtkEntryBuffer`
+     * and calling [method@Gtk.EntryBuffer.get_length] on it.
+     */
     getTextLength() {
         return call("libgtk-4.so.1", "gtk_text_get_text_length", [
             {
@@ -224,6 +428,9 @@ export class Text extends Widget {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Returns whether pasted text will be truncated to the first line.
+     */
     getTruncateMultiline() {
         return call("libgtk-4.so.1", "gtk_text_get_truncate_multiline", [
             {
@@ -232,6 +439,9 @@ export class Text extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves whether the text is visible.
+     */
     getVisibility() {
         return call("libgtk-4.so.1", "gtk_text_get_visibility", [
             {
@@ -240,6 +450,16 @@ export class Text extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Causes the text widget to have the keyboard focus.
+     *
+     * It behaves like [method@Gtk.Widget.grab_focus],
+     * except that it does not select the contents of @self.
+     *
+     * You only want to call this on some special entries
+     * which the user usually doesn't want to replace all
+     * text in, such as search-as-you-type entries.
+     */
     grabFocusWithoutSelecting() {
         return call("libgtk-4.so.1", "gtk_text_grab_focus_without_selecting", [
             {
@@ -248,6 +468,15 @@ export class Text extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets whether pressing `Enter` will activate
+     * the default widget.
+     *
+     * This usually means that the dialog containing `self` will
+     * be closed, since the default widget is usually one of
+     * the dialog buttons.
+     * @param activates - true to activate window’s default widget on
+     */
     setActivatesDefault(activates) {
         call("libgtk-4.so.1", "gtk_text_set_activates_default", [
             {
@@ -260,6 +489,10 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Apply attributes to the contents of the text widget.
+     * @param attrs - a list of style attributes
+     */
     setAttributes(attrs) {
         call("libgtk-4.so.1", "gtk_text_set_attributes", [
             {
@@ -278,6 +511,11 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the entry buffer object which holds the text for
+     * this widget.
+     * @param buffer - an entry buffer object
+     */
     setBuffer(buffer) {
         call("libgtk-4.so.1", "gtk_text_set_buffer", [
             {
@@ -290,6 +528,14 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether Emoji completion is enabled.
+     *
+     * If it is, typing ':', followed by a recognized keyword,
+     * will pop up a window with suggested Emojis matching the
+     * keyword.
+     * @param enableEmojiCompletion - true to enable Emoji completion
+     */
     setEnableEmojiCompletion(enableEmojiCompletion) {
         call("libgtk-4.so.1", "gtk_text_set_enable_emoji_completion", [
             {
@@ -302,6 +548,10 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a menu model to add to the context menu of the text widget.
+     * @param model - a menu model
+     */
     setExtraMenu(model) {
         call("libgtk-4.so.1", "gtk_text_set_extra_menu", [
             {
@@ -315,6 +565,10 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets hints that allow input methods to fine-tune their behaviour.
+     * @param hints - input hints
+     */
     setInputHints(hints) {
         call("libgtk-4.so.1", "gtk_text_set_input_hints", [
             {
@@ -327,6 +581,13 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the input purpose of the text widget.
+     *
+     * The input purpose can be used by on-screen keyboards
+     * and other input methods to adjust their behaviour.
+     * @param purpose - the input purpose
+     */
     setInputPurpose(purpose) {
         call("libgtk-4.so.1", "gtk_text_set_input_purpose", [
             {
@@ -339,6 +600,15 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the character to use when in “password mode”.
+     *
+     * By default, GTK picks the best invisible char available in the
+     * current font. If you set the invisible char to 0, then the user
+     * will get no feedback at all; there will be no text on the screen
+     * as they type.
+     * @param ch - a Unicode character
+     */
     setInvisibleChar(ch) {
         call("libgtk-4.so.1", "gtk_text_set_invisible_char", [
             {
@@ -351,6 +621,16 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the maximum allowed length of the contents.
+     *
+     * If the current contents are longer than the given length,
+     * they will be truncated to fit.
+     *
+     * This is equivalent to getting @self's `GtkEntryBuffer` and
+     * calling [method@Gtk.EntryBuffer.set_max_length] on it.
+     * @param length - the maximum length of the text, or 0 for no maximum.
+     */
     setMaxLength(length) {
         call("libgtk-4.so.1", "gtk_text_set_max_length", [
             {
@@ -363,6 +643,10 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the text is overwritten when typing.
+     * @param overwrite - new value
+     */
     setOverwriteMode(overwrite) {
         call("libgtk-4.so.1", "gtk_text_set_overwrite_mode", [
             {
@@ -375,6 +659,14 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text to be displayed when the text widget is
+     * empty and unfocused.
+     *
+     * This can be used to give a visual hint of the expected
+     * contents of the text widget.
+     * @param text - a string to be displayed when `self`   is empty and unfocused
+     */
     setPlaceholderText(text) {
         call("libgtk-4.so.1", "gtk_text_set_placeholder_text", [
             {
@@ -388,6 +680,10 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the text widget should grow and shrink with the content.
+     * @param propagateTextWidth - true to propagate the text width
+     */
     setPropagateTextWidth(propagateTextWidth) {
         call("libgtk-4.so.1", "gtk_text_set_propagate_text_width", [
             {
@@ -400,6 +696,10 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets tab stops for the text widget.
+     * @param tabs - tab stops
+     */
     setTabs(tabs) {
         call("libgtk-4.so.1", "gtk_text_set_tabs", [
             {
@@ -418,6 +718,10 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether pasted text should be truncated to the first line.
+     * @param truncateMultiline - true to truncate multi-line text
+     */
     setTruncateMultiline(truncateMultiline) {
         call("libgtk-4.so.1", "gtk_text_set_truncate_multiline", [
             {
@@ -430,6 +734,23 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the contents of the text widget are visible or not.
+     *
+     * When visibility is set to false, characters are displayed
+     * as the invisible char, and it will also appear that way when
+     * the text in the widget is copied to the clipboard.
+     *
+     * By default, GTK picks the best invisible character available
+     * in the current font, but it can be changed with
+     * [method@Gtk.Text.set_invisible_char].
+     *
+     * Note that you probably want to set [property@Gtk.Text:input-purpose]
+     * to [enum@Gtk.InputPurpose.password] or [enum@Gtk.InputPurpose.pin]
+     * to inform input methods about the purpose of this widget, in addition
+     * to setting visibility to false.
+     * @param visible - true if the contents of the text widget are displayed
+     */
     setVisibility(visible) {
         call("libgtk-4.so.1", "gtk_text_set_visibility", [
             {
@@ -442,6 +763,11 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unsets the invisible char.
+     *
+     * After calling this, the default invisible char is used again.
+     */
     unsetInvisibleChar() {
         call("libgtk-4.so.1", "gtk_text_unset_invisible_char", [
             {
@@ -450,6 +776,13 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates the position of the caret.
+     *
+     * Implementations of the `GtkAccessibleText` interface should call this
+     * function every time the caret has moved, in order to notify assistive
+     * technologies.
+     */
     updateCaretPosition() {
         call("libgtk-4.so.1", "gtk_accessible_text_update_caret_position", [
             {
@@ -458,6 +791,20 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Notifies assistive technologies of a change in contents.
+     *
+     * Implementations of the `GtkAccessibleText` interface should call this
+     * function every time their contents change as the result of an operation,
+     * like an insertion or a removal.
+     *
+     * Note: If the change is a deletion, this function must be called *before*
+     * removing the contents, if it is an insertion, it must be called *after*
+     * inserting the new contents.
+     * @param change - the type of change in the contents
+     * @param start - the starting offset of the change, in characters
+     * @param end - the end offset of the change, in characters
+     */
     updateContents(change, start, end) {
         call("libgtk-4.so.1", "gtk_accessible_text_update_contents", [
             {
@@ -478,6 +825,13 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates the boundary of the selection.
+     *
+     * Implementations of the `GtkAccessibleText` interface should call this
+     * function every time the selection has moved, in order to notify assistive
+     * technologies.
+     */
     updateSelectionBound() {
         call("libgtk-4.so.1", "gtk_accessible_text_update_selection_bound", [
             {
@@ -486,6 +840,41 @@ export class Text 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", [
             {
@@ -498,6 +887,11 @@ export class Text 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", [
             {
@@ -506,6 +900,18 @@ export class Text 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", [
             {
@@ -522,6 +928,12 @@ export class Text 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", [
             {
@@ -530,6 +942,9 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the alignment of the editable.
+     */
     getAlignment() {
         return call("libgtk-4.so.1", "gtk_editable_get_alignment", [
             {
@@ -538,6 +953,18 @@ export class Text 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", [
             {
@@ -554,6 +981,12 @@ export class Text 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", [
             {
@@ -565,6 +998,9 @@ export class Text extends Widget {
             return null;
         return getObject(ptr, Editable);
     }
+    /**
+     * Retrieves whether `editable` is editable.
+     */
     getEditable() {
         return call("libgtk-4.so.1", "gtk_editable_get_editable", [
             {
@@ -573,6 +1009,9 @@ export class Text 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", [
             {
@@ -581,6 +1020,9 @@ export class Text 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", [
             {
@@ -589,6 +1031,12 @@ export class Text 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", [
             {
@@ -597,6 +1045,17 @@ export class Text 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", [
             {
@@ -621,6 +1080,11 @@ export class Text 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", [
             {
@@ -629,6 +1093,10 @@ export class Text 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", [
             {
@@ -637,6 +1105,15 @@ export class Text 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", [
             {
@@ -645,6 +1122,17 @@ export class Text 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", [
             {
@@ -668,6 +1156,18 @@ export class Text 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", [
             {
@@ -684,6 +1184,13 @@ export class Text 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", [
             {
@@ -696,6 +1203,10 @@ export class Text 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", [
             {
@@ -708,6 +1219,15 @@ export class Text 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", [
             {
@@ -720,6 +1240,10 @@ export class Text 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", [
             {
@@ -732,6 +1256,16 @@ export class Text 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", [
             {
@@ -744,6 +1278,12 @@ export class Text 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", [
             {
@@ -756,6 +1296,15 @@ export class Text 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", [
             {