@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/text-view.d.ts

@@ -12,92 +12,760 @@ import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
 export declare 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: unknown[]);
+    /**
+     * 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: TextBuffer): TextView;
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * 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: Widget, anchor: TextChildAnchor): void;
+    /**
+     * 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: Widget, xpos: number, ypos: number): void;
+    /**
+     * 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: TextIter): 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: TextIter): 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: TextWindowType, bufferX: number, bufferY: number, windowX?: Ref<number> | null, windowY?: Ref<number> | null): void;
+    /**
+     * 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: TextIter): 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: TextIter): boolean;
+    /**
+     * Returns whether pressing the `Tab` key inserts a tab characters.
+     *
+     * See [method@Gtk.TextView.set_accepts_tab].
+     */
     getAcceptsTab(): boolean;
+    /**
+     * Gets the bottom margin for text in the @text_view.
+     */
     getBottomMargin(): number;
+    /**
+     * 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(): 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?: TextIter | null, strong?: Ref<Gdk.Rectangle> | null, weak?: Ref<Gdk.Rectangle> | null): void;
+    /**
+     * Find out whether the cursor should be displayed.
+     */
     getCursorVisible(): boolean;
+    /**
+     * Returns the default editability of the `GtkTextView`.
+     *
+     * Tags in the buffer may override this setting for some ranges of text.
+     */
     getEditable(): boolean;
+    /**
+     * Gets the menu model that gets added to the context menu
+     * or %NULL if none has been set.
+     */
     getExtraMenu(): 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: TextWindowType): Widget | null;
+    /**
+     * 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(): number;
+    /**
+     * Gets the `input-hints` of the `GtkTextView`.
+     */
     getInputHints(): InputHints;
+    /**
+     * Gets the `input-purpose` of the `GtkTextView`.
+     */
     getInputPurpose(): InputPurpose;
+    /**
+     * 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: Ref<TextIter>, x: number, y: number): 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: Ref<TextIter>, x: number, y: number, trailing?: Ref<number> | null): 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: TextIter, location: Ref<Gdk.Rectangle>): void;
+    /**
+     * Gets the default justification of paragraphs in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     */
     getJustification(): Justification;
+    /**
+     * Gets the default left margin size of paragraphs in the @text_view.
+     *
+     * Tags in the buffer may override the default.
+     */
     getLeftMargin(): number;
+    /**
+     * 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: Ref<TextIter>, y: number, lineTop: Ref<number>): void;
+    /**
+     * 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: TextIter, y: Ref<number>, height: Ref<number>): void;
+    /**
+     * Gets the `PangoContext` that is used for rendering LTR directed
+     * text layouts.
+     *
+     * The context may be replaced when CSS changes occur.
+     */
     getLtrContext(): Pango.Context;
+    /**
+     * Gets whether the `GtkTextView` uses monospace styling.
+     */
     getMonospace(): boolean;
+    /**
+     * Returns whether the `GtkTextView` is in overwrite mode or not.
+     */
     getOverwrite(): 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(): number;
+    /**
+     * 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(): number;
+    /**
+     * Gets the default number of pixels to put between wrapped lines
+     * inside a paragraph.
+     */
     getPixelsInsideWrap(): number;
+    /**
+     * Gets the default right margin for text in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     */
     getRightMargin(): number;
+    /**
+     * Gets the `PangoContext` that is used for rendering RTL directed
+     * text layouts.
+     *
+     * The context may be replaced when CSS changes occur.
+     */
     getRtlContext(): 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(): Pango.TabArray | null;
+    /**
+     * Gets the top margin for text in the @text_view.
+     */
     getTopMargin(): number;
+    /**
+     * 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?: Ref<number> | null, yOffset?: Ref<number> | null): void;
+    /**
+     * 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: Ref<Gdk.Rectangle>): void;
+    /**
+     * Gets the line wrapping for the view.
+     */
     getWrapMode(): WrapMode;
