@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtksource/gutter-renderer-pixbuf.js

@@ -4,13 +4,25 @@ import * as Gdk from "../gdk/index.js";
 import * as GdkPixbuf from "../gdkpixbuf/index.js";
 import * as Gio from "../gio/index.js";
 import { GutterRenderer } from "./gutter-renderer.js";
+/**
+ * Renders a pixbuf in the gutter.
+ *
+ * A `GtkSourceGutterRendererPixbuf` can be used to render an image in a cell of
+ * [class@Gutter].
+ */
 export class GutterRendererPixbuf extends GutterRenderer {
+    /**
+     * Create a new #GtkSourceGutterRendererPixbuf.
+     */
     constructor(...args) {
         super(...args);
     }
     createPtr(_args) {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_new", [], { type: "gobject", borrowed: false });
     }
+    /**
+     * Get the gicon of the renderer
+     */
     getGicon() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_get_gicon", [
             {
@@ -28,6 +40,10 @@ export class GutterRendererPixbuf extends GutterRenderer {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets a [iface@Gdk.Paintable] that was set with
+     * [method@GutterRendererPixbuf.set_paintable]
+     */
     getPaintable() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_get_paintable", [
             {
@@ -39,6 +55,9 @@ export class GutterRendererPixbuf extends GutterRenderer {
             return null;
         return getObject(ptr, Gdk.Paintable);
     }
+    /**
+     * Get the pixbuf of the renderer.
+     */
     getPixbuf() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_get_pixbuf", [
             {
@@ -48,6 +67,12 @@ export class GutterRendererPixbuf extends GutterRenderer {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, GdkPixbuf.Pixbuf);
     }
+    /**
+     * Allows overlaying a paintable on top of any other image that
+     * has been set for the pixbuf. This will be applied when the
+     * widget is next snapshot.
+     * @param paintable - a #GdkPaintable
+     */
     overlayPaintable(paintable) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_overlay_paintable", [
             {
@@ -60,6 +85,9 @@ export class GutterRendererPixbuf extends GutterRenderer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * @param icon - the icon, or %NULL.
+     */
     setGicon(icon) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_set_gicon", [
             {
@@ -73,6 +101,9 @@ export class GutterRendererPixbuf extends GutterRenderer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * @param iconName - the icon name, or %NULL.
+     */
     setIconName(iconName) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_set_icon_name", [
             {
@@ -86,6 +117,9 @@ export class GutterRendererPixbuf extends GutterRenderer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * @param paintable - the paintable, or %NULL.
+     */
     setPaintable(paintable) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_set_paintable", [
             {
@@ -99,6 +133,9 @@ export class GutterRendererPixbuf extends GutterRenderer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * @param pixbuf - the pixbuf, or %NULL.
+     */
     setPixbuf(pixbuf) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_pixbuf_set_pixbuf", [
             {

package/dist/generated/gtksource/gutter-renderer-text.d.ts

@@ -1,10 +1,33 @@
 import { Ref } from "@gtkx/native";
 import * as GObject from "../gobject/index.js";
 import { GutterRenderer } from "./gutter-renderer.js";
+/**
+ * Renders text in the gutter.
+ *
+ * A `GtkSourceGutterRendererText` can be used to render text in a cell of
+ * [class@Gutter].
+ */
 export declare class GutterRendererText extends GutterRenderer {
+    /**
+     * Create a new #GtkSourceGutterRendererText.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Measures the text provided using the pango layout used by the
+     * #GtkSourceGutterRendererText.
+     * @param text - the text to measure.
+     * @param width - location to store the width of the text in pixels,
+     * @param height - location to store the height of the text in
+     */
     measureText(text: string, width?: Ref<number> | null, height?: Ref<number> | null): void;
+    /**
+     * Measures the pango markup provided using the pango layout used by the
+     * #GtkSourceGutterRendererText.
+     * @param markup - the pango markup to measure.
+     * @param width - location to store the width of the text in pixels,
+     * @param height - location to store the height of the text in
+     */
     measureMarkup(markup: string, width?: Ref<number> | null, height?: Ref<number> | null): void;
     setMarkup(markup: string, length: number): void;
     setText(text: string, length: number): void;

package/dist/generated/gtksource/gutter-renderer-text.js

@@ -1,13 +1,29 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { GutterRenderer } from "./gutter-renderer.js";
+/**
+ * Renders text in the gutter.
+ *
+ * A `GtkSourceGutterRendererText` can be used to render text in a cell of
+ * [class@Gutter].
+ */
 export class GutterRendererText extends GutterRenderer {
+    /**
+     * Create a new #GtkSourceGutterRendererText.
+     */
     constructor(...args) {
         super(...args);
     }
     createPtr(_args) {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_text_new", [], { type: "gobject", borrowed: false });
     }
+    /**
+     * Measures the text provided using the pango layout used by the
+     * #GtkSourceGutterRendererText.
+     * @param text - the text to measure.
+     * @param width - location to store the width of the text in pixels,
+     * @param height - location to store the height of the text in
+     */
     measureText(text, width, height) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_text_measure", [
             {
@@ -36,6 +52,13 @@ export class GutterRendererText extends GutterRenderer {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Measures the pango markup provided using the pango layout used by the
+     * #GtkSourceGutterRendererText.
+     * @param markup - the pango markup to measure.
+     * @param width - location to store the width of the text in pixels,
+     * @param height - location to store the height of the text in
+     */
     measureMarkup(markup, width, height) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_text_measure_markup", [
             {

package/dist/generated/gtksource/gutter-renderer.d.ts

@@ -8,20 +8,114 @@ import * as Gtk from "../gtk/index.js";
 export declare class GutterRenderer extends Gtk.Widget {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Emits the [signal@GutterRenderer::activate] signal of the renderer. This is
+     * called from [class@Gutter] and should never have to be called manually.
+     * @param iter - a #GtkTextIter at the start of the line where the renderer is activated
+     * @param area - a #GdkRectangle of the cell area where the renderer is activated
+     * @param button - the button that was pressed
+     * @param state - a #GdkModifierType
+     * @param nPresses - the number of button presses
+     */
     activateRenderer(iter: Gtk.TextIter, area: Gdk.Rectangle, button: number, state: Gdk.ModifierType, nPresses: number): void;
+    /**
+     * Locates where to render content that is `width` x `height` based on
+     * the renderers alignment and padding.
+     *
+     * The location will be placed into `x` and `y` and is relative to the
+     * renderer's coordinates.
+     *
+     * It is encouraged that renderers use this function when snappshotting
+     * to ensure consistent placement of their contents.
+     * @param line - the line number for content
+     * @param width - the width of the content to draw
+     * @param height - the height of the content to draw
+     * @param x - the X position to render the content
+     * @param y - the Y position to render the content
+     */
     alignCell(line: number, width: number, height: number, x: Ref<number>, y: Ref<number>): void;
+    /**
+     * Get the alignment mode.
+     *
+     * The alignment mode describes the manner in which the
+     * renderer is aligned (see [property@GutterRenderer:xalign] and
+     * [property@GutterRenderer:yalign]).
+     */
     getAlignmentMode(): GutterRendererAlignmentMode;
+    /**
+     * Gets the [class@Buffer] for which the gutter renderer is drawing.
+     */
     getBuffer(): Buffer | null;
+    /**
+     * Get the view associated to the gutter renderer
+     */
     getView(): View;
+    /**
+     * Gets the `xalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     */
     getXalign(): number;
+    /**
+     * Gets the `xpad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     */
     getXpad(): number;
+    /**
+     * Gets the `yalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     */
     getYalign(): number;
+    /**
+     * Gets the `ypad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     */
     getYpad(): number;
+    /**
+     * Get whether the renderer is activatable at the location provided. This is
+     * called from [class@Gutter] to determine whether a renderer is activatable
+     * using the mouse pointer.
+     * @param iter - a #GtkTextIter at the start of the line to be activated
+     * @param area - a #GdkRectangle of the cell area to be activated
+     */
     queryActivatable(iter: Gtk.TextIter, area: Gdk.Rectangle): boolean;
+    /**
+     * Set the alignment mode. The alignment mode describes the manner in which the
+     * renderer is aligned (see [property@GutterRenderer:xalign] and
+     * [property@GutterRenderer:yalign]).
+     * @param mode - a #GtkSourceGutterRendererAlignmentMode
+     */
     setAlignmentMode(mode: GutterRendererAlignmentMode): void;
+    /**
+     * Adjusts the `xalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     * @param xalign - the Y padding for the drawing cell
+     */
     setXalign(xalign: number): void;
+    /**
+     * Adjusts the `xpad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     * @param xpad - the Y padding for the drawing cell
+     */
     setXpad(xpad: number): void;
+    /**
+     * Adjusts the `yalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     * @param yalign - the Y padding for the drawing cell
+     */
     setYalign(yalign: number): void;
+    /**
+     * Adjusts the `ypad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     * @param ypad - the Y padding for the drawing cell
+     */
     setYpad(ypad: number): void;
     connect(signal: "activate", handler: (self: GutterRenderer, iter: Gtk.TextIter, area: Gdk.Rectangle, button: number, state: Gdk.ModifierType, nPresses: number) => void, after?: boolean): number;
     connect(signal: "query-activatable", handler: (self: GutterRenderer, iter: Gtk.TextIter, area: Gdk.Rectangle) => boolean, after?: boolean): number;

package/dist/generated/gtksource/gutter-renderer.js

@@ -4,6 +4,40 @@ import { Buffer } from "./buffer.js";
 import { View } from "./view.js";
 import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
+/**
+ * Gutter cell renderer.
+ *
+ * A `GtkSourceGutterRenderer` represents a column in a [class@Gutter]. The
+ * column contains one cell for each visible line of the [class@Gtk.TextBuffer]. Due to
+ * text wrapping, a cell can thus span multiple lines of the [class@Gtk.TextView]. In
+ * this case, [enum@GutterRendererAlignmentMode] controls the alignment of
+ * the cell.
+ *
+ * The gutter renderer is a [class@Gtk.Widget] and is measured using the normal widget
+ * measurement facilities. The width of the gutter will be determined by the
+ * measurements of the gutter renderers.
+ *
+ * The width of a gutter renderer generally takes into account the entire text
+ * buffer. For instance, to display the line numbers, if the buffer contains 100
+ * lines, the gutter renderer will always set its width such as three digits can
+ * be printed, even if only the first 20 lines are shown. Another strategy is to
+ * take into account only the visible lines.  In this case, only two digits are
+ * necessary to display the line numbers of the first 20 lines. To take another
+ * example, the gutter renderer for [class@Mark]s doesn't need to take
+ * into account the text buffer to announce its width. It only depends on the
+ * icons size displayed in the gutter column.
+ *
+ * When the available size to render a cell is greater than the required size to
+ * render the cell contents, the cell contents can be aligned horizontally and
+ * vertically with [method@GutterRenderer.set_alignment_mode].
+ *
+ * The cells rendering occurs using [vfunc@Gtk.Widget.snapshot]. Implementations
+ * should use `gtk_source_gutter_renderer_get_lines()` to retrieve information
+ * about the lines to be rendered. To help with aligning content which takes
+ * into account the padding and alignment of a cell, implementations may call
+ * [method@GutterRenderer.align_cell] for a given line number with the
+ * width and height measurement of the content they width to render.
+ */
 const SIGNAL_META = {
     activate: {
         params: [
@@ -44,6 +78,15 @@ export class GutterRenderer extends Gtk.Widget {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Emits the [signal@GutterRenderer::activate] signal of the renderer. This is
+     * called from [class@Gutter] and should never have to be called manually.
+     * @param iter - a #GtkTextIter at the start of the line where the renderer is activated
+     * @param area - a #GdkRectangle of the cell area where the renderer is activated
+     * @param button - the button that was pressed
+     * @param state - a #GdkModifierType
+     * @param nPresses - the number of button presses
+     */
     activateRenderer(iter, area, button, state, nPresses) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_activate", [
             {
@@ -82,6 +125,21 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Locates where to render content that is `width` x `height` based on
+     * the renderers alignment and padding.
+     *
+     * The location will be placed into `x` and `y` and is relative to the
+     * renderer's coordinates.
+     *
+     * It is encouraged that renderers use this function when snappshotting
+     * to ensure consistent placement of their contents.
+     * @param line - the line number for content
+     * @param width - the width of the content to draw
+     * @param height - the height of the content to draw
+     * @param x - the X position to render the content
+     * @param y - the Y position to render the content
+     */
     alignCell(line, width, height, x, y) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_align_cell", [
             {
@@ -110,6 +168,13 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Get the alignment mode.
+     *
+     * The alignment mode describes the manner in which the
+     * renderer is aligned (see [property@GutterRenderer:xalign] and
+     * [property@GutterRenderer:yalign]).
+     */
     getAlignmentMode() {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_get_alignment_mode", [
             {
@@ -118,6 +183,9 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the [class@Buffer] for which the gutter renderer is drawing.
+     */
     getBuffer() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_get_buffer", [
             {
@@ -129,6 +197,9 @@ export class GutterRenderer extends Gtk.Widget {
             return null;
         return getObject(ptr, Buffer);
     }
+    /**
+     * Get the view associated to the gutter renderer
+     */
     getView() {
         const ptr = call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_get_view", [
             {
@@ -138,6 +209,11 @@ export class GutterRenderer extends Gtk.Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, View);
     }
+    /**
+     * Gets the `xalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     */
     getXalign() {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_get_xalign", [
             {
@@ -146,6 +222,11 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Gets the `xpad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     */
     getXpad() {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_get_xpad", [
             {
@@ -154,6 +235,11 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the `yalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     */
     getYalign() {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_get_yalign", [
             {
@@ -162,6 +248,11 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Gets the `ypad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     */
     getYpad() {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_get_ypad", [
             {
@@ -170,6 +261,13 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Get whether the renderer is activatable at the location provided. This is
+     * called from [class@Gutter] to determine whether a renderer is activatable
+     * using the mouse pointer.
+     * @param iter - a #GtkTextIter at the start of the line to be activated
+     * @param area - a #GdkRectangle of the cell area to be activated
+     */
     queryActivatable(iter, area) {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_query_activatable", [
             {
@@ -196,6 +294,12 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Set the alignment mode. The alignment mode describes the manner in which the
+     * renderer is aligned (see [property@GutterRenderer:xalign] and
+     * [property@GutterRenderer:yalign]).
+     * @param mode - a #GtkSourceGutterRendererAlignmentMode
+     */
     setAlignmentMode(mode) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_set_alignment_mode", [
             {
@@ -208,6 +312,12 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adjusts the `xalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     * @param xalign - the Y padding for the drawing cell
+     */
     setXalign(xalign) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_set_xalign", [
             {
@@ -220,6 +330,12 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adjusts the `xpad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     * @param xpad - the Y padding for the drawing cell
+     */
     setXpad(xpad) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_set_xpad", [
             {
@@ -232,6 +348,12 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adjusts the `yalign` property.
+     *
+     * This may be used to adjust where within the cell rectangle the renderer will draw.
+     * @param yalign - the Y padding for the drawing cell
+     */
     setYalign(yalign) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_set_yalign", [
             {
@@ -244,6 +366,12 @@ export class GutterRenderer extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adjusts the `ypad` property.
+     *
+     * This may be used to adjust the cell rectangle that the renderer will use to draw.
+     * @param ypad - the Y padding for the drawing cell
+     */
     setYpad(ypad) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_renderer_set_ypad", [
             {

package/dist/generated/gtksource/gutter.d.ts

@@ -2,12 +2,43 @@ import { GutterRenderer } from "./gutter-renderer.js";
 import { View } from "./view.js";
 import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
+/**
+ * Gutter object for [class@View].
+ *
+ * The `GtkSourceGutter` object represents the left or right gutter of the text
+ * view. It is used by [class@View] to draw the line numbers and
+ * [class@Mark]s that might be present on a line. By packing
+ * additional [class@GutterRenderer] objects in the gutter, you can extend the
+ * gutter with your own custom drawings.
+ *
+ * To get a `GtkSourceGutter`, use the [method@View.get_gutter] function.
+ *
+ * The gutter works very much the same way as cells rendered in a [class@Gtk.TreeView].
+ * The concept is similar, with the exception that the gutter does not have an
+ * underlying [iface@Gtk.TreeModel]. The builtin line number renderer is at position
+ * %GTK_SOURCE_VIEW_GUTTER_POSITION_LINES (-30) and the marks renderer is at
+ * %GTK_SOURCE_VIEW_GUTTER_POSITION_MARKS (-20). The gutter sorts the renderers
+ * in ascending order, from left to right. So the marks are displayed on the
+ * right of the line numbers.
+ */
 export declare class Gutter extends Gtk.Widget {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     getView(): View;
+    /**
+     * Insert `renderer` into the gutter. If `renderer` is yet unowned then gutter
+     * claims its ownership. Otherwise just increases renderer's reference count.
+     * `renderer` cannot be already inserted to another gutter.
+     * @param renderer - a gutter renderer (must inherit from #GtkSourceGutterRenderer).
+     * @param position - the renderer position.
+     */
     insert(renderer: GutterRenderer, position: number): boolean;
     remove(renderer: GutterRenderer): void;
+    /**
+     * Reorders `renderer` in `gutter` to new @position.
+     * @param renderer - a #GtkCellRenderer.
+     * @param position - the new renderer position.
+     */
     reorder(renderer: GutterRenderer, position: number): void;
     connect(signal: "notify", handler: (self: Gutter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtksource/gutter.js

@@ -2,6 +2,25 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { View } from "./view.js";
 import * as Gtk from "../gtk/index.js";
+/**
+ * Gutter object for [class@View].
+ *
+ * The `GtkSourceGutter` object represents the left or right gutter of the text
+ * view. It is used by [class@View] to draw the line numbers and
+ * [class@Mark]s that might be present on a line. By packing
+ * additional [class@GutterRenderer] objects in the gutter, you can extend the
+ * gutter with your own custom drawings.
+ *
+ * To get a `GtkSourceGutter`, use the [method@View.get_gutter] function.
+ *
+ * The gutter works very much the same way as cells rendered in a [class@Gtk.TreeView].
+ * The concept is similar, with the exception that the gutter does not have an
+ * underlying [iface@Gtk.TreeModel]. The builtin line number renderer is at position
+ * %GTK_SOURCE_VIEW_GUTTER_POSITION_LINES (-30) and the marks renderer is at
+ * %GTK_SOURCE_VIEW_GUTTER_POSITION_MARKS (-20). The gutter sorts the renderers
+ * in ascending order, from left to right. So the marks are displayed on the
+ * right of the line numbers.
+ */
 export class Gutter extends Gtk.Widget {
     constructor(...args) {
         super(...args);
@@ -22,6 +41,13 @@ export class Gutter extends Gtk.Widget {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, View);
     }
+    /**
+     * Insert `renderer` into the gutter. If `renderer` is yet unowned then gutter
+     * claims its ownership. Otherwise just increases renderer's reference count.
+     * `renderer` cannot be already inserted to another gutter.
+     * @param renderer - a gutter renderer (must inherit from #GtkSourceGutterRenderer).
+     * @param position - the renderer position.
+     */
     insert(renderer, position) {
         return call("libgtksourceview-5.so.0", "gtk_source_gutter_insert", [
             {
@@ -50,6 +76,11 @@ export class Gutter extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Reorders `renderer` in `gutter` to new @position.
+     * @param renderer - a #GtkCellRenderer.
+     * @param position - the new renderer position.
+     */
     reorder(renderer, position) {
         call("libgtksourceview-5.so.0", "gtk_source_gutter_reorder", [
             {

package/dist/generated/gtksource/hover-context.d.ts

@@ -3,11 +3,42 @@ import { Buffer } from "./buffer.js";
 import { View } from "./view.js";
 import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
+/**
+ * Context for populating [class@HoverDisplay] contents.
+ *
+ * `GtkSourceHoverContext` contains information about the request to populate
+ * contents for a [class@HoverDisplay].
+ *
+ * It can be used to retrieve the [class@View], [class@Buffer], and
+ * [struct@Gtk.TextIter] for the regions of text which are being displayed.
+ *
+ * Use [method@HoverContext.get_bounds] to get the word that was
+ * requested. [method@HoverContext.get_iter] will get you the location
+ * of the pointer when the request was made.
+ */
 export declare class HoverContext extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the current word bounds of the hover.
+     *
+     * If `begin` is non-%NULL, it will be set to the start position of the
+     * current word being hovered.
+     *
+     * If `end` is non-%NULL, it will be set to the end position for the
+     * current word being hovered.
+     * @param begin - a #GtkTextIter
+     * @param end - a #GtkTextIter
+     */
     getBounds(begin?: Ref<Gtk.TextIter> | null, end?: Ref<Gtk.TextIter> | null): boolean;
+    /**
+     * A convenience function to get the buffer.
+     */
     getBuffer(): Buffer;
+    /**
+     * Gets the location of the pointer where the request was made.
+     * @param iter - a #GtkTextIter
+     */
     getIter(iter: Ref<Gtk.TextIter>): boolean;
     getView(): View;
     connect(signal: "notify", handler: (self: HoverContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;