@gtkx/ffi 0.1.14 → 0.1.16

package/dist/generated/gtk/directory-list.d.ts

@@ -15,4 +15,6 @@ export declare class DirectoryList extends GObject.GObject {
     setFile(file?: Gio.File | null): void;
     setIoPriority(ioPriority: number): void;
     setMonitored(monitored: boolean): void;
+    connect(signal: "notify", handler: (self: DirectoryList, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/directory-list.js

@@ -127,4 +127,18 @@ export class DirectoryList 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], DirectoryList);
+            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/drag-icon.d.ts

@@ -16,4 +16,6 @@ export declare class DragIcon extends Widget {
     getSurfaceTransform(x: Ref<number>, y: Ref<number>): void;
     getFocus(): Widget | null;
     setFocus(focus?: Widget | null): void;
+    connect(signal: "notify", handler: (self: DragIcon, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/drag-icon.js

@@ -128,4 +128,18 @@ export class DragIcon 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], DragIcon);
+            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/drag-source.js

@@ -135,8 +135,8 @@ export class DragSource extends GestureSingle {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/drawing-area.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class DrawingArea extends Widget {
     constructor(...args: unknown[]);
@@ -7,4 +8,7 @@ export declare class DrawingArea extends Widget {
     setContentHeight(height: number): void;
     setContentWidth(width: number): void;
     setDrawFunc(destroy: () => void, drawFunc?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    connect(signal: "resize", handler: (self: DrawingArea, width: number, height: number) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DrawingArea, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/drawing-area.js

@@ -1,5 +1,12 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    resize: [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+};
 export class DrawingArea extends Widget {
     constructor(...args) {
         super(...args);
@@ -70,4 +77,28 @@ export class DrawingArea 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], DrawingArea);
+            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/drop-controller-motion.js

@@ -60,8 +60,8 @@ export class DropControllerMotion extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/drop-down.d.ts

@@ -28,4 +28,7 @@ export declare class DropDown extends Widget {
     setSearchMatchMode(searchMatchMode: StringFilterMatchMode): void;
     setSelected(position: number): void;
     setShowArrow(showArrow: boolean): void;
+    connect(signal: "activate", handler: (self: DropDown) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DropDown, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/drop-down.js

@@ -5,6 +5,9 @@ import { ListItemFactory } from "./list-item-factory.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [],
+};
 export class DropDown extends Widget {
     constructor(...args) {
         super(...args);
@@ -237,4 +240,28 @@ export class DropDown 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], DropDown);
+            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/drop-target-async.js

@@ -116,8 +116,8 @@ export class DropTargetAsync extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/drop-target.js

@@ -183,8 +183,8 @@ export class DropTarget extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/editable-label.d.ts

@@ -1,6 +1,7 @@
 import { Ref } from "@gtkx/native";
 import { AccessiblePlatformState } from "./enums.js";
 import { Editable } from "./editable.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class EditableLabel extends Widget {
     constructor(str: string);
@@ -33,4 +34,6 @@ export declare class EditableLabel extends Widget {
     setPosition(position: number): void;
     setText(text: string): void;
     setWidthChars(nChars: number): void;
+    connect(signal: "notify", handler: (self: EditableLabel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/editable-label.js

@@ -323,4 +323,18 @@ export class EditableLabel 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], EditableLabel);
+            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/emoji-chooser.d.ts

@@ -1,5 +1,11 @@
+import * as GObject from "../gobject/index.js";
 import { Popover } from "./popover.js";
 export declare class EmojiChooser extends Popover {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "emoji-picked", handler: (self: EmojiChooser, text: string) => void, after?: boolean): number;
+    connect(signal: "activate-default", handler: (self: EmojiChooser) => void, after?: boolean): number;
+    connect(signal: "closed", handler: (self: EmojiChooser) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EmojiChooser, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/emoji-chooser.js

@@ -1,5 +1,11 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Popover } from "./popover.js";
+const SIGNAL_META = {
+    "emoji-picked": [{ type: { type: "string", borrowed: false } }],
+    "activate-default": [],
+    closed: [],
+};
 export class EmojiChooser extends Popover {
     constructor(...args) {
         super(...args);
@@ -10,4 +16,28 @@ export class EmojiChooser extends Popover {
             borrowed: true,
         });
     }
+    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], EmojiChooser);
+            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/entry-buffer.d.ts

@@ -13,4 +13,8 @@ export declare class EntryBuffer extends GObject.GObject {
     insertText(position: number, chars: string, nChars: number): number;
     setMaxLength(maxLength: number): void;
     setText(chars: string, nChars: number): void;
+    connect(signal: "deleted-text", handler: (self: EntryBuffer, position: number, nChars: number) => void, after?: boolean): number;
+    connect(signal: "inserted-text", handler: (self: EntryBuffer, position: number, chars: string, nChars: number) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EntryBuffer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,5 +1,17 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "deleted-text": [
+        { type: { type: "int", size: 32, unsigned: true } },
+        { type: { type: "int", size: 32, unsigned: true } },
+    ],
+    "inserted-text": [
+        { type: { type: "int", size: 32, unsigned: true } },
+        { type: { type: "string", borrowed: false } },
+        { type: { type: "int", size: 32, unsigned: true } },
+    ],
+};
 export class EntryBuffer extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -149,4 +161,28 @@ export class EntryBuffer 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], EntryBuffer);
+            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/entry-completion.d.ts

@@ -1,3 +1,4 @@
+import { TreeIter } from "./tree-iter.js";
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
@@ -39,4 +40,10 @@ export declare class EntryCompletion extends GObject.GObject {
     packStart(cell: CellRenderer, expand: boolean): void;
     reorder(cell: CellRenderer, position: number): void;
     setCellDataFunc(cell: CellRenderer, destroy: () => void, func?: (...args: unknown[]) => unknown | null, funcData?: number | null): void;
+    connect(signal: "cursor-on-match", handler: (self: EntryCompletion, model: TreeModel, iter: TreeIter) => boolean, after?: boolean): number;
+    connect(signal: "insert-prefix", handler: (self: EntryCompletion, prefix: string) => boolean, after?: boolean): number;
+    connect(signal: "match-selected", handler: (self: EntryCompletion, model: TreeModel, iter: TreeIter) => boolean, after?: boolean): number;
+    connect(signal: "no-matches", handler: (self: EntryCompletion) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EntryCompletion, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/entry-completion.js

@@ -4,6 +4,18 @@ import { CellArea } from "./cell-area.js";
 import { TreeModel } from "./tree-model.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "cursor-on-match": [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+    ],
+    "insert-prefix": [{ type: { type: "string", borrowed: false } }],
+    "match-selected": [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+    ],
+    "no-matches": [],
+};
 export class EntryCompletion extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -390,4 +402,28 @@ export class EntryCompletion 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], EntryCompletion);
+            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/entry.d.ts

@@ -3,6 +3,7 @@ import { AccessiblePlatformState, EntryIconPosition, ImageType, InputHints, Inpu
 import { Editable } from "./editable.js";
 import { EntryBuffer } from "./entry-buffer.js";
 import { EntryCompletion } from "./entry-completion.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
@@ -96,4 +97,9 @@ export declare class Entry extends Widget {
     setPosition(position: number): void;
     setText(text: string): void;
     setWidthChars(nChars: number): void;
+    connect(signal: "activate", handler: (self: Entry) => void, after?: boolean): number;
+    connect(signal: "icon-press", handler: (self: Entry, iconPos: EntryIconPosition) => void, after?: boolean): number;
+    connect(signal: "icon-release", handler: (self: Entry, iconPos: EntryIconPosition) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Entry, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/entry.js

@@ -7,6 +7,11 @@ import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [],
+    "icon-press": [{ type: { type: "int", size: 32, unsigned: false } }],
+    "icon-release": [{ type: { type: "int", size: 32, unsigned: false } }],
+};
 export class Entry extends Widget {
     constructor(...args) {
         super(...args);
@@ -1034,4 +1039,28 @@ export class Entry 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], Entry);
+            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/event-controller-focus.js

@@ -41,8 +41,8 @@ export class EventControllerFocus extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/event-controller-key.js

@@ -79,8 +79,8 @@ export class EventControllerKey extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/event-controller-legacy.js

@@ -24,8 +24,8 @@ export class EventControllerLegacy extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/event-controller-motion.js

@@ -48,8 +48,8 @@ export class EventControllerMotion extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/event-controller-scroll.js

@@ -64,8 +64,8 @@ export class EventControllerScroll extends EventController {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
                 }
                 return signalArgs[i];
             });

package/dist/generated/gtk/event-controller.d.ts

@@ -18,4 +18,6 @@ export declare class EventController extends GObject.GObject {
     setPropagationLimit(limit: PropagationLimit): void;
     setPropagationPhase(phase: PropagationPhase): void;
     setStaticName(name?: string | null): void;
+    connect(signal: "notify", handler: (self: EventController, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/event-controller.js

@@ -147,4 +147,18 @@ export class EventController 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], EventController);
+            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/every-filter.d.ts

@@ -1,5 +1,8 @@
+import * as GObject from "../gobject/index.js";
 import { MultiFilter } from "./multi-filter.js";
 export declare class EveryFilter extends MultiFilter {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: EveryFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/every-filter.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { MultiFilter } from "./multi-filter.js";
 export class EveryFilter extends MultiFilter {
     constructor(...args) {
@@ -10,4 +11,18 @@ export class EveryFilter extends MultiFilter {
             borrowed: false,
         });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], EveryFilter);
+            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/expander.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Expander extends Widget {
     constructor(label?: string | null);
@@ -18,4 +19,7 @@ export declare class Expander extends Widget {
     setResizeToplevel(resizeToplevel: boolean): void;
     setUseMarkup(useMarkup: boolean): void;
     setUseUnderline(useUnderline: boolean): void;
+    connect(signal: "activate", handler: (self: Expander) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Expander, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }