@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -9,93 +9,713 @@ import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
 export declare class Entry extends Widget {
+    /**
+     * Creates a new entry.
+     */
     constructor(...args: unknown[]);
+    /**
+     * Creates a new entry with the specified text buffer.
+     * @param buffer - The buffer to use for the new `GtkEntry`.
+     */
     static newWithBuffer(buffer: EntryBuffer): Entry;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Retrieves the value set by gtk_entry_set_activates_default().
+     */
     getActivatesDefault(): boolean;
+    /**
+     * Gets the value set by gtk_entry_set_alignment().
+     *
+     * See also: [property@Gtk.Editable:xalign]
+     */
     getAlignment(): number;
+    /**
+     * Gets the attribute list of the `GtkEntry`.
+     *
+     * See [method@Gtk.Entry.set_attributes].
+     */
     getAttributes(): Pango.AttrList | null;
+    /**
+     * Get the `GtkEntryBuffer` object which holds the text for
+     * this widget.
+     */
     getBuffer(): EntryBuffer;
+    /**
+     * Returns the auxiliary completion object currently
+     * in use by @entry.
+     */
     getCompletion(): EntryCompletion | null;
+    /**
+     * Returns the index of the icon which is the source of the
+     * current  DND operation, or -1.
+     */
     getCurrentIconDragSource(): number;
+    /**
+     * Gets the menu model set with gtk_entry_set_extra_menu().
+     */
     getExtraMenu(): Gio.MenuModel | null;
+    /**
+     * Gets the value set by gtk_entry_set_has_frame().
+     */
     getHasFrame(): boolean;
+    /**
+     * Returns whether the icon is activatable.
+     * @param iconPos - Icon position
+     */
     getIconActivatable(iconPos: EntryIconPosition): 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: EntryIconPosition, iconArea: Ref<Gdk.Rectangle>): void;
+    /**
+     * 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: number, y: number): number;
+    /**
+     * 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: EntryIconPosition): Gio.Icon | null;
+    /**
+     * 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: EntryIconPosition): string | null;
+    /**
+     * Retrieves the `GdkPaintable` used for the icon.
+     *
+     * If no `GdkPaintable` was used for the icon, %NULL is returned.
+     * @param iconPos - Icon position
+     */
     getIconPaintable(iconPos: EntryIconPosition): Gdk.Paintable | null;
+    /**
+     * Returns whether the icon appears sensitive or insensitive.
+     * @param iconPos - Icon position
+     */
     getIconSensitive(iconPos: EntryIconPosition): 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: EntryIconPosition): ImageType;
+    /**
+     * Gets the contents of the tooltip on the icon at the specified
+     * position in @entry.
+     * @param iconPos - the icon position
+     */
     getIconTooltipMarkup(iconPos: EntryIconPosition): string | null;
+    /**
+     * Gets the contents of the tooltip on the icon at the specified
+     * position in @entry.
+     * @param iconPos - the icon position
+     */
     getIconTooltipText(iconPos: EntryIconPosition): string | null;
+    /**
+     * Gets the input hints of this `GtkEntry`.
+     */
     getInputHints(): InputHints;
+    /**
+     * Gets the input purpose of the `GtkEntry`.
+     */
     getInputPurpose(): InputPurpose;
+    /**
+     * Retrieves the character displayed in place of the actual text
+     * in “password mode”.
+     */
     getInvisibleChar(): number;
+    /**
+     * Retrieves the maximum allowed length of the text in @entry.
+     *
+     * See [method@Gtk.Entry.set_max_length].
+     */
     getMaxLength(): number;
+    /**
+     * 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: EntryIconPosition): string | null;
+    /**
+     * Gets whether the `GtkEntry` is in overwrite mode.
+     */
     getOverwriteMode(): boolean;
+    /**
+     * Retrieves the text that will be displayed when `entry` is empty and unfocused
+     */
     getPlaceholderText(): string | null;
+    /**
+     * Returns the current fraction of the task that’s been completed.
+     *
+     * See [method@Gtk.Entry.set_progress_fraction].
+     */
     getProgressFraction(): number;
+    /**
+     * Retrieves the pulse step set with
+     * gtk_entry_set_progress_pulse_step().
+     */
     getProgressPulseStep(): number;
+    /**
+     * Gets the tabstops of the `GtkEntry`.
+     *
+     * See [method@Gtk.Entry.set_tabs].
+     */
     getTabs(): Pango.TabArray | null;
+    /**
+     * 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(): number;
+    /**
+     * Retrieves whether the text in `entry` is visible.
+     *
+     * See [method@Gtk.Entry.set_visibility].
+     */
     getVisibility(): 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(): 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: Pango.AttrList): void;
+    /**
+     * Set the `GtkEntryBuffer` object which holds the text for
+     * this widget.
+     * @param buffer - a `GtkEntryBuffer`
+     */
     setBuffer(buffer: EntryBuffer): void;