+    /**
+     * 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: Gdk.Event): boolean;
+    /**
+     * Moves a mark within the buffer so that it's
+     * located within the currently-visible text area.
+     * @param mark - a `GtkTextMark`
+     */
     moveMarkOnscreen(mark: TextMark): 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: Widget, xpos: number, ypos: number): void;
+    /**
+     * 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: TextIter, count: number): boolean;
+    /**
+     * Moves the cursor to the currently visible region of the
+     * buffer.
+     */
     placeCursorOnscreen(): boolean;
+    /**
+     * Removes a child widget from @text_view.
+     * @param child - the child to remove
+     */
     remove(child: Widget): void;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: TextMark): void;
+    /**
+     * 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: TextIter, withinMargin: number, useAlign: boolean, xalign: number, yalign: number): 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: TextMark, withinMargin: number, useAlign: boolean, xalign: number, yalign: number): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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?: TextBuffer | null): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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: boolean): void;
+    /**
+     * 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?: Gio.MenuModel | null): void;
+    /**
+     * 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: TextWindowType, widget?: Widget | null): void;
+    /**
+     * Sets the default indentation for paragraphs in @text_view.
+     *
+     * Tags in the buffer may override the default.
+     * @param indent - indentation in pixels
+     */
     setIndent(indent: number): void;
+    /**
+     * Sets the `input-hints` of the `GtkTextView`.
+     *
+     * The `input-hints` allow input methods to fine-tune
+     * their behaviour.
+     * @param hints - the hints
+     */
     setInputHints(hints: InputHints): void;
+    /**
+     * 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: InputPurpose): void;
+    /**
+     * Sets the default justification of text in @text_view.
+     *
+     * Tags in the view’s buffer may override the default.
+     * @param justification - justification
+     */
     setJustification(justification: Justification): void;
+    /**
+     * 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: number): void;
+    /**
+     * Sets whether the `GtkTextView` should display text in
+     * monospace styling.
+     * @param monospace - %TRUE to request monospace styling
+     */
     setMonospace(monospace: boolean): void;
+    /**
+     * Changes the `GtkTextView` overwrite mode.
+     * @param overwrite - %TRUE to turn on overwrite mode, %FALSE to turn it off
+     */
     setOverwrite(overwrite: boolean): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: Pango.TabArray): void;
+    /**
+     * 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: number): void;
+    /**
+     * Sets the line wrapping for the view.
+     * @param wrapMode - a `GtkWrapMode`
+     */
     setWrapMode(wrapMode: WrapMode): void;
+    /**
+     * 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: TextIter): 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: TextWindowType, windowX: number, windowY: number, bufferX?: Ref<number> | null, bufferY?: Ref<number> | null): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: AccessibleTextContentChange, start: number, end: number): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: Ref<Border>): boolean;
+    /**
+     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+     */
     getHadjustment(): Adjustment | null;
+    /**
+     * Gets the horizontal `GtkScrollablePolicy`.
+     */
     getHscrollPolicy(): ScrollablePolicy;
+    /**
+     * Retrieves the `GtkAdjustment` used for vertical scrolling.
+     */
     getVadjustment(): Adjustment | null;
+    /**
+     * Gets the vertical `GtkScrollablePolicy`.
+     */
     getVscrollPolicy(): ScrollablePolicy;
+    /**
+     * Sets the horizontal adjustment of the `GtkScrollable`.
+     * @param hadjustment - a `GtkAdjustment`
+     */
     setHadjustment(hadjustment?: Adjustment | null): void;
+    /**
+     * 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: ScrollablePolicy): void;
+    /**
+     * Sets the vertical adjustment of the `GtkScrollable`.
+     * @param vadjustment - a `GtkAdjustment`
+     */
     setVadjustment(vadjustment?: Adjustment | null): void;
+    /**
+     * 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: ScrollablePolicy): void;
     connect(signal: "backspace", handler: (self: TextView) => void, after?: boolean): number;
     connect(signal: "copy-clipboard", handler: (self: TextView) => void, after?: boolean): number;