@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/text-view.js

@@ -5,6 +5,81 @@ import { TextBuffer } from "./text-buffer.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
+/**
+ * Displays the contents of a [class@Gtk.TextBuffer].
+ *
+ *
+ *
+ * You may wish to begin by reading the conceptual overview,
+ * which gives an overview of all the objects and data types related to the
+ * text widget and how they work together.
+ *
+ * ## Shortcuts and Gestures
+ *
+ * `GtkTextView` supports the following keyboard shortcuts:
+ *
+ * - `Shift`+`F10` or `Menu` opens the context menu.
+ * - `Ctrl`+`Z` undoes the last modification.
+ * - `Ctrl`+`Y` or `Ctrl`+`Shift`+`Z`
+ * redoes the last undone modification.
+ * - `Clear` clears the content.
+ *
+ * Additionally, the following signals have default keybindings:
+ *
+ * - [signal@Gtk.TextView::backspace]
+ * - [signal@Gtk.TextView::copy-clipboard]
+ * - [signal@Gtk.TextView::cut-clipboard]
+ * - [signal@Gtk.TextView::delete-from-cursor]
+ * - [signal@Gtk.TextView::insert-emoji]
+ * - [signal@Gtk.TextView::move-cursor]
+ * - [signal@Gtk.TextView::paste-clipboard]
+ * - [signal@Gtk.TextView::select-all]
+ * - [signal@Gtk.TextView::toggle-cursor-visible]
+ * - [signal@Gtk.TextView::toggle-overwrite]
+ *
+ * ## Actions
+ *
+ * `GtkTextView` 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.
+ * - `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` clears the content.
+ *
+ * ## CSS nodes
+ *
+ * ```
+ * textview.view
+ * ├── border.top
+ * ├── border.left
+ * ├── text
+ * │   ╰── [selection]
+ * ├── border.right
+ * ├── border.bottom
+ * ╰── [window.popup]
+ * ```
+ *
+ * `GtkTextView` has a main css node with name textview and style class .view,
+ * and subnodes for each of the border windows, and the main text area,
+ * with names border and text, respectively. The border nodes each get
+ * one of the style classes .left, .right, .top or .bottom.
+ *
+ * A node representing the selection will appear below the text node.
+ *
+ * If a context menu is opened, the window node will appear as a subnode
+ * of the main node.
+ *
+ * ## Accessibility
+ *
+ * `GtkTextView` uses the [enum@Gtk.AccessibleRole.text_box] role.
+ */
 const SIGNAL_META = {
     backspace: { params: [], returnType: { type: "undefined" } },
     "copy-clipboard": { params: [], returnType: { type: "undefined" } },
@@ -59,9 +134,26 @@ const SIGNAL_META = {
     "toggle-overwrite": { params: [], returnType: { type: "undefined" } },
 };
 export class TextView extends Widget {
+    /**
+     * Creates a new `GtkTextView`.
+     *
+     * If you don’t call [method@Gtk.TextView.set_buffer] before using the
+     * text view, an empty default buffer will be created for you. Get the
+     * buffer with [method@Gtk.TextView.get_buffer]. If you want to specify
+     * your own buffer, consider [ctor@Gtk.TextView.new_with_buffer].
+     */
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a new `GtkTextView` widget displaying the buffer @buffer.
+     *
+     * One buffer can be shared among many widgets. `buffer` may be %NULL
+     * to create a default buffer, in which case this function is equivalent
+     * to [ctor@Gtk.TextView.new]. The text view adds its own reference count
+     * to the buffer; it does not take over an existing reference.
+     * @param buffer - a `GtkTextBuffer`
+     */
     static viewNewWithBuffer(buffer) {
         const ptr = call("libgtk-4.so.1", "gtk_text_view_new_with_buffer", [
             {
@@ -77,6 +169,11 @@ export class TextView extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Adds a child widget in the text buffer, at the given @anchor.
+     * @param child - a `GtkWidget`
+     * @param anchor - a `GtkTextChildAnchor` in the `GtkTextBuffer` for @text_view
+     */
     addChildAtAnchor(child, anchor) {
         call("libgtk-4.so.1", "gtk_text_view_add_child_at_anchor", [
             {
@@ -93,6 +190,21 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds `child` at a fixed coordinate in the `GtkTextView`'s text window.
+     *
+     * The `xpos` and `ypos` must be in buffer coordinates (see
+     * [method@Gtk.TextView.get_iter_location] to convert to
+     * buffer coordinates).
+     *
+     * `child` will scroll with the text view.
+     *
+     * If instead you want a widget that will not move with the
+     * `GtkTextView` contents see `GtkOverlay`.
+     * @param child - a `GtkWidget`
+     * @param xpos - X position of child in window coordinates
+     * @param ypos - Y position of child in window coordinates
+     */
     addOverlay(child, xpos, ypos) {
         call("libgtk-4.so.1", "gtk_text_view_add_overlay", [
             {
@@ -113,6 +225,18 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves the given `iter` backward by one display (wrapped) line.
+     *
+     * A display line is different from a paragraph. Paragraphs are
+     * separated by newlines or other paragraph separator characters.
+     * Display lines are created by line-wrapping a paragraph. If
+     * wrapping is turned off, display lines and paragraphs will be the
+     * same. Display lines are divided differently for each view, since
+     * they depend on the view’s width; paragraphs are the same in all
+     * views, since they depend on the contents of the `GtkTextBuffer`.
+     * @param iter - a `GtkTextIter`
+     */
     backwardDisplayLine(iter) {
         return call("libgtk-4.so.1", "gtk_text_view_backward_display_line", [
             {
@@ -130,6 +254,18 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves the given `iter` backward to the next display line start.
+     *
+     * A display line is different from a paragraph. Paragraphs are
+     * separated by newlines or other paragraph separator characters.
+     * Display lines are created by line-wrapping a paragraph. If
+     * wrapping is turned off, display lines and paragraphs will be the
+     * same. Display lines are divided differently for each view, since
+     * they depend on the view’s width; paragraphs are the same in all
+     * views, since they depend on the contents of the `GtkTextBuffer`.
+     * @param iter - a `GtkTextIter`
+     */
     backwardDisplayLineStart(iter) {
         return call("libgtk-4.so.1", "gtk_text_view_backward_display_line_start", [
             {
@@ -147,6 +283,14 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Converts buffer coordinates to window coordinates.
+     * @param win - a `GtkTextWindowType`
+     * @param bufferX - buffer x coordinate
+     * @param bufferY - buffer y coordinate
+     * @param windowX - window x coordinate return location
+     * @param windowY - window y coordinate return location
+     */
     bufferToWindowCoords(win, bufferX, bufferY, windowX, windowY) {
         call("libgtk-4.so.1", "gtk_text_view_buffer_to_window_coords", [
             {
@@ -183,6 +327,18 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves the given `iter` forward by one display (wrapped) line.
+     *
+     * A display line is different from a paragraph. Paragraphs are
+     * separated by newlines or other paragraph separator characters.
+     * Display lines are created by line-wrapping a paragraph. If
+     * wrapping is turned off, display lines and paragraphs will be the
+     * same. Display lines are divided differently for each view, since
+     * they depend on the view’s width; paragraphs are the same in all
+     * views, since they depend on the contents of the `GtkTextBuffer`.
+     * @param iter - a `GtkTextIter`
+     */
     forwardDisplayLine(iter) {
         return call("libgtk-4.so.1", "gtk_text_view_forward_display_line", [
             {
@@ -200,6 +356,18 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves the given `iter` forward to the next display line end.
+     *
+     * A display line is different from a paragraph. Paragraphs are
+     * separated by newlines or other paragraph separator characters.
+     * Display lines are created by line-wrapping a paragraph. If
+     * wrapping is turned off, display lines and paragraphs will be the
+     * same. Display lines are divided differently for each view, since
+     * they depend on the view’s width; paragraphs are the same in all
+     * views, since they depend on the contents of the `GtkTextBuffer`.
+     * @param iter - a `GtkTextIter`
+     */
     forwardDisplayLineEnd(iter) {
         return call("libgtk-4.so.1", "gtk_text_view_forward_display_line_end", [
             {
@@ -217,6 +385,11 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether pressing the `Tab` key inserts a tab characters.
+     *
+     * See [method@Gtk.TextView.set_accepts_tab].
+     */
     getAcceptsTab() {
         return call("libgtk-4.so.1", "gtk_text_view_get_accepts_tab", [
             {
@@ -225,6 +398,9 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the bottom margin for text in the @text_view.
+     */
     getBottomMargin() {
         return call("libgtk-4.so.1", "gtk_text_view_get_bottom_margin", [
             {
@@ -233,6 +409,12 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the `GtkTextBuffer` being displayed by this text view.
+     *
+     * The reference count on the buffer is not incremented; the caller
+     * of this function won’t own a new reference.
+     */
     getBuffer() {
         const ptr = call("libgtk-4.so.1", "gtk_text_view_get_buffer", [
             {
@@ -242,6 +424,31 @@ export class TextView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, TextBuffer);
     }
+    /**
+     * Determine the positions of the strong and weak cursors if the
+     * insertion point is at @iter.
+     *
+     * 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 of the paragraph
+     * are inserted. The weak cursor location is the location where
+     * characters of the directionality opposite to the base direction
+     * of the paragraph are inserted.
+     *
+     * If `iter` is %NULL, the actual cursor position is used.
+     *
+     * Note that if `iter` happens to be the actual cursor position, and
+     * there is currently an IM preedit sequence being entered, the
+     * returned locations will be adjusted to account for the preedit
+     * cursor’s offset within the preedit sequence.
+     *
+     * The rectangle position is in buffer coordinates; use
+     * [method@Gtk.TextView.buffer_to_window_coords] to convert these
+     * coordinates to coordinates for one of the windows in the text view.
+     * @param iter - a `GtkTextIter`
+     * @param strong - location to store the strong cursor position
+     * @param weak - location to store the weak cursor position
+     */
     getCursorLocations(iter, strong, weak) {
         call("libgtk-4.so.1", "gtk_text_view_get_cursor_locations", [
             {
@@ -284,6 +491,9 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Find out whether the cursor should be displayed.
+     */
     getCursorVisible() {
         return call("libgtk-4.so.1", "gtk_text_view_get_cursor_visible", [
             {
@@ -292,6 +502,11 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the default editability of the `GtkTextView`.
+     *
+     * Tags in the buffer may override this setting for some ranges of text.
+     */
     getEditable() {
         return call("libgtk-4.so.1", "gtk_text_view_get_editable", [
             {
@@ -300,6 +515,10 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the menu model that gets added to the context menu
+     * or %NULL if none has been set.
+     */
     getExtraMenu() {
         const ptr = call("libgtk-4.so.1", "gtk_text_view_get_extra_menu", [
             {
@@ -309,6 +528,15 @@ export class TextView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gio.MenuModel);
     }
+    /**
+     * Gets a `GtkWidget` that has previously been set as gutter.
+     *
+     * See [method@Gtk.TextView.set_gutter].
+     *
+     * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
+     * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
+     * @param win - a `GtkTextWindowType`
+     */
     getGutter(win) {
         const ptr = call("libgtk-4.so.1", "gtk_text_view_get_gutter", [
             {
@@ -324,6 +552,12 @@ export class TextView extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets the default indentation of paragraphs in @text_view.
+     *
+     * Tags in the view’s buffer may override the default.
+     * The indentation may be negative.
+     */
     getIndent() {
         return call("libgtk-4.so.1", "gtk_text_view_get_indent", [
             {
@@ -332,6 +566,9 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the `input-hints` of the `GtkTextView`.
+     */
     getInputHints() {
         return call("libgtk-4.so.1", "gtk_text_view_get_input_hints", [
             {
@@ -340,6 +577,9 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the `input-purpose` of the `GtkTextView`.
+     */
     getInputPurpose() {
         return call("libgtk-4.so.1", "gtk_text_view_get_input_purpose", [
             {
@@ -348,6 +588,17 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the iterator at buffer coordinates `x` and @y.
+     *
+     * Buffer coordinates are coordinates for the entire buffer, not just
+     * the currently-displayed portion. If you have coordinates from an
+     * event, you have to convert those to buffer coordinates with
+     * [method@Gtk.TextView.window_to_buffer_coords].
+     * @param iter - a `GtkTextIter`
+     * @param x - x position, in buffer coordinates
+     * @param y - y position, in buffer coordinates
+     */
     getIterAtLocation(iter, x, y) {
         return call("libgtk-4.so.1", "gtk_text_view_get_iter_at_location", [
             {
@@ -375,6 +626,22 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the iterator pointing to the character at buffer
+     * coordinates `x` and @y.
+     *
+     * Buffer coordinates are coordinates for the entire buffer, not just
+     * the currently-displayed portion. If you have coordinates from an event,
+     * you have to convert those to buffer coordinates with
+     * [method@Gtk.TextView.window_to_buffer_coords].
+     *
+     * Note that this is different from [method@Gtk.TextView.get_iter_at_location],
+     * which returns cursor locations, i.e. positions between characters.
+     * @param iter - a `GtkTextIter`
+     * @param trailing - if non-%NULL, location to store
+     * @param x - x position, in buffer coordinates
+     * @param y - y position, in buffer coordinates
+     */
     getIterAtPosition(iter, x, y, trailing) {
         return call("libgtk-4.so.1", "gtk_text_view_get_iter_at_position", [
             {
@@ -410,6 +677,15 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets a rectangle which roughly contains the character at @iter.
+     *
+     * The rectangle position is in buffer coordinates; use
+     * [method@Gtk.TextView.buffer_to_window_coords] to convert these
+     * coordinates to coordinates for one of the windows in the text view.
+     * @param iter - a `GtkTextIter`
+     * @param location - bounds of the character at @iter
+     */
     getIterLocation(iter, location) {
         call("libgtk-4.so.1", "gtk_text_view_get_iter_location", [
             {
@@ -438,6 +714,11 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the default justification of paragraphs in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     */
     getJustification() {
         return call("libgtk-4.so.1", "gtk_text_view_get_justification", [
             {
@@ -446,6 +727,11 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the default left margin size of paragraphs in the @text_view.
+     *
+     * Tags in the buffer may override the default.
+     */
     getLeftMargin() {
         return call("libgtk-4.so.1", "gtk_text_view_get_left_margin", [
             {
@@ -454,6 +740,18 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the `GtkTextIter` at the start of the line containing
+     * the coordinate @y.
+     *
+     * `y` is in buffer coordinates, convert from window coordinates with
+     * [method@Gtk.TextView.window_to_buffer_coords]. If non-%NULL,
+     * `line_top` will be filled with the coordinate of the top edge
+     * of the line.
+     * @param targetIter - a `GtkTextIter`
+     * @param y - a y coordinate
+     * @param lineTop - return location for top coordinate of the line
+     */
     getLineAtY(targetIter, y, lineTop) {
         call("libgtk-4.so.1", "gtk_text_view_get_line_at_y", [
             {
@@ -484,6 +782,16 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the y coordinate of the top of the line containing @iter,
+     * and the height of the line.
+     *
+     * The coordinate is a buffer coordinate; convert to window
+     * coordinates with [method@Gtk.TextView.buffer_to_window_coords].
+     * @param iter - a `GtkTextIter`
+     * @param y - return location for a y coordinate
+     * @param height - return location for a height
+     */
     getLineYrange(iter, y, height) {
         call("libgtk-4.so.1", "gtk_text_view_get_line_yrange", [
             {
@@ -515,6 +823,12 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the `PangoContext` that is used for rendering LTR directed
+     * text layouts.
+     *
+     * The context may be replaced when CSS changes occur.
+     */
     getLtrContext() {
         const ptr = call("libgtk-4.so.1", "gtk_text_view_get_ltr_context", [
             {
@@ -524,6 +838,9 @@ export class TextView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pango.Context);
     }
+    /**
+     * Gets whether the `GtkTextView` uses monospace styling.
+     */
     getMonospace() {
         return call("libgtk-4.so.1", "gtk_text_view_get_monospace", [
             {
@@ -532,6 +849,9 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the `GtkTextView` is in overwrite mode or not.
+     */
     getOverwrite() {
         return call("libgtk-4.so.1", "gtk_text_view_get_overwrite", [
             {
@@ -540,6 +860,12 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the default number of pixels to put above paragraphs.
+     *
+     * Adding this function with [method@Gtk.TextView.get_pixels_below_lines]
+     * is equal to the line space between each paragraph.
+     */
     getPixelsAboveLines() {
         return call("libgtk-4.so.1", "gtk_text_view_get_pixels_above_lines", [
             {
@@ -548,6 +874,12 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the default number of pixels to put below paragraphs.
+     *
+     * The line space is the sum of the value returned by this function and
+     * the value returned by [method@Gtk.TextView.get_pixels_above_lines].
+     */
     getPixelsBelowLines() {
         return call("libgtk-4.so.1", "gtk_text_view_get_pixels_below_lines", [
             {
@@ -556,6 +888,10 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the default number of pixels to put between wrapped lines
+     * inside a paragraph.
+     */
     getPixelsInsideWrap() {
         return call("libgtk-4.so.1", "gtk_text_view_get_pixels_inside_wrap", [
             {
@@ -564,6 +900,11 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the default right margin for text in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     */
     getRightMargin() {
         return call("libgtk-4.so.1", "gtk_text_view_get_right_margin", [
             {
@@ -572,6 +913,12 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the `PangoContext` that is used for rendering RTL directed
+     * text layouts.
+     *
+     * The context may be replaced when CSS changes occur.
+     */
     getRtlContext() {
         const ptr = call("libgtk-4.so.1", "gtk_text_view_get_rtl_context", [
             {
@@ -581,6 +928,13 @@ export class TextView extends Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pango.Context);
     }
+    /**
+     * Gets the default tabs for @text_view.
+     *
+     * Tags in the buffer may override the defaults. The returned array
+     * will be %NULL if “standard” (8-space) tabs are used. Free the
+     * return value with [method@Pango.TabArray.free].
+     */
     getTabs() {
         const ptr = call("libgtk-4.so.1", "gtk_text_view_get_tabs", [
             {
@@ -597,6 +951,9 @@ export class TextView extends Widget {
             return null;
         return getObject(ptr, Pango.TabArray);
     }
+    /**
+     * Gets the top margin for text in the @text_view.
+     */
     getTopMargin() {
         return call("libgtk-4.so.1", "gtk_text_view_get_top_margin", [
             {
@@ -605,6 +962,19 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the X,Y offset in buffer coordinates of the top-left corner of
+     * the textview's text contents.
+     *
+     * This allows for more-precise positioning than what is provided by
+     * [method@Gtk.TextView.get_visible_rect] as you can discover what
+     * device pixel is being quantized for text positioning.
+     *
+     * You might want this when making ulterior widgets align with quantized
+     * device pixels of the textview contents such as line numbers.
+     * @param xOffset - a location for the X offset
+     * @param yOffset - a location for the Y offset
+     */
     getVisibleOffset(xOffset, yOffset) {
         call("libgtk-4.so.1", "gtk_text_view_get_visible_offset", [
             {
@@ -623,6 +993,14 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Fills `visible_rect` with the currently-visible
+     * region of the buffer, in buffer coordinates.
+     *
+     * Convert to window coordinates with
+     * [method@Gtk.TextView.buffer_to_window_coords].
+     * @param visibleRect - rectangle to fill
+     */
     getVisibleRect(visibleRect) {
         call("libgtk-4.so.1", "gtk_text_view_get_visible_rect", [
             {
@@ -642,6 +1020,9 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the line wrapping for the view.
+     */
     getWrapMode() {
         return call("libgtk-4.so.1", "gtk_text_view_get_wrap_mode", [
             {
@@ -650,6 +1031,40 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Allow the `GtkTextView` input method to internally handle key press
+     * and release events.
+     *
+     * If this function returns %TRUE, then no further processing should be
+     * done for this key event. See [method@Gtk.IMContext.filter_keypress].
+     *
+     * Note that you are expected to call this function from your handler
+     * when overriding key event handling. This is needed in the case when
+     * you need to insert your own key handling between the input method
+     * and the default key event handling of the `GtkTextView`.
+     *
+     * ```c
+     * static gboolean
+     * gtk_foo_bar_key_press_event (GtkWidget *widget,
+     * GdkEvent  *event)
+     * {
+     * guint keyval;
+     *
+     * gdk_event_get_keyval ((GdkEvent*)event, &keyval);
+     *
+     * if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
+     * {
+     * if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
+     * return TRUE;
+     * }
+     *
+     * // Do some stuff
+     *
+     * return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
+     * }
+     * ```
+     * @param event - the key event
+     */
     imContextFilterKeypress(event) {
         return call("libgtk-4.so.1", "gtk_text_view_im_context_filter_keypress", [
             {
@@ -662,6 +1077,11 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves a mark within the buffer so that it's
+     * located within the currently-visible text area.
+     * @param mark - a `GtkTextMark`
+     */
     moveMarkOnscreen(mark) {
         return call("libgtk-4.so.1", "gtk_text_view_move_mark_onscreen", [
             {
@@ -674,6 +1094,14 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Updates the position of a child.
+     *
+     * See [method@Gtk.TextView.add_overlay].
+     * @param child - a widget already added with [method@Gtk.TextView.add_overlay]
+     * @param xpos - new X position in buffer coordinates
+     * @param ypos - new Y position in buffer coordinates
+     */
     moveOverlay(child, xpos, ypos) {
         call("libgtk-4.so.1", "gtk_text_view_move_overlay", [
             {
@@ -694,6 +1122,22 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Move the iterator a given number of characters visually, treating
+     * it as the strong cursor position.
+     *
+     * If `count` is positive, then the new strong cursor position will
+     * be `count` positions to the right of the old cursor position.
+     * If `count` is negative then the new strong cursor position will
+     * be `count` positions to the left of the old cursor position.
+     *
+     * In the presence of bi-directional text, the correspondence
+     * between logical and visual order will depend on the direction
+     * of the current run, and there may be jumps when the cursor
+     * is moved off of the end of a run.
+     * @param iter - a `GtkTextIter`
+     * @param count - number of characters to move (negative moves left,
+     */
     moveVisually(iter, count) {
         return call("libgtk-4.so.1", "gtk_text_view_move_visually", [
             {
@@ -715,6 +1159,10 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves the cursor to the currently visible region of the
+     * buffer.
+     */
     placeCursorOnscreen() {
         return call("libgtk-4.so.1", "gtk_text_view_place_cursor_onscreen", [
             {
@@ -723,6 +1171,10 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Removes a child widget from @text_view.
+     * @param child - the child to remove
+     */
     remove(child) {
         call("libgtk-4.so.1", "gtk_text_view_remove", [
             {
@@ -735,6 +1187,16 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Ensures that the cursor is shown.
+     *
+     * This also resets the time that it will stay blinking (or
+     * visible, in case blinking is disabled).
+     *
+     * This function should be called in response to user input
+     * (e.g. from derived classes that override the textview's
+     * event handlers).
+     */
     resetCursorBlink() {
         call("libgtk-4.so.1", "gtk_text_view_reset_cursor_blink", [
             {
@@ -743,6 +1205,12 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Reset the input method context of the text view 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_text_view_reset_im_context", [
             {
@@ -751,6 +1219,11 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Scrolls `text_view` the minimum distance such that `mark` is contained
+     * within the visible area of the widget.
+     * @param mark - a mark in the buffer for @text_view
+     */
     scrollMarkOnscreen(mark) {
         call("libgtk-4.so.1", "gtk_text_view_scroll_mark_onscreen", [
             {
@@ -763,6 +1236,28 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Scrolls `text_view` so that `iter` is on the screen in the position
+     * indicated by `xalign` and @yalign.
+     *
+     * An alignment of 0.0 indicates left or top, 1.0 indicates right or
+     * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
+     * the minimal distance to get the mark onscreen, possibly not scrolling
+     * at all. The effective screen for purposes of this function is reduced
+     * by a margin of size @within_margin.
+     *
+     * Note that this function uses the currently-computed height of the
+     * lines in the text buffer. Line heights are computed in an idle
+     * handler; so this function may not have the desired effect if it’s
+     * called before the height computations. To avoid oddness, consider
+     * using [method@Gtk.TextView.scroll_to_mark] which saves a point to be
+     * scrolled to after line validation.
+     * @param iter - a `GtkTextIter`
+     * @param withinMargin - margin as a [0.0,0.5) fraction of screen size
+     * @param useAlign - whether to use alignment arguments (if %FALSE,
+     * @param xalign - horizontal alignment of mark within visible area
+     * @param yalign - vertical alignment of mark within visible area
+     */
     scrollToIter(iter, withinMargin, useAlign, xalign, yalign) {
         return call("libgtk-4.so.1", "gtk_text_view_scroll_to_iter", [
             {
@@ -796,6 +1291,21 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Scrolls `text_view` so that `mark` is on the screen in the position
+     * indicated by `xalign` and @yalign.
+     *
+     * An alignment of 0.0 indicates left or top, 1.0 indicates right or
+     * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
+     * the minimal distance to get the mark onscreen, possibly not scrolling
+     * at all. The effective screen for purposes of this function is reduced
+     * by a margin of size @within_margin.
+     * @param mark - a `GtkTextMark`
+     * @param withinMargin - margin as a [0.0,0.5) fraction of screen size
+     * @param useAlign - whether to use alignment arguments (if %FALSE, just
+     * @param xalign - horizontal alignment of mark within visible area
+     * @param yalign - vertical alignment of mark within visible area
+     */
     scrollToMark(mark, withinMargin, useAlign, xalign, yalign) {
         call("libgtk-4.so.1", "gtk_text_view_scroll_to_mark", [
             {
@@ -824,6 +1334,15 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the behavior of the text widget when the `Tab` key is pressed.
+     *
+     * If `accepts_tab` is %TRUE, a tab character is inserted. If `accepts_tab` is %FALSE the keyboard focus is moved to the next widget in the focus
+     * chain.
+     *
+     * Focus can always be moved using `Ctrl`+`Tab`.
+     * @param acceptsTab - %TRUE if pressing the Tab key should insert a tab
+     */
     setAcceptsTab(acceptsTab) {
         call("libgtk-4.so.1", "gtk_text_view_set_accepts_tab", [
             {
@@ -836,6 +1355,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the bottom margin for text in @text_view.
+     *
+     * Note that this function is confusingly named.
+     * In CSS terms, the value set here is padding.
+     * @param bottomMargin - bottom margin in pixels
+     */
     setBottomMargin(bottomMargin) {
         call("libgtk-4.so.1", "gtk_text_view_set_bottom_margin", [
             {
@@ -848,6 +1374,14 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `buffer` as the buffer being displayed by @text_view.
+     *
+     * The previous buffer displayed by the text view is unreferenced, and
+     * a reference is added to @buffer. If you owned a reference to `buffer` before passing it to this function, you must remove that reference
+     * yourself; `GtkTextView` will not “adopt” it.
+     * @param buffer - a `GtkTextBuffer`
+     */
     setBuffer(buffer) {
         call("libgtk-4.so.1", "gtk_text_view_set_buffer", [
             {
@@ -861,6 +1395,16 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Toggles whether the insertion point should be displayed.
+     *
+     * A buffer with no editable text probably shouldn’t have a visible
+     * cursor, so you may want to turn the cursor off.
+     *
+     * Note that this property may be overridden by the
+     * [property@Gtk.Settings:gtk-keynav-use-caret] setting.
+     * @param setting - whether to show the insertion cursor
+     */
     setCursorVisible(setting) {
         call("libgtk-4.so.1", "gtk_text_view_set_cursor_visible", [
             {
@@ -873,6 +1417,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default editability of the `GtkTextView`.
+     *
+     * You can override this default setting with tags in the buffer,
+     * using the “editable” attribute of tags.
+     * @param setting - whether it’s editable
+     */
     setEditable(setting) {
         call("libgtk-4.so.1", "gtk_text_view_set_editable", [
             {
@@ -885,6 +1436,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a menu model to add when constructing the context
+     * menu for @text_view.
+     *
+     * You can pass %NULL to remove a previously set extra menu.
+     * @param model - a `GMenuModel`
+     */
     setExtraMenu(model) {
         call("libgtk-4.so.1", "gtk_text_view_set_extra_menu", [
             {
@@ -898,6 +1456,14 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Places `widget` into the gutter specified by @win.
+     *
+     * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
+     * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
+     * @param win - a `GtkTextWindowType`
+     * @param widget - a `GtkWidget`
+     */
     setGutter(win, widget) {
         call("libgtk-4.so.1", "gtk_text_view_set_gutter", [
             {
@@ -915,6 +1481,12 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default indentation for paragraphs in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     * @param indent - indentation in pixels
+     */
     setIndent(indent) {
         call("libgtk-4.so.1", "gtk_text_view_set_indent", [
             {
@@ -927,6 +1499,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `input-hints` of the `GtkTextView`.
+     *
+     * The `input-hints` allow input methods to fine-tune
+     * their behaviour.
+     * @param hints - the hints
+     */
     setInputHints(hints) {
         call("libgtk-4.so.1", "gtk_text_view_set_input_hints", [
             {
@@ -939,6 +1518,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `input-purpose` of the `GtkTextView`.
+     *
+     * The `input-purpose` can be used by on-screen keyboards
+     * and other input methods to adjust their behaviour.
+     * @param purpose - the purpose
+     */
     setInputPurpose(purpose) {
         call("libgtk-4.so.1", "gtk_text_view_set_input_purpose", [
             {
@@ -951,6 +1537,12 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default justification of text in @text_view.
+     *
+     * Tags in the view’s buffer may override the default.
+     * @param justification - justification
+     */
     setJustification(justification) {
         call("libgtk-4.so.1", "gtk_text_view_set_justification", [
             {
@@ -963,6 +1555,15 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default left margin for text in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     *
+     * Note that this function is confusingly named.
+     * In CSS terms, the value set here is padding.
+     * @param leftMargin - left margin in pixels
+     */
     setLeftMargin(leftMargin) {
         call("libgtk-4.so.1", "gtk_text_view_set_left_margin", [
             {
@@ -975,6 +1576,11 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the `GtkTextView` should display text in
+     * monospace styling.
+     * @param monospace - %TRUE to request monospace styling
+     */
     setMonospace(monospace) {
         call("libgtk-4.so.1", "gtk_text_view_set_monospace", [
             {
@@ -987,6 +1593,10 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes the `GtkTextView` overwrite mode.
+     * @param overwrite - %TRUE to turn on overwrite mode, %FALSE to turn it off
+     */
     setOverwrite(overwrite) {
         call("libgtk-4.so.1", "gtk_text_view_set_overwrite", [
             {
@@ -999,6 +1609,12 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default number of blank pixels above paragraphs in @text_view.
+     *
+     * Tags in the buffer for `text_view` may override the defaults.
+     * @param pixelsAboveLines - pixels above paragraphs
+     */
     setPixelsAboveLines(pixelsAboveLines) {
         call("libgtk-4.so.1", "gtk_text_view_set_pixels_above_lines", [
             {
@@ -1011,6 +1627,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default number of pixels of blank space
+     * to put below paragraphs in @text_view.
+     *
+     * May be overridden by tags applied to @text_view’s buffer.
+     * @param pixelsBelowLines - pixels below paragraphs
+     */
     setPixelsBelowLines(pixelsBelowLines) {
         call("libgtk-4.so.1", "gtk_text_view_set_pixels_below_lines", [
             {
@@ -1023,6 +1646,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default number of pixels of blank space to leave between
+     * display/wrapped lines within a paragraph.
+     *
+     * May be overridden by tags in @text_view’s buffer.
+     * @param pixelsInsideWrap - default number of pixels between wrapped lines
+     */
     setPixelsInsideWrap(pixelsInsideWrap) {
         call("libgtk-4.so.1", "gtk_text_view_set_pixels_inside_wrap", [
             {
@@ -1035,6 +1665,15 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default right margin for text in the text view.
+     *
+     * Tags in the buffer may override the default.
+     *
+     * Note that this function is confusingly named.
+     * In CSS terms, the value set here is padding.
+     * @param rightMargin - right margin in pixels
+     */
     setRightMargin(rightMargin) {
         call("libgtk-4.so.1", "gtk_text_view_set_right_margin", [
             {
@@ -1047,6 +1686,12 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the default tab stops for paragraphs in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     * @param tabs - tabs as a `PangoTabArray`
+     */
     setTabs(tabs) {
         call("libgtk-4.so.1", "gtk_text_view_set_tabs", [
             {
@@ -1064,6 +1709,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the top margin for text in @text_view.
+     *
+     * Note that this function is confusingly named.
+     * In CSS terms, the value set here is padding.
+     * @param topMargin - top margin in pixels
+     */
     setTopMargin(topMargin) {
         call("libgtk-4.so.1", "gtk_text_view_set_top_margin", [
             {
@@ -1076,6 +1728,10 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the line wrapping for the view.
+     * @param wrapMode - a `GtkWrapMode`
+     */
     setWrapMode(wrapMode) {
         call("libgtk-4.so.1", "gtk_text_view_set_wrap_mode", [
             {
@@ -1088,6 +1744,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Determines whether `iter` is at the start of a display line.
+     *
+     * See [method@Gtk.TextView.forward_display_line] for an
+     * explanation of display lines vs. paragraphs.
+     * @param iter - a `GtkTextIter`
+     */
     startsDisplayLine(iter) {
         return call("libgtk-4.so.1", "gtk_text_view_starts_display_line", [
             {
@@ -1105,6 +1768,15 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Converts coordinates on the window identified by `win` to buffer
+     * coordinates.
+     * @param win - a `GtkTextWindowType`
+     * @param windowX - window x coordinate
+     * @param windowY - window y coordinate
+     * @param bufferX - buffer x coordinate return location
+     * @param bufferY - buffer y coordinate return location
+     */
     windowToBufferCoords(win, windowX, windowY, bufferX, bufferY) {
         call("libgtk-4.so.1", "gtk_text_view_window_to_buffer_coords", [
             {
@@ -1141,6 +1813,13 @@ export class TextView 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", [
             {
@@ -1149,6 +1828,20 @@ export class TextView 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", [
             {
@@ -1169,6 +1862,13 @@ export class TextView 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", [
             {
@@ -1177,6 +1877,15 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the size of a non-scrolling border around the
+     * outside of the scrollable.
+     *
+     * An example for this would be treeview headers. GTK can use
+     * this information to display overlaid graphics, like the
+     * overshoot indication, at the right position.
+     * @param border - return location for the results
+     */
     getBorder(border) {
         return call("libgtk-4.so.1", "gtk_scrollable_get_border", [
             {
@@ -1196,6 +1905,9 @@ export class TextView extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+     */
     getHadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrollable_get_hadjustment", [
             {
@@ -1207,6 +1919,9 @@ export class TextView extends Widget {
             return null;
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Gets the horizontal `GtkScrollablePolicy`.
+     */
     getHscrollPolicy() {
         return call("libgtk-4.so.1", "gtk_scrollable_get_hscroll_policy", [
             {
@@ -1215,6 +1930,9 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the `GtkAdjustment` used for vertical scrolling.
+     */
     getVadjustment() {
         const ptr = call("libgtk-4.so.1", "gtk_scrollable_get_vadjustment", [
             {
@@ -1226,6 +1944,9 @@ export class TextView extends Widget {
             return null;
         return getObject(ptr, Adjustment);
     }
+    /**
+     * Gets the vertical `GtkScrollablePolicy`.
+     */
     getVscrollPolicy() {
         return call("libgtk-4.so.1", "gtk_scrollable_get_vscroll_policy", [
             {
@@ -1234,6 +1955,10 @@ export class TextView extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the horizontal adjustment of the `GtkScrollable`.
+     * @param hadjustment - a `GtkAdjustment`
+     */
     setHadjustment(hadjustment) {
         call("libgtk-4.so.1", "gtk_scrollable_set_hadjustment", [
             {
@@ -1247,6 +1972,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether horizontal scrolling should start
+     * below the minimum width or below the natural width.
+     * @param policy - the horizontal `GtkScrollablePolicy`
+     */
     setHscrollPolicy(policy) {
         call("libgtk-4.so.1", "gtk_scrollable_set_hscroll_policy", [
             {
@@ -1259,6 +1991,10 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the vertical adjustment of the `GtkScrollable`.
+     * @param vadjustment - a `GtkAdjustment`
+     */
     setVadjustment(vadjustment) {
         call("libgtk-4.so.1", "gtk_scrollable_set_vadjustment", [
             {
@@ -1272,6 +2008,13 @@ export class TextView extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `GtkScrollablePolicy`.
+     *
+     * The policy determines whether vertical scrolling should start
+     * below the minimum height or below the natural height.
+     * @param policy - the vertical `GtkScrollablePolicy`
+     */
     setVscrollPolicy(policy) {
         call("libgtk-4.so.1", "gtk_scrollable_set_vscroll_policy", [
             {