@gtkx/ffi 0.9.4 → 0.10.1

package/dist/generated/gtk/symbolic-paintable.d.ts

@@ -1,4 +1,6 @@
+import { Ref } from "@gtkx/native";
 import { NativeObject } from "../../native/base.js";
+import { Snapshot } from "./snapshot.js";
 import * as Gdk from "../gdk/index.js";
 /**
  * An interface that supports symbolic colors in paintables.
@@ -28,4 +30,123 @@ export declare class SymbolicPaintable extends NativeObject {
      * @param nColors - The number of colors
      */
     snapshotSymbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[], nColors: number): void;
+    /**
+     * Compute a concrete size for the `GdkPaintable`.
+     *
+     * Applies the sizing algorithm outlined in the
+     * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+     * to the given `paintable`. See that link for more details.
+     *
+     * It is not necessary to call this function when both `specified_width`
+     * and `specified_height` are known, but it is useful to call this
+     * function in GtkWidget:measure implementations to compute the
+     * other dimension when only one dimension is given.
+     * @param specifiedWidth - the width `paintable` could be drawn into or
+     * @param specifiedHeight - the height `paintable` could be drawn into or
+     * @param defaultWidth - the width `paintable` would be drawn into if
+     * @param defaultHeight - the height `paintable` would be drawn into if
+     * @param concreteWidth - will be set to the concrete width computed
+     * @param concreteHeight - will be set to the concrete height computed
+     */
+    computeConcreteSize(specifiedWidth: number, specifiedHeight: number, defaultWidth: number, defaultHeight: number, concreteWidth: Ref<number>, concreteHeight: Ref<number>): void;
+    /**
+     * Gets an immutable paintable for the current contents displayed by `paintable`.
+     *
+     * This is useful when you want to retain the current state of an animation,
+     * for example to take a screenshot of a running animation.
+     *
+     * If the `paintable` is already immutable, it will return itself.
+     */
+    getCurrentImage(): Gdk.Paintable;
+    /**
+     * Get flags for the paintable.
+     *
+     * This is oftentimes useful for optimizations.
+     *
+     * See {@link Gdk.PaintableFlags} for the flags and what they mean.
+     */
+    getFlags(): Gdk.PaintableFlags;
+    /**
+     * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+     *
+     * The aspect ratio is the width divided by the height, so a value of 0.5
+     * means that the `paintable` prefers to be displayed twice as high as it
+     * is wide. Consumers of this interface can use this to preserve aspect
+     * ratio when displaying the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to {@link Gdk.Paintable.snapshot}.
+     *
+     * Usually when a `paintable` returns nonzero values from
+     * {@link Gdk.Paintable.get_intrinsic_width} and
+     * {@link Gdk.Paintable.get_intrinsic_height} the aspect ratio
+     * should conform to those values, though that is not required.
+     *
+     * If the `paintable` does not have a preferred aspect ratio,
+     * it returns 0. Negative values are never returned.
+     */
+    getIntrinsicAspectRatio(): number;
+    /**
+     * Gets the preferred height the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to {@link Gdk.Paintable.snapshot}.
+     *
+     * If the `paintable` does not have a preferred height, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicHeight(): number;
+    /**
+     * Gets the preferred width the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to {@link Gdk.Paintable.snapshot}.
+     *
+     * If the `paintable` does not have a preferred width, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicWidth(): number;
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their contents.
+     *
+     * Unless the contents are invalidated, implementations must guarantee that
+     * multiple calls of {@link Gdk.Paintable.snapshot} produce the same output.
+     *
+     * This function will emit the {@link Gdk.Paintable.:invalidate-contents}
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+     * it must not call this function.
+     */
+    invalidateContents(): void;
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their size.
+     *
+     * As long as the size is not invalidated, `paintable` must return the same
+     * values for its intrinsic width, height and aspect ratio.
+     *
+     * This function will emit the {@link Gdk.Paintable.:invalidate-size}
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+     * it must not call this function.
+     */
+    invalidateSize(): void;
+    /**
+     * Snapshots the given paintable with the given `width` and `height`.
+     *
+     * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+     * If `width` and `height` are not larger than zero, this function will
+     * do nothing.
+     * @param snapshot - a `GdkSnapshot` to snapshot to
+     * @param width - width to snapshot in
+     * @param height - height to snapshot in
+     */
+    snapshot(snapshot: Snapshot, width: number, height: number): void;
 }