+    /**
+     * 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?: EntryCompletion | null): void;
+    /**
+     * Sets a menu model to add when constructing
+     * the context menu for @entry.
+     * @param model - a `GMenuModel`
+     */
     setExtraMenu(model?: Gio.MenuModel | null): void;
+    /**
+     * Sets whether the entry has a beveled frame around it.
+     * @param setting - new value
+     */
     setHasFrame(setting: boolean): void;
+    /**
+     * Sets whether the icon is activatable.
+     * @param iconPos - Icon position
+     * @param activatable - %TRUE if the icon should be activatable
+     */
     setIconActivatable(iconPos: EntryIconPosition, activatable: boolean): void;
+    /**
+     * 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: EntryIconPosition, provider: Gdk.ContentProvider, actions: Gdk.DragAction): void;
+    /**
+     * 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: EntryIconPosition, icon?: Gio.Icon | null): void;
+    /**
+     * 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: EntryIconPosition, iconName?: string | null): void;
+    /**
+     * 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: EntryIconPosition, paintable?: Gdk.Paintable | null): void;
+    /**
+     * Sets the sensitivity for the specified icon.
+     * @param iconPos - Icon position
+     * @param sensitive - Specifies whether the icon should appear
+     */
     setIconSensitive(iconPos: EntryIconPosition, sensitive: boolean): void;
+    /**
+     * 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: EntryIconPosition, tooltip?: string | null): void;
+    /**
+     * 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: EntryIconPosition, tooltip?: string | null): void;
+    /**
+     * Set additional hints which allow input methods to
+     * fine-tune their behavior.
+     * @param hints - the hints
+     */
     setInputHints(hints: InputHints): void;
+    /**
+     * Sets the input purpose which can be used by input methods
+     * to adjust their behavior.
+     * @param purpose - the purpose
+     */
     setInputPurpose(purpose: InputPurpose): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: EntryIconPosition, text: string): void;
+    /**
+     * Sets whether the text is overwritten when typing in the `GtkEntry`.
+     * @param overwrite - new value
+     */
     setOverwriteMode(overwrite: boolean): void;
+    /**
+     * 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?: string | null): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * Sets a `PangoTabArray`.
+     *
+     * The tabstops in the array are applied to the entry text.
+     * @param tabs - a `PangoTabArray`
+     */
     setTabs(tabs?: Pango.TabArray | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * Unsets the invisible char, so that the default invisible char
+     * is used again. See [method@Gtk.Entry.set_invisible_char].
+     */
     unsetInvisibleChar(): void;
+    /**
+     * Emits the `GtkCellEditable::editing-done` signal.
+     */
     editingDone(): void;
+    /**
+     * Emits the `GtkCellEditable::remove-widget` signal.
+     */
     removeWidget(): void;
+    /**
+     * 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?: Gdk.Event | null): void;
+    /**
+     * 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: AccessiblePlatformState): boolean;
+    /**
+     * Deletes the currently selected text of the editable.
+     *
+     * This call doesn’t do anything if there is no selected text.
+     */
     deleteSelection(): void;
+    /**
+     * 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: number, endPos: number): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: number, endPos: number): string;
+    /**
+     * Gets the `GtkEditable` that `editable` is delegating its
+     * implementation to.
+     *
+     * Typically, the delegate is a [class@Gtk.Text] widget.
+     */
     getDelegate(): Editable | null;
+    /**
+     * Retrieves whether `editable` is editable.
+     */
     getEditable(): boolean;
+    /**
+     * Gets if undo/redo actions are enabled for @editable
+     */
     getEnableUndo(): boolean;
+    /**
+     * Retrieves the desired maximum width of @editable, in characters.
+     */
     getMaxWidthChars(): number;
+    /**
+     * 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(): number;
+    /**
+     * 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?: Ref<number> | null, endPos?: Ref<number> | null): boolean;
+    /**
+     * Retrieves the contents of @editable.
+     *
+     * The returned string is owned by GTK and must not be modified or freed.
+     */
     getText(): string;
+    /**
+     * Gets the number of characters of space reserved
+     * for the contents of the editable.
+     */
     getWidthChars(): number;
+    /**
+     * 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(): void;
+    /**
+     * 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: string, length: number, position: Ref<number>): void;
+    /**
+     * 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: number, endPos: number): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * Sets the desired maximum width in characters of @editable.
+     * @param nChars - the new desired maximum width, in characters
+     */
     setMaxWidthChars(nChars: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * Sets the text in the editable to the given value.
+     *
+     * This is replacing the current contents.
+     * @param text - the text to set
+     */
     setText(text: string): void;
+    /**
+     * 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: number): void;
     connect(signal: "activate", handler: (self: Entry) => void, after?: boolean): number;
     connect(signal: "icon-press", handler: (self: Entry, iconPos: EntryIconPosition) => void, after?: boolean): number;