@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -6,6 +6,14 @@ import { TextMark } from "./text-mark.js";
 import { TextTag } from "./text-tag.js";
 import * as Gdk from "../gdk/index.js";
 import * as Pango from "../pango/index.js";
+/**
+ * Iterates over the contents of a `GtkTextBuffer`.
+ *
+ * You may wish to begin by reading the
+ * text widget conceptual overview,
+ * which gives an overview of all the objects and data types
+ * related to the text widget and how they work together.
+ */
 export class TextIter {
     ptr;
     constructor() {
@@ -14,6 +22,15 @@ export class TextIter {
     createPtr(_init) {
         return alloc(0, "GtkTextIter", "libgtk-4.so.1");
     }
+    /**
+     * Assigns the value of `other` to @iter.
+     *
+     * This function is not useful in applications, because
+     * iterators can be assigned with `GtkTextIter i = j;`.
+     *
+     * The function is used by language bindings.
+     * @param other - another `GtkTextIter`
+     */
     assign(other) {
         call("libgtk-4.so.1", "gtk_text_iter_assign", [
             {
@@ -31,6 +48,13 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves backward by one character offset.
+     *
+     * Returns %TRUE if movement was possible; if `iter` was the first
+     * in the buffer (character offset 0), this function returns %FALSE
+     * for convenience when writing loops.
+     */
     backwardChar() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_char", [
             {
@@ -39,6 +63,18 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `count` characters backward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves
+     * to the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE.
+     * @param count - number of characters to move
+     */
     backwardChars(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_chars", [
             {
@@ -51,6 +87,9 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Like [method@Gtk.TextIter.forward_cursor_position], but moves backward.
+     */
     backwardCursorPosition() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_cursor_position", [
             {
@@ -59,6 +98,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves up to `count` cursor positions.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     backwardCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_cursor_positions", [
             {
@@ -71,6 +116,13 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Same as [method@Gtk.TextIter.forward_find_char],
+     * but goes backward from @iter.
+     * @param pred - function to be called on each character
+     * @param userData - user data for @pred
+     * @param limit - search limit
+     */
     backwardFindChar(pred, userData, limit) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_find_char", [
             {
@@ -98,6 +150,17 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` to the start of the previous line.
+     *
+     * Returns %TRUE if `iter` could be moved; i.e. if `iter` was at
+     * character offset 0, this function returns %FALSE. Therefore,
+     * if `iter` was already on line 0, but not at the start of the line,
+     * `iter` is snapped to the start of the line and the function returns
+     * %TRUE. (Note that this implies that
+     * in a loop calling this function, the line number may not change on
+     * every iteration, if your first iteration is on line 0.)
+     */
     backwardLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_line", [
             {
@@ -106,6 +169,19 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `count` lines backward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves forward by 0 - `count` lines.
+     * @param count - number of lines to move backward
+     */
     backwardLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_lines", [
             {
@@ -118,6 +194,17 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Same as [method@Gtk.TextIter.forward_search], but moves backward.
+     *
+     * `match_end` will never be set to a `GtkTextIter` located after @iter,
+     * even if there is a possible `match_start` before or at @iter.
+     * @param str - search string
+     * @param flags - bitmask of flags affecting the search
+     * @param matchStart - return location for start of match
+     * @param matchEnd - return location for end of match
+     * @param limit - location of last possible @match_start, or %NULL for start of buffer
+     */
     backwardSearch(str, flags, matchStart, matchEnd, limit) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_search", [
             {
@@ -168,6 +255,15 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves backward to the previous sentence start.
+     *
+     * If `iter` is already at the start of a sentence, moves backward
+     * to the next one.
+     *
+     * Sentence boundaries are determined by Pango and should
+     * be correct for nearly any language.
+     */
     backwardSentenceStart() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_sentence_start", [
             {
@@ -176,6 +272,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls [method@Gtk.TextIter.backward_sentence_start] up to `count` times.
+     *
+     * If `count` is negative, moves forward instead of backward.
+     * @param count - number of sentences to move
+     */
     backwardSentenceStarts(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_sentence_starts", [
             {
@@ -188,6 +290,17 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves backward to the next toggle (on or off) of the
+     * @tag, or to the next toggle of any tag if
+     * `tag` is %NULL.
+     *
+     * If no matching tag toggles are found,
+     * returns %FALSE, otherwise %TRUE. Does not return toggles
+     * located at @iter, only toggles before @iter. Sets `iter` to the location of the toggle, or the start of the buffer
+     * if no toggle is found.
+     * @param tag - a `GtkTextTag`
+     */
     backwardToTagToggle(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_to_tag_toggle", [
             {
@@ -201,6 +314,11 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` backward to the previous visible cursor position.
+     *
+     * See [method@Gtk.TextIter.backward_cursor_position] for details.
+     */
     backwardVisibleCursorPosition() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_cursor_position", [
             {
@@ -209,6 +327,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves up to `count` visible cursor positions.
+     *
+     * See [method@Gtk.TextIter.backward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     backwardVisibleCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_cursor_positions", [
             {
@@ -221,6 +345,17 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` to the start of the previous visible line.
+     *
+     * Returns %TRUE if
+     * `iter` could be moved; i.e. if `iter` was at character offset 0, this
+     * function returns %FALSE. Therefore if `iter` was already on line 0,
+     * but not at the start of the line, `iter` is snapped to the start of
+     * the line and the function returns %TRUE. (Note that this implies that
+     * in a loop calling this function, the line number may not change on
+     * every iteration, if your first iteration is on line 0.)
+     */
     backwardVisibleLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_line", [
             {
@@ -229,6 +364,19 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `count` visible lines backward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves forward by 0 - `count` lines.
+     * @param count - number of lines to move backward
+     */
     backwardVisibleLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_lines", [
             {
@@ -241,6 +389,15 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves backward to the previous visible word start.
+     *
+     * If `iter` is currently on a word start, moves backward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     backwardVisibleWordStart() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_word_start", [
             {
@@ -249,6 +406,10 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls [method@Gtk.TextIter.backward_visible_word_start] up to `count` times.
+     * @param count - number of times to move
+     */
     backwardVisibleWordStarts(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_visible_word_starts", [
             {
@@ -261,6 +422,15 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves backward to the previous word start.
+     *
+     * If `iter` is currently on a word start, moves backward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language
+     */
     backwardWordStart() {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_word_start", [
             {
@@ -269,6 +439,10 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls [method@Gtk.TextIter.backward_word_start] up to `count` times.
+     * @param count - number of times to move
+     */
     backwardWordStarts(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_backward_word_starts", [
             {
@@ -281,6 +455,17 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Considering the default editability of the buffer, and tags that
+     * affect editability, determines whether text inserted at `iter` would
+     * be editable.
+     *
+     * If text inserted at `iter` would be editable then the
+     * user should be allowed to insert text at @iter.
+     * [method@Gtk.TextBuffer.insert_interactive] uses this function
+     * to decide whether insertions are allowed at a given position.
+     * @param defaultEditability - %TRUE if text is editable by default
+     */
     canInsert(defaultEditability) {
         return call("libgtk-4.so.1", "gtk_text_iter_can_insert", [
             {
@@ -293,6 +478,14 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * A qsort()-style function that returns negative if `lhs` is less than
+     * @rhs, positive if `lhs` is greater than @rhs, and 0 if they’re equal.
+     *
+     * Ordering is in character offset order, i.e. the first character
+     * in the buffer is less than the second character in the buffer.
+     * @param rhs - another `GtkTextIter`
+     */
     compare(rhs) {
         return call("libgtk-4.so.1", "gtk_text_iter_compare", [
             {
@@ -310,6 +503,15 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Creates a dynamically-allocated copy of an iterator.
+     *
+     * This function is not useful in applications, because
+     * iterators can be copied with a simple assignment
+     * (`GtkTextIter i = j;`).
+     *
+     * The function is used by language bindings.
+     */
     copy() {
         const ptr = call("libgtk-4.so.1", "gtk_text_iter_copy", [
             {
@@ -324,6 +526,22 @@ export class TextIter {
         });
         return getObject(ptr, TextIter);
     }
+    /**
+     * Returns whether the character at `iter` is within an editable region
+     * of text.
+     *
+     * Non-editable text is “locked” and can’t be changed by the
+     * user via `GtkTextView`. If no tags applied to this text affect
+     * editability, `default_setting` will be returned.
+     *
+     * You don’t want to use this function to decide whether text can be
+     * inserted at @iter, because for insertion you don’t want to know
+     * whether the char at `iter` is inside an editable range, you want to
+     * know whether a new character inserted at `iter` would be inside an
+     * editable range. Use [method@Gtk.TextIter.can_insert] to handle this
+     * case.
+     * @param defaultSetting - %TRUE if text is editable by default
+     */
     editable(defaultSetting) {
         return call("libgtk-4.so.1", "gtk_text_iter_editable", [
             {
@@ -336,6 +554,19 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if `iter` points to the start of the paragraph
+     * delimiter characters for a line.
+     *
+     * Delimiters will be either a newline, a carriage return, a carriage
+     * return followed by a newline, or a Unicode paragraph separator
+     * character.
+     *
+     * Note that an iterator pointing to the \n of a \r\n pair will not be
+     * counted as the end of a line, the line ends before the \r. The end
+     * iterator is considered to be at the end of a line, even though there
+     * are no paragraph delimiter chars there.
+     */
     endsLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_ends_line", [
             {
@@ -344,6 +575,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether `iter` ends a sentence.
+     *
+     * Sentence boundaries are determined by Pango and should
+     * be correct for nearly any language.
+     */
     endsSentence() {
         return call("libgtk-4.so.1", "gtk_text_iter_ends_sentence", [
             {
@@ -352,6 +589,19 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if `tag` is toggled off at exactly this point.
+     *
+     * If `tag` is %NULL, returns %TRUE if any tag is toggled off at this point.
+     *
+     * Note that if this function returns %TRUE, it means that
+     * `iter` is at the end of the tagged range, but that the character
+     * at `iter` is outside the tagged range. In other words,
+     * unlike [method@Gtk.TextIter.starts_tag], if this function
+     * returns %TRUE, [method@Gtk.TextIter.has_tag] will return
+     * %FALSE for the same parameters.
+     * @param tag - a `GtkTextTag`
+     */
     endsTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_ends_tag", [
             {
@@ -365,6 +615,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether `iter` ends a natural-language word.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     endsWord() {
         return call("libgtk-4.so.1", "gtk_text_iter_ends_word", [
             {
@@ -373,6 +629,16 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Tests whether two iterators are equal, using the fastest possible
+     * mechanism.
+     *
+     * This function is very fast; you can expect it to perform
+     * better than e.g. getting the character offset for each
+     * iterator and comparing the offsets yourself. Also, it’s a
+     * bit faster than [method@Gtk.TextIter.compare].
+     * @param rhs - another `GtkTextIter`
+     */
     equal(rhs) {
         return call("libgtk-4.so.1", "gtk_text_iter_equal", [
             {
@@ -390,6 +656,15 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` forward by one character offset.
+     *
+     * Note that images embedded in the buffer occupy 1 character slot, so
+     * this function may actually move onto an image instead of a character,
+     * if you have images in your buffer. If `iter` is the end iterator or
+     * one character before it, `iter` will now point at the end iterator,
+     * and this function returns %FALSE for convenience when writing loops.
+     */
     forwardChar() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_char", [
             {
@@ -398,6 +673,17 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `count` characters if possible.
+     *
+     * If `count` would move past the start or end of the buffer,
+     * moves to the start or end of the buffer.
+     *
+     * The return value indicates whether the new position of
+     * `iter` is different from its original position, and dereferenceable
+     * (the last iterator in the buffer is not dereferenceable). If `count` is 0, the function does nothing and returns %FALSE.
+     * @param count - number of characters to move, may be negative
+     */
     forwardChars(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_chars", [
             {
@@ -410,6 +696,23 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` forward by a single cursor position.
+     *
+     * Cursor positions are (unsurprisingly) positions where the
+     * cursor can appear. Perhaps surprisingly, there may not be
+     * a cursor position between all characters. The most common
+     * example for European languages would be a carriage return/newline
+     * sequence.
+     *
+     * For some Unicode characters, the equivalent of say the letter “a”
+     * with an accent mark will be represented as two characters, first
+     * the letter then a "combining mark" that causes the accent to be
+     * rendered; so the cursor can’t go between those two characters.
+     *
+     * See also the [struct@Pango.LogAttr] struct and the [func@Pango.break]
+     * function.
+     */
     forwardCursorPosition() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_cursor_position", [
             {
@@ -418,6 +721,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves up to `count` cursor positions.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     forwardCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_cursor_positions", [
             {
@@ -430,6 +739,16 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Advances @iter, calling `pred` on each character.
+     *
+     * If `pred` returns %TRUE, returns %TRUE and stops scanning.
+     * If `pred` never returns %TRUE, `iter` is set to `limit` if
+     * `limit` is non-%NULL, otherwise to the end iterator.
+     * @param pred - a function to be called on each character
+     * @param userData - user data for @pred
+     * @param limit - search limit
+     */
     forwardFindChar(pred, userData, limit) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_find_char", [
             {
@@ -457,6 +776,14 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` to the start of the next line.
+     *
+     * If the iter is already on the last line of the buffer,
+     * moves the iter to the end of the current line. If after
+     * the operation, the iter is at the end of the buffer and not
+     * dereferenceable, returns %FALSE. Otherwise, returns %TRUE.
+     */
     forwardLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_line", [
             {
@@ -465,6 +792,19 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `count` lines forward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves backward by 0 - `count` lines.
+     * @param count - number of lines to move forward
+     */
     forwardLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_lines", [
             {
@@ -477,6 +817,23 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Searches forward for @str.
+     *
+     * Any match is returned by setting `match_start` to the first character
+     * of the match and `match_end` to the first character after the match.
+     * The search will not continue past @limit. Note that a search is a
+     * linear or O(n) operation, so you may wish to use `limit` to avoid
+     * locking up your UI on large buffers.
+     *
+     * `match_start` will never be set to a `GtkTextIter` located before @iter,
+     * even if there is a possible `match_end` after or at @iter.
+     * @param str - a search string
+     * @param flags - flags affecting how the search is done
+     * @param matchStart - return location for start of match
+     * @param matchEnd - return location for end of match
+     * @param limit - location of last possible @match_end, or %NULL for the end of the buffer
+     */
     forwardSearch(str, flags, matchStart, matchEnd, limit) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_search", [
             {
@@ -527,6 +884,15 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves forward to the next sentence end.
+     *
+     * If `iter` is at the end of a sentence, moves to the next
+     * end of sentence.
+     *
+     * Sentence boundaries are determined by Pango and should
+     * be correct for nearly any language.
+     */
     forwardSentenceEnd() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_sentence_end", [
             {
@@ -535,6 +901,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls [method@Gtk.TextIter.forward_sentence_end] `count` times.
+     *
+     * If `count` is negative, moves backward instead of forward.
+     * @param count - number of sentences to move
+     */
     forwardSentenceEnds(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_sentence_ends", [
             {
@@ -547,6 +919,13 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` forward to the “end iterator”, which points
+     * one past the last valid character in the buffer.
+     *
+     * [method@Gtk.TextIter.get_char] called on the end iterator
+     * returns 0, which is convenient for writing loops.
+     */
     forwardToEnd() {
         call("libgtk-4.so.1", "gtk_text_iter_forward_to_end", [
             {
@@ -555,6 +934,19 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves the iterator to point to the paragraph delimiter characters.
+     *
+     * The possible characters are either a newline, a carriage return,
+     * a carriage return/newline in sequence, or the Unicode paragraph
+     * separator character.
+     *
+     * If the iterator is already at the paragraph delimiter
+     * characters, moves to the paragraph delimiter characters for the
+     * next line. If `iter` is on the last line in the buffer, which does
+     * not end in paragraph delimiters, moves to the end iterator (end of
+     * the last line), and returns %FALSE.
+     */
     forwardToLineEnd() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_to_line_end", [
             {
@@ -563,6 +955,18 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves forward to the next toggle (on or off) of the
+     * @tag, or to the next toggle of any tag if
+     * `tag` is %NULL.
+     *
+     * If no matching tag toggles are found,
+     * returns %FALSE, otherwise %TRUE. Does not return toggles
+     * located at @iter, only toggles after @iter. Sets `iter` to
+     * the location of the toggle, or to the end of the buffer
+     * if no toggle is found.
+     * @param tag - a `GtkTextTag`
+     */
     forwardToTagToggle(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_to_tag_toggle", [
             {
@@ -576,6 +980,11 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` forward to the next visible cursor position.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     */
     forwardVisibleCursorPosition() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_cursor_position", [
             {
@@ -584,6 +993,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves up to `count` visible cursor positions.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     forwardVisibleCursorPositions(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_cursor_positions", [
             {
@@ -596,6 +1011,14 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` to the start of the next visible line.
+     *
+     * Returns %TRUE if there
+     * was a next line to move to, and %FALSE if `iter` was simply moved to
+     * the end of the buffer and is now not dereferenceable, or if `iter` was
+     * already at the end of the buffer.
+     */
     forwardVisibleLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_line", [
             {
@@ -604,6 +1027,19 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `count` visible lines forward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves backward by 0 - `count` lines.
+     * @param count - number of lines to move forward
+     */
     forwardVisibleLines(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_lines", [
             {
@@ -616,6 +1052,15 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves forward to the next visible word end.
+     *
+     * If `iter` is currently on a word end, moves forward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language
+     */
     forwardVisibleWordEnd() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_word_end", [
             {
@@ -624,6 +1069,10 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls [method@Gtk.TextIter.forward_visible_word_end] up to `count` times.
+     * @param count - number of times to move
+     */
     forwardVisibleWordEnds(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_visible_word_ends", [
             {
@@ -636,6 +1085,15 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves forward to the next word end.
+     *
+     * If `iter` is currently on a word end, moves forward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     forwardWordEnd() {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_word_end", [
             {
@@ -644,6 +1102,10 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls [method@Gtk.TextIter.forward_word_end] up to `count` times.
+     * @param count - number of times to move
+     */
     forwardWordEnds(count) {
         return call("libgtk-4.so.1", "gtk_text_iter_forward_word_ends", [
             {
@@ -656,6 +1118,13 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Free an iterator allocated on the heap.
+     *
+     * This function is intended for use in language bindings,
+     * and is not especially useful for applications, because
+     * iterators can simply be allocated on the stack.
+     */
     free() {
         call("libgtk-4.so.1", "gtk_text_iter_free", [
             {
@@ -664,6 +1133,9 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the `GtkTextBuffer` this iterator is associated with.
+     */
     getBuffer() {
         const ptr = call("libgtk-4.so.1", "gtk_text_iter_get_buffer", [
             {
@@ -673,6 +1145,10 @@ export class TextIter {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, TextBuffer);
     }
+    /**
+     * Returns the number of bytes in the line containing @iter,
+     * including the paragraph delimiters.
+     */
     getBytesInLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_bytes_in_line", [
             {
@@ -681,6 +1157,17 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * The Unicode character at this iterator is returned.
+     *
+     * Equivalent to operator* on a C++ iterator. If the element at
+     * this iterator is a non-character element, such as an image
+     * embedded in the buffer, the Unicode “unknown” character 0xFFFC
+     * is returned. If invoked on the end iterator, zero is returned;
+     * zero is not a valid Unicode character.
+     *
+     * So you can write a loop which ends when this function returns 0.
+     */
     getChar() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_char", [
             {
@@ -689,6 +1176,10 @@ export class TextIter {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Returns the number of characters in the line containing @iter,
+     * including the paragraph delimiters.
+     */
     getCharsInLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_chars_in_line", [
             {
@@ -697,6 +1188,12 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * If the location at `iter` contains a child anchor, the
+     * anchor is returned.
+     *
+     * Otherwise, %NULL is returned.
+     */
     getChildAnchor() {
         const ptr = call("libgtk-4.so.1", "gtk_text_iter_get_child_anchor", [
             {
@@ -708,6 +1205,12 @@ export class TextIter {
             return null;
         return getObject(ptr, TextChildAnchor);
     }
+    /**
+     * Returns the language in effect at @iter.
+     *
+     * If no tags affecting language apply to @iter, the return
+     * value is identical to that of [func@Gtk.get_default_language].
+     */
     getLanguage() {
         const ptr = call("libgtk-4.so.1", "gtk_text_iter_get_language", [
             {
@@ -722,6 +1225,12 @@ export class TextIter {
         });
         return getObject(ptr, Pango.Language);
     }
+    /**
+     * Returns the line number containing the iterator.
+     *
+     * Lines in a `GtkTextBuffer` are numbered beginning
+     * with 0 for the first line in the buffer.
+     */
     getLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_line", [
             {
@@ -730,6 +1239,14 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the byte index of the iterator, counting
+     * from the start of a newline-terminated line.
+     *
+     * Remember that `GtkTextBuffer` encodes text in
+     * UTF-8, and that characters can require a variable
+     * number of bytes to represent.
+     */
     getLineIndex() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_line_index", [
             {
@@ -738,6 +1255,12 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the character offset of the iterator,
+     * counting from the start of a newline-terminated line.
+     *
+     * The first character on the line has offset 0.
+     */
     getLineOffset() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_line_offset", [
             {
@@ -746,6 +1269,15 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns a list of all `GtkTextMark` at this location.
+     *
+     * Because marks are not iterable (they don’t take up any "space"
+     * in the buffer, they are just marks in between iterable locations),
+     * multiple marks can exist in the same place.
+     *
+     * The returned list is not in any meaningful order.
+     */
     getMarks() {
         const ptrs = call("libgtk-4.so.1", "gtk_text_iter_get_marks", [
             {
@@ -760,6 +1292,14 @@ export class TextIter {
         });
         return ptrs.map((ptr) => getObject(ptr, TextMark));
     }
+    /**
+     * Returns the character offset of an iterator.
+     *
+     * Each character in a `GtkTextBuffer` has an offset,
+     * starting with 0 for the first character in the buffer.
+     * Use [method@Gtk.TextBuffer.get_iter_at_offset] to convert
+     * an offset back into an iterator.
+     */
     getOffset() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_offset", [
             {
@@ -768,6 +1308,11 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * If the element at `iter` is a paintable, the paintable is returned.
+     *
+     * Otherwise, %NULL is returned.
+     */
     getPaintable() {
         const ptr = call("libgtk-4.so.1", "gtk_text_iter_get_paintable", [
             {
@@ -779,6 +1324,19 @@ export class TextIter {
             return null;
         return getObject(ptr, Gdk.Paintable);
     }
+    /**
+     * Returns the text in the given range.
+     *
+     * A “slice” is an array of characters encoded in UTF-8 format,
+     * including the Unicode “unknown” character 0xFFFC for iterable
+     * non-character elements in the buffer, such as images.
+     * Because images are encoded in the slice, byte and
+     * character offsets in the returned array will correspond to byte
+     * offsets in the text buffer. Note that 0xFFFC can occur in normal
+     * text as well, so it is not a reliable indicator that a paintable or
+     * widget is in the buffer.
+     * @param end - iterator at end of a range
+     */
     getSlice(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_slice", [
             {
@@ -796,6 +1354,15 @@ export class TextIter {
             },
         ], { type: "string" });
     }
+    /**
+     * Returns a list of tags that apply to @iter, in ascending order of
+     * priority.
+     *
+     * The highest-priority tags are last.
+     *
+     * The `GtkTextTag`s in the list don’t have a reference added,
+     * but you have to free the list itself.
+     */
     getTags() {
         const ptrs = call("libgtk-4.so.1", "gtk_text_iter_get_tags", [
             {
@@ -810,6 +1377,16 @@ export class TextIter {
         });
         return ptrs.map((ptr) => getObject(ptr, TextTag));
     }
+    /**
+     * Returns text in the given range.
+     *
+     * If the range
+     * contains non-text elements such as images, the character and byte
+     * offsets in the returned string will not correspond to character and
+     * byte offsets in the buffer. If you want offsets to correspond, see
+     * [method@Gtk.TextIter.get_slice].
+     * @param end - iterator at end of a range
+     */
     getText(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_text", [
             {
@@ -827,6 +1404,16 @@ export class TextIter {
             },
         ], { type: "string" });
     }
+    /**
+     * Returns a list of `GtkTextTag` that are toggled on or off at this
+     * point.
+     *
+     * If `toggled_on` is %TRUE, the list contains tags that are
+     * toggled on. If a tag is toggled on at @iter, then some non-empty
+     * range of characters following `iter` has that tag applied to it.  If
+     * a tag is toggled off, then some non-empty range following `iter` does not have the tag applied to it.
+     * @param toggledOn - %TRUE to get toggled-on tags
+     */
     getToggledTags(toggledOn) {
         const ptrs = call("libgtk-4.so.1", "gtk_text_iter_get_toggled_tags", [
             {
@@ -845,6 +1432,12 @@ export class TextIter {
         });
         return ptrs.map((ptr) => getObject(ptr, TextTag));
     }
+    /**
+     * Returns the number of bytes from the start of the
+     * line to the given @iter, not counting bytes that
+     * are invisible due to tags with the “invisible” flag
+     * toggled on.
+     */
     getVisibleLineIndex() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_visible_line_index", [
             {
@@ -853,6 +1446,12 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the offset in characters from the start of the
+     * line to the given @iter, not counting characters that
+     * are invisible due to tags with the “invisible” flag
+     * toggled on.
+     */
     getVisibleLineOffset() {
         return call("libgtk-4.so.1", "gtk_text_iter_get_visible_line_offset", [
             {
@@ -861,6 +1460,15 @@ export class TextIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns visible text in the given range.
+     *
+     * Like [method@Gtk.TextIter.get_slice], but invisible text
+     * is not included. Invisible text is usually invisible because
+     * a `GtkTextTag` with the “invisible” attribute turned on has
+     * been applied to it.
+     * @param end - iterator at end of range
+     */
     getVisibleSlice(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_visible_slice", [
             {
@@ -878,6 +1486,15 @@ export class TextIter {
             },
         ], { type: "string" });
     }
+    /**
+     * Returns visible text in the given range.
+     *
+     * Like [method@Gtk.TextIter.get_text], but invisible text
+     * is not included. Invisible text is usually invisible because
+     * a `GtkTextTag` with the “invisible” attribute turned on has
+     * been applied to it.
+     * @param end - iterator at end of range
+     */
     getVisibleText(end) {
         return call("libgtk-4.so.1", "gtk_text_iter_get_visible_text", [
             {
@@ -895,6 +1512,14 @@ export class TextIter {
             },
         ], { type: "string" });
     }
+    /**
+     * Returns %TRUE if `iter` points to a character that is part
+     * of a range tagged with @tag.
+     *
+     * See also [method@Gtk.TextIter.starts_tag] and
+     * [method@Gtk.TextIter.ends_tag].
+     * @param tag - a `GtkTextTag`
+     */
     hasTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_has_tag", [
             {
@@ -907,6 +1532,13 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether `iter` falls in the range [@start, @end).
+     *
+     * `start` and `end` must be in ascending order.
+     * @param start - start of range
+     * @param end - end of range
+     */
     inRange(start, end) {
         return call("libgtk-4.so.1", "gtk_text_iter_in_range", [
             {
@@ -933,6 +1565,14 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether `iter` is inside a sentence (as opposed to in
+     * between two sentences, e.g. after a period and before the first
+     * letter of the next sentence).
+     *
+     * Sentence boundaries are determined by Pango and should be correct
+     * for nearly any language.
+     */
     insideSentence() {
         return call("libgtk-4.so.1", "gtk_text_iter_inside_sentence", [
             {
@@ -941,6 +1581,17 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether the character pointed by `iter` is part of a
+     * natural-language word (as opposed to say inside some whitespace).
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     *
+     * Note that if [method@Gtk.TextIter.starts_word] returns %TRUE,
+     * then this function returns %TRUE too, since `iter` points to
+     * the first character of the word.
+     */
     insideWord() {
         return call("libgtk-4.so.1", "gtk_text_iter_inside_word", [
             {
@@ -949,6 +1600,13 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determine if `iter` is at a cursor position.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] or
+     * [struct@Pango.LogAttr] or [func@Pango.break] for details
+     * on what a cursor position is.
+     */
     isCursorPosition() {
         return call("libgtk-4.so.1", "gtk_text_iter_is_cursor_position", [
             {
@@ -957,6 +1615,13 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if `iter` is the end iterator.
+     *
+     * This means it is one past the last dereferenceable iterator
+     * in the buffer. [method@Gtk.TextIter.is_end] is the most efficient
+     * way to check whether an iterator is the end iterator.
+     */
     isEnd() {
         return call("libgtk-4.so.1", "gtk_text_iter_is_end", [
             {
@@ -965,6 +1630,9 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if `iter` is the first iterator in the buffer.
+     */
     isStart() {
         return call("libgtk-4.so.1", "gtk_text_iter_is_start", [
             {
@@ -973,6 +1641,18 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Swaps the value of `first` and `second` if `second` comes before
+     * `first` in the buffer.
+     *
+     * That is, ensures that `first` and `second` are in sequence.
+     * Most text buffer functions that take a range call this
+     * automatically on your behalf, so there’s no real reason to
+     * call it yourself in those cases. There are some exceptions,
+     * such as [method@Gtk.TextIter.in_range], that expect a
+     * pre-sorted range.
+     * @param second - another `GtkTextIter`
+     */
     order(second) {
         call("libgtk-4.so.1", "gtk_text_iter_order", [
             {
@@ -990,6 +1670,13 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves iterator `iter` to the start of the line @line_number.
+     *
+     * If `line_number` is negative or larger than or equal to the number of lines
+     * in the buffer, moves `iter` to the start of the last line in the buffer.
+     * @param lineNumber - line number (counted from 0)
+     */
     setLine(lineNumber) {
         call("libgtk-4.so.1", "gtk_text_iter_set_line", [
             {
@@ -1002,6 +1689,13 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Same as [method@Gtk.TextIter.set_line_offset], but works with a
+     * byte index. The given byte index must be at
+     * the start of a character, it can’t be in the middle of a UTF-8
+     * encoded character.
+     * @param byteOnLine - a byte index relative to the start of @iter’s current line
+     */
     setLineIndex(byteOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_line_index", [
             {
@@ -1014,6 +1708,15 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Moves `iter` within a line, to a new character (not byte) offset.
+     *
+     * The given character offset must be less than or equal to the number
+     * of characters in the line; if equal, `iter` moves to the start of the
+     * next line. See [method@Gtk.TextIter.set_line_index] if you have a byte
+     * index rather than a character offset.
+     * @param charOnLine - a character offset relative to the start of @iter’s current line
+     */
     setLineOffset(charOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_line_offset", [
             {
@@ -1026,6 +1729,13 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `iter` to point to @char_offset.
+     *
+     * `char_offset` counts from the start
+     * of the entire text buffer, starting with 0.
+     * @param charOffset - a character number
+     */
     setOffset(charOffset) {
         call("libgtk-4.so.1", "gtk_text_iter_set_offset", [
             {
@@ -1038,6 +1748,12 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Like [method@Gtk.TextIter.set_line_index], but the index is in visible
+     * bytes, i.e. text with a tag making it invisible is not counted
+     * in the index.
+     * @param byteOnLine - a byte index
+     */
     setVisibleLineIndex(byteOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_visible_line_index", [
             {
@@ -1050,6 +1766,12 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Like [method@Gtk.TextIter.set_line_offset], but the offset is in visible
+     * characters, i.e. text with a tag making it invisible is not
+     * counted in the offset.
+     * @param charOnLine - a character offset
+     */
     setVisibleLineOffset(charOnLine) {
         call("libgtk-4.so.1", "gtk_text_iter_set_visible_line_offset", [
             {
@@ -1062,6 +1784,15 @@ export class TextIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns %TRUE if `iter` begins a paragraph.
+     *
+     * This is the case if [method@Gtk.TextIter.get_line_offset]
+     * would return 0. However this function is potentially more
+     * efficient than [method@Gtk.TextIter.get_line_offset], because
+     * it doesn’t have to compute the offset, it just has to see
+     * whether it’s 0.
+     */
     startsLine() {
         return call("libgtk-4.so.1", "gtk_text_iter_starts_line", [
             {
@@ -1070,6 +1801,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether `iter` begins a sentence.
+     *
+     * Sentence boundaries are determined by Pango and
+     * should be correct for nearly any language.
+     */
     startsSentence() {
         return call("libgtk-4.so.1", "gtk_text_iter_starts_sentence", [
             {
@@ -1078,6 +1815,19 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if `tag` is toggled on at exactly this point.
+     *
+     * If `tag` is %NULL, returns %TRUE if any tag is toggled on at this point.
+     *
+     * Note that if this function returns %TRUE, it means that
+     * `iter` is at the beginning of the tagged range, and that the
+     * character at `iter` is inside the tagged range. In other
+     * words, unlike [method@Gtk.TextIter.ends_tag], if
+     * this function returns %TRUE, [method@Gtk.TextIter.has_tag]
+     * will also return %TRUE for the same parameters.
+     * @param tag - a `GtkTextTag`
+     */
     startsTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_starts_tag", [
             {
@@ -1091,6 +1841,12 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether `iter` begins a natural-language word.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     startsWord() {
         return call("libgtk-4.so.1", "gtk_text_iter_starts_word", [
             {
@@ -1099,6 +1855,14 @@ export class TextIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether a range with `tag` applied to it begins
+     * or ends at @iter.
+     *
+     * This is equivalent to (gtk_text_iter_starts_tag() ||
+     * gtk_text_iter_ends_tag())
+     * @param tag - a `GtkTextTag`
+     */
     togglesTag(tag) {
         return call("libgtk-4.so.1", "gtk_text_iter_toggles_tag", [
             {