package/dist/generated/gtk/symbolic-paintable.js

@@ -1,5 +1,7 @@
 import { call } from "../../batch.js";
+import { getNativeObject } from "../../native/object.js";
 import { NativeObject } from "../../native/base.js";
+import * as Gdk from "../gdk/index.js";
 /**
  * An interface that supports symbolic colors in paintables.
  *
@@ -63,4 +65,223 @@ export class SymbolicPaintable extends NativeObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compute a concrete size for the `GdkPaintable`.
+     *
+     * Applies the sizing algorithm outlined in the
+     * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+     * to the given `paintable`. See that link for more details.
+     *
+     * It is not necessary to call this function when both `specified_width`
+     * and `specified_height` are known, but it is useful to call this
+     * function in GtkWidget:measure implementations to compute the
+     * other dimension when only one dimension is given.
+     * @param specifiedWidth - the width `paintable` could be drawn into or
+     * @param specifiedHeight - the height `paintable` could be drawn into or
+     * @param defaultWidth - the width `paintable` would be drawn into if
+     * @param defaultHeight - the height `paintable` would be drawn into if
+     * @param concreteWidth - will be set to the concrete width computed
+     * @param concreteHeight - will be set to the concrete height computed
+     */
+    computeConcreteSize(specifiedWidth, specifiedHeight, defaultWidth, defaultHeight, concreteWidth, concreteHeight) {
+        call("libgtk-4.so.1", "gdk_paintable_compute_concrete_size", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: specifiedWidth,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: specifiedHeight,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: defaultWidth,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: defaultHeight,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                value: concreteWidth,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 64 } },
+                value: concreteHeight,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Gets an immutable paintable for the current contents displayed by `paintable`.
+     *
+     * This is useful when you want to retain the current state of an animation,
+     * for example to take a screenshot of a running animation.
+     *
+     * If the `paintable` is already immutable, it will return itself.
+     */
+    getCurrentImage() {
+        const ptr = call("libgtk-4.so.1", "gdk_paintable_get_current_image", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "gobject", borrowed: true });
+        return getNativeObject(ptr, Gdk.Paintable);
+    }
+    /**
+     * Get flags for the paintable.
+     *
+     * This is oftentimes useful for optimizations.
+     *
+     * See {@link Gdk.PaintableFlags} for the flags and what they mean.
+     */
+    getFlags() {
+        return call("libgtk-4.so.1", "gdk_paintable_get_flags", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+     *
+     * The aspect ratio is the width divided by the height, so a value of 0.5
+     * means that the `paintable` prefers to be displayed twice as high as it
+     * is wide. Consumers of this interface can use this to preserve aspect
+     * ratio when displaying the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to {@link Gdk.Paintable.snapshot}.
+     *
+     * Usually when a `paintable` returns nonzero values from
+     * {@link Gdk.Paintable.get_intrinsic_width} and
+     * {@link Gdk.Paintable.get_intrinsic_height} the aspect ratio
+     * should conform to those values, though that is not required.
+     *
+     * If the `paintable` does not have a preferred aspect ratio,
+     * it returns 0. Negative values are never returned.
+     */
+    getIntrinsicAspectRatio() {
+        return call("libgtk-4.so.1", "gdk_paintable_get_intrinsic_aspect_ratio", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "float", size: 64 });
+    }
+    /**
+     * Gets the preferred height the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to {@link Gdk.Paintable.snapshot}.
+     *
+     * If the `paintable` does not have a preferred height, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicHeight() {
+        return call("libgtk-4.so.1", "gdk_paintable_get_intrinsic_height", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Gets the preferred width the `paintable` would like to be displayed at.
+     *
+     * Consumers of this interface can use this to reserve enough space to draw
+     * the paintable.
+     *
+     * This is a purely informational value and does not in any way limit the
+     * values that may be passed to {@link Gdk.Paintable.snapshot}.
+     *
+     * If the `paintable` does not have a preferred width, it returns 0.
+     * Negative values are never returned.
+     */
+    getIntrinsicWidth() {
+        return call("libgtk-4.so.1", "gdk_paintable_get_intrinsic_width", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their contents.
+     *
+     * Unless the contents are invalidated, implementations must guarantee that
+     * multiple calls of {@link Gdk.Paintable.snapshot} produce the same output.
+     *
+     * This function will emit the {@link Gdk.Paintable.:invalidate-contents}
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+     * it must not call this function.
+     */
+    invalidateContents() {
+        call("libgtk-4.so.1", "gdk_paintable_invalidate_contents", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Called by implementations of `GdkPaintable` to invalidate their size.
+     *
+     * As long as the size is not invalidated, `paintable` must return the same
+     * values for its intrinsic width, height and aspect ratio.
+     *
+     * This function will emit the {@link Gdk.Paintable.:invalidate-size}
+     * signal.
+     *
+     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+     * it must not call this function.
+     */
+    invalidateSize() {
+        call("libgtk-4.so.1", "gdk_paintable_invalidate_size", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Snapshots the given paintable with the given `width` and `height`.
+     *
+     * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+     * If `width` and `height` are not larger than zero, this function will
+     * do nothing.
+     * @param snapshot - a `GdkSnapshot` to snapshot to
+     * @param width - width to snapshot in
+     * @param height - height to snapshot in
+     */
+    snapshot(snapshot, width, height) {
+        call("libgtk-4.so.1", "gdk_paintable_snapshot", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "gobject", borrowed: true },
+                value: snapshot?.id ?? snapshot,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: width,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: height,
+            },
+        ], { type: "undefined" });
+    }
 }

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

@@ -141,6 +141,10 @@ const SIGNAL_META = {
         returnType: { type: "undefined" },
     },
     undo: { params: [], returnType: { type: "undefined" } },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class TextBuffer extends GObject.GObject {
     static glibTypeName = "GtkTextBuffer";
@@ -161,7 +165,7 @@ export class TextBuffer extends GObject.GObject {
                     value: table?.id ?? table,
                     optional: true,
                 },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -2135,20 +2139,24 @@ export class TextBuffer extends GObject.GObject {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
                 }
-                if (m.type === "boxed" && signalArgs[i] != null) {
-                    const cls = getNativeClass(m.innerType);
-                    return cls ? getNativeObject(signalArgs[i], cls) : signalArgs[i];
+                if (t?.type === "boxed" && callbackArgs[i] != null) {
+                    const cls = getNativeClass(t.innerType);
+                    return cls ? getNativeObject(callbackArgs[i], cls) : callbackArgs[i];
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gtk/text-child-anchor.d.ts

@@ -1,11 +1,6 @@
 import { Ref } from "@gtkx/native";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
-/**
- * Marks a spot in a `GtkTextBuffer` where child widgets can be “anchored”.
- *
- * The anchor can have multiple widgets anchored, to allow for multiple views.
- */
 export declare class TextChildAnchor extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

package/dist/generated/gtk/text-child-anchor.js

@@ -8,6 +8,12 @@ import * as GObject from "../gobject/index.js";
  *
  * The anchor can have multiple widgets anchored, to allow for multiple views.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TextChildAnchor extends GObject.GObject {
     static glibTypeName = "GtkTextChildAnchor";
     static objectType = "gobject";
@@ -27,7 +33,7 @@ export class TextChildAnchor extends GObject.GObject {
             setInstantiating(false);
             this.id = call("libgtk-4.so.1", "gtk_text_child_anchor_new", [], {
                 type: "gobject",
-                borrowed: true,
+                borrowed: false,
             });
         }
         else {
@@ -92,12 +98,26 @@ export class TextChildAnchor extends GObject.GObject {
         return ptrs.map((ptr) => getNativeObject(ptr));
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -1,40 +1,5 @@
 import { TextBuffer } from "./text-buffer.js";
 import * as GObject from "../gobject/index.js";
-/**
- * Marks a position in a `GtkTextbuffer` that is preserved
- * across modifications.
- *
- * 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.
- *
- * A `GtkTextMark` is like a bookmark in a text buffer; it preserves
- * a position in the text. You can convert the mark to an iterator using
- * {@link Gtk.TextBuffer.get_iter_at_mark}. Unlike iterators, marks remain
- * valid across buffer mutations, because their behavior is defined when
- * text is inserted or deleted. When text containing a mark is deleted,
- * the mark remains in the position originally occupied by the deleted
- * text. When text is inserted at a mark, a mark with “left gravity” will
- * be moved to the beginning of the newly-inserted text, and a mark with
- * “right gravity” will be moved to the end.
- *
- * Note that “left” and “right” here refer to logical direction (left
- * is the toward the start of the buffer); in some languages such as
- * Hebrew the logically-leftmost text is not actually on the left when
- * displayed.
- *
- * Marks are reference counted, but the reference count only controls
- * the validity of the memory; marks can be deleted from the buffer at
- * any time with {@link Gtk.TextBuffer.delete_mark}. Once deleted from
- * the buffer, a mark is essentially useless.
- *
- * Marks optionally have names; these can be convenient to avoid passing
- * the `GtkTextMark` object around.
- *
- * Marks are typically created using the {@link Gtk.TextBuffer.create_mark}
- * function.
- */
 export declare class TextMark extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";

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

@@ -38,6 +38,12 @@ import * as GObject from "../gobject/index.js";
  * Marks are typically created using the {@link Gtk.TextBuffer.create_mark}
  * function.
  */
+const SIGNAL_META = {
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
+};
 export class TextMark extends GObject.GObject {
     static glibTypeName = "GtkTextMark";
     static objectType = "gobject";
@@ -72,7 +78,7 @@ export class TextMark extends GObject.GObject {
                     type: { type: "boolean" },
                     value: leftGravity,
                 },
-            ], { type: "gobject", borrowed: true });
+            ], { type: "gobject", borrowed: false });
         }
         else {
             // @ts-ignore
@@ -170,12 +176,26 @@ export class TextMark extends GObject.GObject {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            return handler(self, ...args.slice(1));
+            const callbackArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
+                }
+                return callbackArgs[i];
+            });
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

package/dist/generated/gtk/text-tag-table.js

@@ -39,6 +39,10 @@ const SIGNAL_META = {
         params: [{ type: "gobject", borrowed: true }],
         returnType: { type: "undefined" },
     },
+    notify: {
+        params: [{ type: "gparam", borrowed: true }],
+        returnType: { type: "undefined" },
+    },
 };
 export class TextTagTable extends GObject.GObject {
     static glibTypeName = "GtkTextTagTable";
@@ -56,7 +60,7 @@ export class TextTagTable extends GObject.GObject {
             setInstantiating(false);
             this.id = call("libgtk-4.so.1", "gtk_text_tag_table_new", [], {
                 type: "gobject",
-                borrowed: true,
+                borrowed: false,
             });
         }
         else {
@@ -157,16 +161,20 @@ export class TextTagTable extends GObject.GObject {
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getNativeObject(args[0]);
-            const signalArgs = args.slice(1);
+            const callbackArgs = args.slice(1);
             if (!meta)
-                return handler(self, ...signalArgs);
-            const wrapped = meta.params.map((m, i) => {
-                if (m.type === "gobject" && signalArgs[i] != null) {
-                    return getNativeObject(signalArgs[i]);
+                return handler(self, ...callbackArgs);
+            const wrapped = meta.params.map((t, i) => {
+                if (t?.type === "gobject" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i]);
+                }
+                if (t?.type === "gparam" && callbackArgs[i] != null) {
+                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
                 }
-                return signalArgs[i];
+                return callbackArgs[i];
             });
-            return handler(self, ...wrapped);
+            const result = handler(self, ...wrapped);
+            return result;
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.id },

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

@@ -1,24 +1,4 @@
 import * as GObject from "../gobject/index.js";
-/**
- * Can be applied to text contained in 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.
- *
- * Tags should be in the {@link Gtk.TextTagTable} for a given
- * `GtkTextBuffer` before using them with that buffer.
- *
- * {@link Gtk.TextBuffer.create_tag} is the best way to create tags.
- * See “gtk4-demo” for numerous examples.
- *
- * For each property of `GtkTextTag`, there is a “set” property, e.g.
- * “font-set” corresponds to “font”. These “set” properties reflect
- * whether a property has been set or not.
- *
- * They are maintained by GTK and you should not set them independently.
- */
 export declare class TextTag extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";