@gtkx/ffi 0.1.14 → 0.1.16

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

@@ -1,7 +1,8 @@
 import { Ref } from "@gtkx/native";
-import { AccessiblePlatformState, AccessibleTextContentChange, InputHints, InputPurpose } from "./enums.js";
+import { AccessiblePlatformState, AccessibleTextContentChange, DeleteType, InputHints, InputPurpose, MovementStep } from "./enums.js";
 import { Editable } from "./editable.js";
 import { EntryBuffer } from "./entry-buffer.js";
+import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import * as Graphene from "../graphene/index.js";
 import * as Pango from "../pango/index.js";
@@ -71,4 +72,17 @@ export declare class Text extends Widget {
     setPosition(position: number): void;
     setText(text: string): void;
     setWidthChars(nChars: number): void;
+    connect(signal: "activate", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "backspace", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "copy-clipboard", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "cut-clipboard", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "delete-from-cursor", handler: (self: Text, type: DeleteType, count: number) => void, after?: boolean): number;
+    connect(signal: "insert-at-cursor", handler: (self: Text, string: string) => void, after?: boolean): number;
+    connect(signal: "insert-emoji", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "move-cursor", handler: (self: Text, step: MovementStep, count: number, extend: boolean) => void, after?: boolean): number;
+    connect(signal: "paste-clipboard", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "preedit-changed", handler: (self: Text, preedit: string) => void, after?: boolean): number;
+    connect(signal: "toggle-overwrite", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Text, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/text.js

@@ -5,6 +5,26 @@ import { EntryBuffer } from "./entry-buffer.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [],
+    backspace: [],
+    "copy-clipboard": [],
+    "cut-clipboard": [],
+    "delete-from-cursor": [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    "insert-at-cursor": [{ type: { type: "string", borrowed: false } }],
+    "insert-emoji": [],
+    "move-cursor": [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "boolean" } },
+    ],
+    "paste-clipboard": [],
+    "preedit-changed": [{ type: { type: "string", borrowed: false } }],
+    "toggle-overwrite": [],
+};
 export class Text extends Widget {
     constructor(...args) {
         super(...args);
@@ -726,4 +746,28 @@ export class Text extends Widget {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Text);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/toggle-button.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { Button } from "./button.js";
 export declare class ToggleButton extends Button {
     constructor(...args: unknown[]);
@@ -8,4 +9,9 @@ export declare class ToggleButton extends Button {
     setActive(isActive: boolean): void;
     setGroup(group?: ToggleButton | null): void;
     toggled(): void;
+    connect(signal: "toggled", handler: (self: ToggleButton) => void, after?: boolean): number;
+    connect(signal: "activate", handler: (self: ToggleButton) => void, after?: boolean): number;
+    connect(signal: "clicked", handler: (self: ToggleButton) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ToggleButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/toggle-button.js

@@ -1,6 +1,11 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { Button } from "./button.js";
+const SIGNAL_META = {
+    toggled: [],
+    activate: [],
+    clicked: [],
+};
 export class ToggleButton extends Button {
     constructor(...args) {
         super(...args);
@@ -69,4 +74,28 @@ export class ToggleButton extends Button {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], ToggleButton);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tooltip.d.ts

@@ -12,4 +12,6 @@ export declare class Tooltip extends GObject.GObject {
     setMarkup(markup?: string | null): void;
     setText(text?: string | null): void;
     setTipArea(rect: Gdk.Rectangle): void;
+    connect(signal: "notify", handler: (self: Tooltip, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tooltip.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class Tooltip extends GObject.GObject {
     constructor(...args) {
@@ -103,4 +104,18 @@ export class Tooltip extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Tooltip);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-expander.d.ts

@@ -15,4 +15,6 @@ export declare class TreeExpander extends Widget {
     setIndentForDepth(indentForDepth: boolean): void;
     setIndentForIcon(indentForIcon: boolean): void;
     setListRow(listRow?: TreeListRow | null): void;
+    connect(signal: "notify", handler: (self: TreeExpander, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-expander.js

@@ -130,4 +130,18 @@ export class TreeExpander extends Widget {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeExpander);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-list-model.d.ts

@@ -11,4 +11,6 @@ export declare class TreeListModel extends GObject.GObject {
     getPassthrough(): boolean;
     getRow(position: number): TreeListRow | null;
     setAutoexpand(autoexpand: boolean): void;
+    connect(signal: "notify", handler: (self: TreeListModel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-list-model.js

@@ -103,4 +103,18 @@ export class TreeListModel extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeListModel);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-list-row-sorter.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
 export declare class TreeListRowSorter extends Sorter {
     constructor(sorter?: Sorter | null);
@@ -5,4 +6,6 @@ export declare class TreeListRowSorter extends Sorter {
     protected createPtr(args: unknown[]): unknown;
     getSorter(): Sorter | null;
     setSorter(sorter?: Sorter | null): void;
+    connect(signal: "notify", handler: (self: TreeListRowSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-list-row-sorter.js

@@ -37,4 +37,18 @@ export class TreeListRowSorter extends Sorter {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeListRowSorter);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-list-row.d.ts

@@ -12,4 +12,6 @@ export declare class TreeListRow extends GObject.GObject {
     getPosition(): number;
     isExpandable(): boolean;
     setExpanded(expanded: boolean): void;
+    connect(signal: "notify", handler: (self: TreeListRow, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-list-row.js

@@ -109,4 +109,18 @@ export class TreeListRow extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeListRow);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-model-filter.d.ts

@@ -46,4 +46,6 @@ export declare class TreeModelFilter extends GObject.GObject {
     rowInserted(path: TreePath, iter: TreeIter): void;
     rowsReorderedWithLength(path: TreePath, newOrder: number[], length: number, iter?: TreeIter | null): void;
     unrefNode(iter: TreeIter): void;
+    connect(signal: "notify", handler: (self: TreeModelFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-model-filter.js

@@ -763,4 +763,18 @@ export class TreeModelFilter extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeModelFilter);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-model-sort.d.ts

@@ -51,4 +51,6 @@ export declare class TreeModelSort extends GObject.GObject {
     setSortColumnId(sortColumnId: number, order: SortType): void;
     setSortFunc(sortColumnId: number, sortFunc: (...args: unknown[]) => unknown, userData?: number | null, destroy?: () => void | null): void;
     sortColumnChanged(): void;
+    connect(signal: "notify", handler: (self: TreeModelSort, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-model-sort.js

@@ -812,4 +812,18 @@ export class TreeModelSort extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeModelSort);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-selection.d.ts

@@ -26,4 +26,7 @@ export declare class TreeSelection extends GObject.GObject {
     unselectIter(iter: TreeIter): void;
     unselectPath(path: TreePath): void;
     unselectRange(startPath: TreePath, endPath: TreePath): void;
+    connect(signal: "changed", handler: (self: TreeSelection) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: TreeSelection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-selection.js

@@ -2,6 +2,9 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { TreeView } from "./tree-view.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    changed: [],
+};
 export class TreeSelection extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -292,4 +295,28 @@ export class TreeSelection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeSelection);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-store.d.ts

@@ -63,4 +63,6 @@ export declare class TreeStore extends GObject.GObject {
     setSortColumnId(sortColumnId: number, order: SortType): void;
     setSortFunc(sortColumnId: number, sortFunc: (...args: unknown[]) => unknown, userData?: number | null, destroy?: () => void | null): void;
     sortColumnChanged(): void;
+    connect(signal: "notify", handler: (self: TreeStore, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-store.js

@@ -1165,4 +1165,18 @@ export class TreeStore extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeStore);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/tree-view-column.d.ts

@@ -63,4 +63,7 @@ export declare class TreeViewColumn extends GObject.InitiallyUnowned {
     getArea(): CellArea | null;
     getCells(): CellRenderer[];
     reorder(cell: CellRenderer, position: number): void;
+    connect(signal: "clicked", handler: (self: TreeViewColumn) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: TreeViewColumn, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-view-column.js

@@ -3,6 +3,9 @@ import { wrapPtr } from "@gtkx/ffi";
 import { CellArea } from "./cell-area.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    clicked: [],
+};
 export class TreeViewColumn extends GObject.InitiallyUnowned {
     constructor(...args) {
         super(...args);
@@ -646,4 +649,28 @@ export class TreeViewColumn extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeViewColumn);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -1,5 +1,5 @@
 import { Ref } from "@gtkx/native";
-import { ScrollablePolicy, TreeViewDropPosition, TreeViewGridLines } from "./enums.js";
+import { MovementStep, ScrollablePolicy, TreeViewDropPosition, TreeViewGridLines } from "./enums.js";
 import { Border } from "./border.js";
 import { TreeIter } from "./tree-iter.js";
 import { TreePath } from "./tree-path.js";
@@ -10,6 +10,7 @@ import { Tooltip } from "./tooltip.js";
 import { TreeModel } from "./tree-model.js";
 import { TreeSelection } from "./tree-selection.js";
 import { TreeViewColumn } from "./tree-view-column.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class TreeView extends Widget {
@@ -109,4 +110,21 @@ export declare class TreeView extends Widget {
     setHscrollPolicy(policy: ScrollablePolicy): void;
     setVadjustment(vadjustment?: Adjustment | null): void;
     setVscrollPolicy(policy: ScrollablePolicy): void;
+    connect(signal: "columns-changed", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "cursor-changed", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "expand-collapse-cursor-row", handler: (self: TreeView, object: boolean, p0: boolean, p1: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-cursor", handler: (self: TreeView, step: MovementStep, direction: number, extend: boolean, modify: boolean) => boolean, after?: boolean): number;
+    connect(signal: "row-activated", handler: (self: TreeView, path: TreePath, column: TreeViewColumn) => void, after?: boolean): number;
+    connect(signal: "row-collapsed", handler: (self: TreeView, iter: TreeIter, path: TreePath) => void, after?: boolean): number;
+    connect(signal: "row-expanded", handler: (self: TreeView, iter: TreeIter, path: TreePath) => void, after?: boolean): number;
+    connect(signal: "select-all", handler: (self: TreeView) => boolean, after?: boolean): number;
+    connect(signal: "select-cursor-parent", handler: (self: TreeView) => boolean, after?: boolean): number;
+    connect(signal: "select-cursor-row", handler: (self: TreeView, object: boolean) => boolean, after?: boolean): number;
+    connect(signal: "start-interactive-search", handler: (self: TreeView) => boolean, after?: boolean): number;
+    connect(signal: "test-collapse-row", handler: (self: TreeView, iter: TreeIter, path: TreePath) => boolean, after?: boolean): number;
+    connect(signal: "test-expand-row", handler: (self: TreeView, iter: TreeIter, path: TreePath) => boolean, after?: boolean): number;
+    connect(signal: "toggle-cursor-row", handler: (self: TreeView) => boolean, after?: boolean): number;
+    connect(signal: "unselect-all", handler: (self: TreeView) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: TreeView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -7,6 +7,50 @@ import { TreeSelection } from "./tree-selection.js";
 import { TreeViewColumn } from "./tree-view-column.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    "columns-changed": [],
+    "cursor-changed": [],
+    "expand-collapse-cursor-row": [
+        { type: { type: "boolean" } },
+        { type: { type: "boolean" } },
+        { type: { type: "boolean" } },
+    ],
+    "move-cursor": [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "boolean" } },
+        { type: { type: "boolean" } },
+    ],
+    "row-activated": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreePath" } },
+        {
+            type: { type: "gobject", borrowed: false },
+            getCls: () => TreeViewColumn,
+        },
+    ],
+    "row-collapsed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreePath" } },
+    ],
+    "row-expanded": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreePath" } },
+    ],
+    "select-all": [],
+    "select-cursor-parent": [],
+    "select-cursor-row": [{ type: { type: "boolean" } }],
+    "start-interactive-search": [],
+    "test-collapse-row": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreePath" } },
+    ],
+    "test-expand-row": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreePath" } },
+    ],
+    "toggle-cursor-row": [],
+    "unselect-all": [],
+};
 export class TreeView extends Widget {
     constructor(...args) {
         super(...args);
@@ -1534,4 +1578,28 @@ export class TreeView extends Widget {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], TreeView);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/uri-launcher.d.ts

@@ -9,4 +9,6 @@ export declare class UriLauncher extends GObject.GObject {
     getUri(): string | null;
     launch(parent?: Window, cancellable?: Gio.Cancellable): Promise<boolean>;
     setUri(uri?: string | null): void;
+    connect(signal: "notify", handler: (self: UriLauncher, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/uri-launcher.js

@@ -1,5 +1,5 @@
 import { call } from "@gtkx/native";
-import { NativeError } from "@gtkx/ffi";
+import { NativeError, wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class UriLauncher extends GObject.GObject {
     constructor(...args) {
@@ -97,4 +97,18 @@ export class UriLauncher extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], UriLauncher);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/video.d.ts

@@ -1,5 +1,6 @@
 import { GraphicsOffloadEnabled } from "./enums.js";
 import { MediaStream } from "./media-stream.js";
+import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
 export declare class Video extends Widget {
@@ -21,4 +22,6 @@ export declare class Video extends Widget {
     setLoop(loop: boolean): void;
     setMediaStream(stream?: MediaStream | null): void;
     setResource(resourcePath?: string | null): void;
+    connect(signal: "notify", handler: (self: Video, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }