@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/entry.js

@@ -7,6 +7,95 @@ import * as Gdk from "../gdk/index.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 widget.
+ *
+ *
+ *
+ * A fairly large set of key bindings are 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.Entry.set_visibility].
+ * In this mode, entered text is displayed using a “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.Entry.set_invisible_char].
+ *
+ * `GtkEntry` has the ability to display progress or activity
+ * information behind the text. To make an entry display such information,
+ * use [method@Gtk.Entry.set_progress_fraction] or
+ * [method@Gtk.Entry.set_progress_pulse_step].
+ *
+ * Additionally, `GtkEntry` can show icons at either side of the entry.
+ * These icons can be activatable by clicking, can be set up as drag source
+ * and can have tooltips. To add an icon, use
+ * [method@Gtk.Entry.set_icon_from_gicon] or one of the various other functions
+ * that set an icon from an icon name or a paintable. To trigger an action when
+ * the user clicks an icon, connect to the [signal@Gtk.Entry::icon-press] signal.
+ * To allow DND operations from an icon, use
+ * [method@Gtk.Entry.set_icon_drag_source]. To set a tooltip on an icon, use
+ * [method@Gtk.Entry.set_icon_tooltip_text] or the corresponding function
+ * for markup.
+ *
+ * Note that functionality or information that is only available by clicking
+ * on an icon in an entry may not be accessible at all to users which are not
+ * able to use a mouse or other pointing device. It is therefore recommended
+ * that any such functionality should also be available by other means, e.g.
+ * via the context menu of the entry.
+ *
+ * # CSS nodes
+ *
+ * ```
+ * entry[.flat][.warning][.error]
+ * ├── text[.readonly]
+ * ├── image.left
+ * ├── image.right
+ * ╰── [progress[.pulse]]
+ * ```
+ *
+ * `GtkEntry` has a main node with the name entry. Depending on the properties
+ * of the entry, the style classes .read-only and .flat may appear. The style
+ * classes .warning and .error may also be used with entries.
+ *
+ * When the entry shows icons, it adds subnodes with the name image and the
+ * style class .left or .right, depending on where the icon appears.
+ *
+ * When the entry shows progress, it adds a subnode with the name progress.
+ * The node has the style class .pulse when the shown progress is pulsing.
+ *
+ * For all the subnodes added to the text node in various situations,
+ * see [class@Gtk.Text].
+ *
+ * # GtkEntry as GtkBuildable
+ *
+ * The `GtkEntry` implementation of the `GtkBuildable` interface supports a
+ * custom `<attributes>` element, which supports any number of `<attribute>`
+ * elements. The `<attribute>` element has attributes named “name“, “value“,
+ * “start“ and “end“ and allows you to specify `PangoAttribute` values for
+ * this label.
+ *
+ * An example of a UI definition fragment specifying Pango attributes:
+ * ```xml
+ * <object class="GtkEntry">
+ * <attributes>
+ * <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
+ * <attribute name="background" value="red" start="5" end="10"/>
+ * </attributes>
+ * </object>
+ * ```
+ *
+ * The start and end attributes specify the range of characters to which the
+ * Pango attribute applies. If start and end are not specified, the attribute
+ * is applied to the whole text. Note that specifying ranges does not make much
+ * sense with translatable attributes. Use markup embedded in the translatable
+ * content instead.
+ *
+ * # Accessibility
+ *
+ * `GtkEntry` uses the [enum@Gtk.AccessibleRole.text_box] role.
+ */
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     "icon-press": {
@@ -19,9 +108,16 @@ const SIGNAL_META = {
     },
 };
 export class Entry extends Widget {
+    /**
+     * Creates a new entry.
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new entry with the specified text buffer.
+     * @param buffer - The buffer to use for the new `GtkEntry`.
+     */
     static newWithBuffer(buffer) {
         const ptr = call("libgtk-4.so.1", "gtk_entry_new_with_buffer", [
             {
@@ -37,6 +133,9 @@ export class Entry extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Retrieves the value set by gtk_entry_set_activates_default().
+     */
     getActivatesDefault() {
         return call("libgtk-4.so.1", "gtk_entry_get_activates_default", [
             {
@@ -45,6 +144,11 @@ export class Entry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the value set by gtk_entry_set_alignment().
+     *
+     * See also: [property@Gtk.Editable:xalign]
+     */
     getAlignment() {
         return call("libgtk-4.so.1", "gtk_entry_get_alignment", [
             {
@@ -53,6 +157,11 @@ export class Entry extends Widget {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Gets the attribute list of the `GtkEntry`.
+     *
+     * See [method@Gtk.Entry.set_attributes].
+     */
     getAttributes() {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_attributes", [
             {
@@ -69,6 +178,10 @@ export class Entry extends Widget {
             return null;
         return getObject(ptr, Pango.AttrList);
     }
+    /**
+     * Get the `GtkEntryBuffer` object which holds the text for
+     * this widget.
+     */
     getBuffer() {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_buffer", [
             {
@@ -78,6 +191,10 @@ export class Entry extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, EntryBuffer);
     }
+    /**
+     * Returns the auxiliary completion object currently
+     * in use by @entry.
+     */
     getCompletion() {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_completion", [
             {
@@ -89,6 +206,10 @@ export class Entry extends Widget {
             return null;
         return getObject(ptr, EntryCompletion);
     }
+    /**
+     * Returns the index of the icon which is the source of the
+     * current  DND operation, or -1.
+     */
     getCurrentIconDragSource() {
         return call("libgtk-4.so.1", "gtk_entry_get_current_icon_drag_source", [
             {
@@ -97,6 +218,9 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the menu model set with gtk_entry_set_extra_menu().
+     */
     getExtraMenu() {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_extra_menu", [
             {
@@ -108,6 +232,9 @@ export class Entry extends Widget {
             return null;
         return getObject(ptr, Gio.MenuModel);
     }
+    /**
+     * Gets the value set by gtk_entry_set_has_frame().
+     */
     getHasFrame() {
         return call("libgtk-4.so.1", "gtk_entry_get_has_frame", [
             {
@@ -116,6 +243,10 @@ export class Entry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the icon is activatable.
+     * @param iconPos - Icon position
+     */
     getIconActivatable(iconPos) {
         return call("libgtk-4.so.1", "gtk_entry_get_icon_activatable", [
             {
@@ -128,6 +259,19 @@ export class Entry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the area where entry’s icon at `icon_pos` is drawn.
+     *
+     * This function is useful when drawing something to the
+     * entry in a draw callback.
+     *
+     * If the entry is not realized or has no icon at the given
+     * position, `icon_area` is filled with zeros. Otherwise,
+     * `icon_area` will be filled with the icon's allocation,
+     * relative to @entry's allocation.
+     * @param iconPos - Icon position
+     * @param iconArea - Return location for the icon’s area
+     */
     getIconArea(iconPos, iconArea) {
         call("libgtk-4.so.1", "gtk_entry_get_icon_area", [
             {
@@ -151,6 +295,16 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finds the icon at the given position and return its index.
+     *
+     * The position’s coordinates are relative to the @entry’s
+     * top left corner. If @x, `y` doesn’t lie inside an icon,
+     * -1 is returned. This function is intended for use in a
+     * [signal@Gtk.Widget::query-tooltip] signal handler.
+     * @param x - the x coordinate of the position to find, relative to @entry
+     * @param y - the y coordinate of the position to find, relative to @entry
+     */
     getIconAtPos(x, y) {
         return call("libgtk-4.so.1", "gtk_entry_get_icon_at_pos", [
             {
@@ -167,6 +321,13 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the `GIcon` used for the icon.
+     *
+     * %NULL will be returned if there is no icon or if the icon was
+     * set by some other method (e.g., by `GdkPaintable` or icon name).
+     * @param iconPos - Icon position
+     */
     getIconGicon(iconPos) {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_icon_gicon", [
             {
@@ -182,6 +343,13 @@ export class Entry extends Widget {
             return null;
         return getObject(ptr, Gio.Icon);
     }
+    /**
+     * Retrieves the icon name used for the icon.
+     *
+     * %NULL is returned if there is no icon or if the icon was set
+     * by some other method (e.g., by `GdkPaintable` or gicon).
+     * @param iconPos - Icon position
+     */
     getIconName(iconPos) {
         return call("libgtk-4.so.1", "gtk_entry_get_icon_name", [
             {
@@ -194,6 +362,12 @@ export class Entry extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Retrieves the `GdkPaintable` used for the icon.
+     *
+     * If no `GdkPaintable` was used for the icon, %NULL is returned.
+     * @param iconPos - Icon position
+     */
     getIconPaintable(iconPos) {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_icon_paintable", [
             {
@@ -209,6 +383,10 @@ export class Entry extends Widget {
             return null;
         return getObject(ptr, Gdk.Paintable);
     }
+    /**
+     * Returns whether the icon appears sensitive or insensitive.
+     * @param iconPos - Icon position
+     */
     getIconSensitive(iconPos) {
         return call("libgtk-4.so.1", "gtk_entry_get_icon_sensitive", [
             {
@@ -221,6 +399,14 @@ export class Entry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the type of representation being used by the icon
+     * to store image data.
+     *
+     * If the icon has no image data, the return value will
+     * be %GTK_IMAGE_EMPTY.
+     * @param iconPos - Icon position
+     */
     getIconStorageType(iconPos) {
         return call("libgtk-4.so.1", "gtk_entry_get_icon_storage_type", [
             {
@@ -233,6 +419,11 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the contents of the tooltip on the icon at the specified
+     * position in @entry.
+     * @param iconPos - the icon position
+     */
     getIconTooltipMarkup(iconPos) {
         return call("libgtk-4.so.1", "gtk_entry_get_icon_tooltip_markup", [
             {
@@ -245,6 +436,11 @@ export class Entry extends Widget {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the contents of the tooltip on the icon at the specified
+     * position in @entry.
+     * @param iconPos - the icon position
+     */
     getIconTooltipText(iconPos) {
         return call("libgtk-4.so.1", "gtk_entry_get_icon_tooltip_text", [
             {
@@ -257,6 +453,9 @@ export class Entry extends Widget {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the input hints of this `GtkEntry`.
+     */
     getInputHints() {
         return call("libgtk-4.so.1", "gtk_entry_get_input_hints", [
             {
@@ -265,6 +464,9 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the input purpose of the `GtkEntry`.
+     */
     getInputPurpose() {
         return call("libgtk-4.so.1", "gtk_entry_get_input_purpose", [
             {
@@ -273,6 +475,10 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the character displayed in place of the actual text
+     * in “password mode”.
+     */
     getInvisibleChar() {
         return call("libgtk-4.so.1", "gtk_entry_get_invisible_char", [
             {
@@ -281,6 +487,11 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Retrieves the maximum allowed length of the text in @entry.
+     *
+     * See [method@Gtk.Entry.set_max_length].
+     */
     getMaxLength() {
         return call("libgtk-4.so.1", "gtk_entry_get_max_length", [
             {
@@ -289,6 +500,15 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the text that will be used in the context menu of the `GtkEntry`
+     * when the specified icon is activatable. Selecting this item in the menu
+     * results, from all aspects, the same than clicking on the specified icon.
+     * This greatly simplifies making accessible applications, because the icons
+     * aren't focusable when using keyboard navigation. This is why Gtk recommends
+     * to add the same action to the context menu.
+     * @param iconPos - either `GTK_ENTRY_ICON_PRIMARY` or @GTK_ENTRY_ICON_SECONDARY
+     */
     getMenuEntryIconText(iconPos) {
         return call("libgtk-4.so.1", "gtk_entry_get_menu_entry_icon_text", [
             {
@@ -301,6 +521,9 @@ export class Entry extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets whether the `GtkEntry` is in overwrite mode.
+     */
     getOverwriteMode() {
         return call("libgtk-4.so.1", "gtk_entry_get_overwrite_mode", [
             {
@@ -309,6 +532,9 @@ export class Entry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the text that will be displayed when `entry` is empty and unfocused
+     */
     getPlaceholderText() {
         return call("libgtk-4.so.1", "gtk_entry_get_placeholder_text", [
             {
@@ -317,6 +543,11 @@ export class Entry extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns the current fraction of the task that’s been completed.
+     *
+     * See [method@Gtk.Entry.set_progress_fraction].
+     */
     getProgressFraction() {
         return call("libgtk-4.so.1", "gtk_entry_get_progress_fraction", [
             {
@@ -325,6 +556,10 @@ export class Entry extends Widget {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Retrieves the pulse step set with
+     * gtk_entry_set_progress_pulse_step().
+     */
     getProgressPulseStep() {
         return call("libgtk-4.so.1", "gtk_entry_get_progress_pulse_step", [
             {
@@ -333,6 +568,11 @@ export class Entry extends Widget {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Gets the tabstops of the `GtkEntry`.
+     *
+     * See [method@Gtk.Entry.set_tabs].
+     */
     getTabs() {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_tabs", [
             {
@@ -349,6 +589,12 @@ export class Entry extends Widget {
             return null;
         return getObject(ptr, Pango.TabArray);
     }
+    /**
+     * Retrieves the current length of the text in @entry.
+     *
+     * This is equivalent to getting @entry's `GtkEntryBuffer`
+     * and calling [method@Gtk.EntryBuffer.get_length] on it.
+     */
     getTextLength() {
         return call("libgtk-4.so.1", "gtk_entry_get_text_length", [
             {
@@ -357,6 +603,11 @@ export class Entry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Retrieves whether the text in `entry` is visible.
+     *
+     * See [method@Gtk.Entry.set_visibility].
+     */
     getVisibility() {
         return call("libgtk-4.so.1", "gtk_entry_get_visibility", [
             {
@@ -365,6 +616,14 @@ export class Entry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Causes `entry` to have keyboard focus.
+     *
+     * It behaves like [method@Gtk.Widget.grab_focus], except that it doesn't
+     * select the contents of the entry. 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_entry_grab_focus_without_selecting", [
             {
@@ -373,6 +632,16 @@ export class Entry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Indicates that some progress is made, but you don’t
+     * know how much.
+     *
+     * Causes the entry’s progress indicator to enter “activity
+     * mode”, where a block bounces back and forth. Each call to
+     * gtk_entry_progress_pulse() causes the block to move by a
+     * little bit (the amount of movement per pulse is determined
+     * by [method@Gtk.Entry.set_progress_pulse_step]).
+     */
     progressPulse() {
         call("libgtk-4.so.1", "gtk_entry_progress_pulse", [
             {
@@ -381,6 +650,12 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Reset the input method context of the entry if needed.
+     *
+     * This can be necessary in the case where modifying the buffer
+     * would confuse on-going input method behavior.
+     */
     resetImContext() {
         call("libgtk-4.so.1", "gtk_entry_reset_im_context", [
             {
@@ -389,6 +664,14 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether pressing Enter in the `entry` will activate the default
+     * widget for the window containing the entry.
+     *
+     * This usually means that the dialog containing the entry will be closed,
+     * since the default widget is usually one of the dialog buttons.
+     * @param setting - %TRUE to activate window’s default widget on Enter keypress
+     */
     setActivatesDefault(setting) {
         call("libgtk-4.so.1", "gtk_entry_set_activates_default", [
             {
@@ -401,6 +684,15 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the alignment for the contents of the entry.
+     *
+     * This controls the horizontal positioning of the contents when
+     * the displayed text is shorter than the width of the entry.
+     *
+     * See also: [property@Gtk.Editable:xalign]
+     * @param xalign - The horizontal alignment, from 0 (left) to 1 (right).
+     */
     setAlignment(xalign) {
         call("libgtk-4.so.1", "gtk_entry_set_alignment", [
             {
@@ -413,6 +705,16 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a `PangoAttrList`.
+     *
+     * The attributes in the list are applied to the entry text.
+     *
+     * Since the attributes will be applied to text that changes
+     * as the user types, it makes most sense to use attributes
+     * with unlimited extent.
+     * @param attrs - a `PangoAttrList`
+     */
     setAttributes(attrs) {
         call("libgtk-4.so.1", "gtk_entry_set_attributes", [
             {
@@ -430,6 +732,11 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the `GtkEntryBuffer` object which holds the text for
+     * this widget.
+     * @param buffer - a `GtkEntryBuffer`
+     */
     setBuffer(buffer) {
         call("libgtk-4.so.1", "gtk_entry_set_buffer", [
             {
@@ -442,6 +749,15 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `completion` to be the auxiliary completion object
+     * to use with @entry.
+     *
+     * All further configuration of the completion mechanism is
+     * done on `completion` using the `GtkEntryCompletion` API.
+     * Completion is disabled if `completion` is set to %NULL.
+     * @param completion - The `GtkEntryCompletion`
+     */
     setCompletion(completion) {
         call("libgtk-4.so.1", "gtk_entry_set_completion", [
             {
@@ -455,6 +771,11 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a menu model to add when constructing
+     * the context menu for @entry.
+     * @param model - a `GMenuModel`
+     */
     setExtraMenu(model) {
         call("libgtk-4.so.1", "gtk_entry_set_extra_menu", [
             {
@@ -468,6 +789,10 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the entry has a beveled frame around it.
+     * @param setting - new value
+     */
     setHasFrame(setting) {
         call("libgtk-4.so.1", "gtk_entry_set_has_frame", [
             {
@@ -480,6 +805,11 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the icon is activatable.
+     * @param iconPos - Icon position
+     * @param activatable - %TRUE if the icon should be activatable
+     */
     setIconActivatable(iconPos, activatable) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_activatable", [
             {
@@ -496,6 +826,15 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets up the icon at the given position as drag source.
+     *
+     * This makes it so that GTK will start a drag
+     * operation when the user clicks and drags the icon.
+     * @param iconPos - icon position
+     * @param provider - a `GdkContentProvider`
+     * @param actions - a bitmask of the allowed drag actions
+     */
     setIconDragSource(iconPos, provider, actions) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_drag_source", [
             {
@@ -516,6 +855,18 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the icon shown in the entry at the specified position
+     * from the current icon theme.
+     *
+     * If the icon isn’t known, a “broken image” icon will be
+     * displayed instead.
+     *
+     * If `icon` is %NULL, no icon will be shown in the
+     * specified position.
+     * @param iconPos - The position at which to set the icon
+     * @param icon - The icon to set
+     */
     setIconFromGicon(iconPos, icon) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_from_gicon", [
             {
@@ -533,6 +884,18 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the icon shown in the entry at the specified position
+     * from the current icon theme.
+     *
+     * If the icon name isn’t known, a “broken image” icon will be
+     * displayed instead.
+     *
+     * If `icon_name` is %NULL, no icon will be shown in the
+     * specified position.
+     * @param iconPos - The position at which to set the icon
+     * @param iconName - An icon name
+     */
     setIconFromIconName(iconPos, iconName) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_from_icon_name", [
             {
@@ -550,6 +913,13 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the icon shown in the specified position using a `GdkPaintable`.
+     *
+     * If `paintable` is %NULL, no icon will be shown in the specified position.
+     * @param iconPos - Icon position
+     * @param paintable - A `GdkPaintable`
+     */
     setIconFromPaintable(iconPos, paintable) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_from_paintable", [
             {
@@ -567,6 +937,11 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the sensitivity for the specified icon.
+     * @param iconPos - Icon position
+     * @param sensitive - Specifies whether the icon should appear
+     */
     setIconSensitive(iconPos, sensitive) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_sensitive", [
             {
@@ -583,6 +958,19 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `tooltip` as the contents of the tooltip for the icon at
+     * the specified position.
+     *
+     * `tooltip` is assumed to be marked up with Pango Markup.
+     *
+     * Use %NULL for `tooltip` to remove an existing tooltip.
+     *
+     * See also [method@Gtk.Widget.set_tooltip_markup] and
+     * [method@Gtk.Entry.set_icon_tooltip_text].
+     * @param iconPos - the icon position
+     * @param tooltip - the contents of the tooltip for the icon
+     */
     setIconTooltipMarkup(iconPos, tooltip) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_tooltip_markup", [
             {
@@ -600,6 +988,27 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `tooltip` as the contents of the tooltip for the icon
+     * at the specified position.
+     *
+     * Use %NULL for `tooltip` to remove an existing tooltip.
+     *
+     * See also [method@Gtk.Widget.set_tooltip_text] and
+     * [method@Gtk.Entry.set_icon_tooltip_markup].
+     *
+     * If you unset the widget tooltip via
+     * [method@Gtk.Widget.set_tooltip_text] or
+     * [method@Gtk.Widget.set_tooltip_markup], this sets
+     * [property@Gtk.Widget:has-tooltip] to %FALSE, which suppresses
+     * icon tooltips too. You can resolve this by then calling
+     * [method@Gtk.Widget.set_has_tooltip] to set
+     * [property@Gtk.Widget:has-tooltip] back to %TRUE, or
+     * setting at least one non-empty tooltip on any icon
+     * achieves the same result.
+     * @param iconPos - the icon position
+     * @param tooltip - the contents of the tooltip for the icon
+     */
     setIconTooltipText(iconPos, tooltip) {
         call("libgtk-4.so.1", "gtk_entry_set_icon_tooltip_text", [
             {
@@ -617,6 +1026,11 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set additional hints which allow input methods to
+     * fine-tune their behavior.
+     * @param hints - the hints
+     */
     setInputHints(hints) {
         call("libgtk-4.so.1", "gtk_entry_set_input_hints", [
             {
@@ -629,6 +1043,11 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the input purpose which can be used by input methods
+     * to adjust their behavior.
+     * @param purpose - the purpose
+     */
     setInputPurpose(purpose) {
         call("libgtk-4.so.1", "gtk_entry_set_input_purpose", [
             {
@@ -641,6 +1060,19 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the character to use in place of the actual text
+     * in “password mode”.
+     *
+     * See [method@Gtk.Entry.set_visibility] for how to enable
+     * “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_entry_set_invisible_char", [
             {
@@ -653,6 +1085,16 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the maximum allowed length of the contents of the widget.
+     *
+     * If the current contents are longer than the given length, then
+     * they will be truncated to fit. The length is in characters.
+     *
+     * This is equivalent to getting @entry's `GtkEntryBuffer` and
+     * calling [method@Gtk.EntryBuffer.set_max_length] on it.
+     * @param max - the maximum length of the entry, or 0 for no maximum.
+     */
     setMaxLength(max) {
         call("libgtk-4.so.1", "gtk_entry_set_max_length", [
             {
@@ -665,6 +1107,16 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text that will be used in the context menu of the `GtkEntry`
+     * when the specified icon is activatable. Selecting this item in the menu
+     * results, from all aspects, the same than clicking on the specified icon.
+     * This greatly simplifies making accessible applications, because the icons
+     * aren't focusable when using keyboard navigation. This is why Gtk recommends
+     * to add the same action to the context menu.
+     * @param iconPos - either `GTK_ENTRY_ICON_PRIMARY` or @GTK_ENTRY_ICON_SECONDARY
+     * @param text - the text used for the menu item in the context menu, or NULL to not add a menu item.
+     */
     setMenuEntryIconText(iconPos, text) {
         call("libgtk-4.so.1", "gtk_entry_set_menu_entry_icon_text", [
             {
@@ -681,6 +1133,10 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the text is overwritten when typing in the `GtkEntry`.
+     * @param overwrite - new value
+     */
     setOverwriteMode(overwrite) {
         call("libgtk-4.so.1", "gtk_entry_set_overwrite_mode", [
             {
@@ -693,6 +1149,13 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets text to be displayed in `entry` when it is empty.
+     *
+     * This can be used to give a visual hint of the expected
+     * contents of the `GtkEntry`.
+     * @param text - a string to be displayed when `entry` is empty and unfocused
+     */
     setPlaceholderText(text) {
         call("libgtk-4.so.1", "gtk_entry_set_placeholder_text", [
             {
@@ -706,6 +1169,13 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Causes the entry’s progress indicator to “fill in” the given
+     * fraction of the bar.
+     *
+     * The fraction should be between 0.0 and 1.0, inclusive.
+     * @param fraction - fraction of the task that’s been completed
+     */
     setProgressFraction(fraction) {
         call("libgtk-4.so.1", "gtk_entry_set_progress_fraction", [
             {
@@ -718,6 +1188,14 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the fraction of total entry width to move the progress
+     * bouncing block for each pulse.
+     *
+     * Use [method@Gtk.Entry.progress_pulse] to pulse
+     * the progress.
+     * @param fraction - fraction between 0.0 and 1.0
+     */
     setProgressPulseStep(fraction) {
         call("libgtk-4.so.1", "gtk_entry_set_progress_pulse_step", [
             {
@@ -730,6 +1208,12 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a `PangoTabArray`.
+     *
+     * The tabstops in the array are applied to the entry text.
+     * @param tabs - a `PangoTabArray`
+     */
     setTabs(tabs) {
         call("libgtk-4.so.1", "gtk_entry_set_tabs", [
             {
@@ -748,6 +1232,23 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the contents of the entry are visible or not.
+     *
+     * When visibility is set to %FALSE, characters are displayed
+     * as the invisible char, and will also appear that way when
+     * the text in the entry widget is copied elsewhere.
+     *
+     * By default, GTK picks the best invisible character available
+     * in the current font, but it can be changed with
+     * [method@Gtk.Entry.set_invisible_char].
+     *
+     * Note that you probably want to set [property@Gtk.Entry:input-purpose]
+     * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
+     * inform input methods about the purpose of this entry,
+     * in addition to setting visibility to %FALSE.
+     * @param visible - %TRUE if the contents of the entry are displayed as plaintext
+     */
     setVisibility(visible) {
         call("libgtk-4.so.1", "gtk_entry_set_visibility", [
             {
@@ -760,6 +1261,10 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unsets the invisible char, so that the default invisible char
+     * is used again. See [method@Gtk.Entry.set_invisible_char].
+     */
     unsetInvisibleChar() {
         call("libgtk-4.so.1", "gtk_entry_unset_invisible_char", [
             {
@@ -768,6 +1273,9 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the `GtkCellEditable::editing-done` signal.
+     */
     editingDone() {
         call("libgtk-4.so.1", "gtk_cell_editable_editing_done", [
             {
@@ -776,6 +1284,9 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the `GtkCellEditable::remove-widget` signal.
+     */
     removeWidget() {
         call("libgtk-4.so.1", "gtk_cell_editable_remove_widget", [
             {
@@ -784,6 +1295,19 @@ export class Entry 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", [
             {
@@ -797,6 +1321,41 @@ export class Entry 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", [
             {
@@ -809,6 +1368,11 @@ export class Entry 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", [
             {
@@ -817,6 +1381,18 @@ export class Entry 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", [
             {
@@ -833,6 +1409,12 @@ export class Entry 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", [
             {
@@ -841,6 +1423,18 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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", [
             {
@@ -857,6 +1451,12 @@ export class Entry 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", [
             {
@@ -868,6 +1468,9 @@ export class Entry extends Widget {
             return null;
         return getObject(ptr, Editable);
     }
+    /**
+     * Retrieves whether `editable` is editable.
+     */
     getEditable() {
         return call("libgtk-4.so.1", "gtk_editable_get_editable", [
             {
@@ -876,6 +1479,9 @@ export class Entry 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", [
             {
@@ -884,6 +1490,9 @@ export class Entry 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", [
             {
@@ -892,6 +1501,12 @@ export class Entry 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", [
             {
@@ -900,6 +1515,17 @@ export class Entry 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", [
             {
@@ -924,6 +1550,11 @@ export class Entry 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", [
             {
@@ -932,6 +1563,10 @@ export class Entry 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", [
             {
@@ -940,6 +1575,15 @@ export class Entry 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", [
             {
@@ -948,6 +1592,17 @@ export class Entry 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", [
             {
@@ -971,6 +1626,18 @@ export class Entry 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", [
             {
@@ -987,6 +1654,10 @@ export class Entry 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", [
             {
@@ -999,6 +1670,15 @@ export class Entry 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", [
             {
@@ -1011,6 +1691,10 @@ export class Entry 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", [
             {
@@ -1023,6 +1707,16 @@ export class Entry 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", [
             {
@@ -1035,6 +1729,12 @@ export class Entry 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", [
             {
@@ -1047,6 +1747,15 @@ export class Entry 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", [
             {