@gtkx/ffi 0.1.14 → 0.1.16

package/dist/codegen/ffi-generator.js

@@ -436,7 +436,7 @@ export class CodeGenerator {
         }
         let signalMetaConstant = "";
         const { signals: allSignals, hasCrossNamespaceParent } = this.collectAllSignals(cls, classMap);
-        if (allSignals.length > 0 && !hasCrossNamespaceParent) {
+        if (allSignals.length > 0 || hasCrossNamespaceParent) {
             const hasConnectMethod = cls.methods.some((m) => toCamelCase(m.name) === "connect");
             const signalConnect = this.generateSignalConnect(sharedLibrary, allSignals, hasConnectMethod, classMap, className);
             signalMetaConstant = signalConnect.moduleLevel;
@@ -1180,7 +1180,7 @@ ${allArgs ? `${allArgs},` : ""}
                 const signalParamClass = this.extractSignalParamClass(param, classMap);
                 if (signalParamClass) {
                     this.signalClasses.add(signalParamClass);
-                    return `{ type: ${ffiType}, cls: ${signalParamClass} }`;
+                    return `{ type: ${ffiType}, getCls: () => ${signalParamClass} }`;
                 }
                 return `{ type: ${ffiType} }`;
             });
@@ -1219,29 +1219,32 @@ ${allArgs ? `${allArgs},` : ""}
         }
         signalOverloads.push(`  ${methodName}(signal: string, handler: (...args: any[]) => any, after?: boolean): number;`);
         this.usesType = true;
+        this.usesWrapPtr = true;
         if (signalMetadata.length > 0) {
-            this.usesWrapPtr = true;
             this.usesSignalMeta = true;
         }
-        const moduleLevel = signalMetadata.length > 0
-            ? `const SIGNAL_META: SignalMeta = {\n${signalMetadata.join(",\n")}\n};\n`
-            : "";
+        const moduleLevel = signalMetadata.length > 0 ? `const SIGNAL_META: SignalMeta = {\n${signalMetadata.join(",\n")}\n};\n` : "";
         const signalMapCode = signalMetadata.length > 0
             ? `const meta = SIGNAL_META[signal];
     const selfType: Type = { type: "gobject", borrowed: true };
     const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];`
-            : `const meta = undefined;\n    const selfType: Type = { type: "gobject", borrowed: true };\n    const argTypes = [selfType];`;
-        const wrapperCode = `const wrappedHandler = (...args: unknown[]) => {
+            : `const selfType: Type = { type: "gobject", borrowed: true };\n    const argTypes = [selfType];`;
+        const wrapperCode = signalMetadata.length > 0
+            ? `const wrappedHandler = (...args: unknown[]) => {
       const self = wrapPtr(args[0], ${className});
       const signalArgs = args.slice(1);
       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];
       });
       return handler(self, ...wrapped);
+    };`
+            : `const wrappedHandler = (...args: unknown[]) => {
+      const self = wrapPtr(args[0], ${className});
+      return handler(self, ...args.slice(1));
     };`;
         const overloadsSection = signalOverloads.length > 0 ? `${signalOverloads.join("\n")}\n` : "";
         const method = `${overloadsSection}  ${methodName}(

package/dist/generated/gdk/app-launch-context.d.ts

@@ -1,4 +1,5 @@
 import { Display } from "./display.js";
+import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 export declare class AppLaunchContext extends Gio.AppLaunchContext {
     constructor(...args: unknown[]);
@@ -8,4 +9,6 @@ export declare class AppLaunchContext extends Gio.AppLaunchContext {
     setIcon(icon?: Gio.Icon | null): void;
     setIconName(iconName?: string | null): void;
     setTimestamp(timestamp: number): void;
+    connect(signal: "notify", handler: (self: AppLaunchContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/app-launch-context.js

@@ -74,4 +74,18 @@ export class AppLaunchContext extends Gio.AppLaunchContext {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], AppLaunchContext);
+            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/gdk/cicp-params.d.ts

@@ -13,4 +13,6 @@ export declare class CicpParams extends GObject.GObject {
     setMatrixCoefficients(matrixCoefficients: number): void;
     setRange(range: CicpRange): void;
     setTransferFunction(transferFunction: number): void;
+    connect(signal: "notify", handler: (self: CicpParams, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/cicp-params.js

@@ -121,4 +121,18 @@ export class CicpParams 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], CicpParams);
+            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/gdk/clipboard.d.ts

@@ -19,4 +19,7 @@ export declare class Clipboard extends GObject.GObject {
     setContent(provider?: ContentProvider | null): boolean;
     setValue(value: GObject.Value): void;
     storeFinish(result: Gio.AsyncResult): boolean;
+    connect(signal: "changed", handler: (self: Clipboard) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Clipboard, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/clipboard.js

@@ -6,6 +6,9 @@ import { Display } from "./display.js";
 import { Texture } from "./texture.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+const SIGNAL_META = {
+    changed: [],
+};
 export class Clipboard extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -240,4 +243,28 @@ export class Clipboard extends GObject.GObject {
         }
         return _result;
     }
+    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], Clipboard);
+            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/gdk/content-deserializer.d.ts

@@ -15,4 +15,6 @@ export declare class ContentDeserializer extends GObject.GObject {
     returnError(error: GLib.GError): void;
     returnSuccess(): void;
     setTaskData(notify: () => void, data?: number | null): void;
+    connect(signal: "notify", handler: (self: ContentDeserializer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/content-deserializer.js

@@ -123,4 +123,18 @@ export class ContentDeserializer 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], ContentDeserializer);
+            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/gdk/content-provider.d.ts

@@ -14,4 +14,7 @@ export declare class ContentProvider extends GObject.GObject {
     refFormats(): ContentFormats;
     refStorableFormats(): ContentFormats;
     writeMimeTypeFinish(result: Gio.AsyncResult): boolean;
+    connect(signal: "content-changed", handler: (self: ContentProvider) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ContentProvider, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/content-provider.js

@@ -2,6 +2,9 @@ import { call } from "@gtkx/native";
 import { NativeError, wrapPtr } from "@gtkx/ffi";
 import { ContentFormats } from "./content-formats.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "content-changed": [],
+};
 export class ContentProvider extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -140,4 +143,28 @@ export class ContentProvider extends GObject.GObject {
         }
         return _result;
     }
+    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], ContentProvider);
+            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/gdk/content-serializer.d.ts

@@ -15,4 +15,6 @@ export declare class ContentSerializer extends GObject.GObject {
     returnError(error: GLib.GError): void;
     returnSuccess(): void;
     setTaskData(notify: () => void, data?: number | null): void;
+    connect(signal: "notify", handler: (self: ContentSerializer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/content-serializer.js

@@ -127,4 +127,18 @@ export class ContentSerializer 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], ContentSerializer);
+            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/gdk/cursor.d.ts

@@ -11,4 +11,6 @@ export declare class Cursor extends GObject.GObject {
     getHotspotY(): number;
     getName(): string | null;
     getTexture(): Texture | null;
+    connect(signal: "notify", handler: (self: Cursor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/cursor.js

@@ -107,4 +107,18 @@ export class Cursor extends GObject.GObject {
             return null;
         return wrapPtr(ptr, Texture);
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Cursor);
+            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/gdk/device-tool.d.ts

@@ -7,4 +7,6 @@ export declare class DeviceTool extends GObject.GObject {
     getHardwareId(): number;
     getSerial(): number;
     getToolType(): DeviceToolType;
+    connect(signal: "notify", handler: (self: DeviceTool, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/device-tool.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class DeviceTool extends GObject.GObject {
     constructor(...args) {
@@ -47,4 +48,18 @@ export class DeviceTool extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], DeviceTool);
+            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/gdk/device.d.ts

@@ -1,9 +1,9 @@
 import { Ref } from "@gtkx/native";
 import { InputSource, ModifierType } from "./enums.js";
-import { DeviceTool } from "./device-tool.js";
 import { Display } from "./display.js";
 import { Seat } from "./seat.js";
 import { Surface } from "./surface.js";
+import { DeviceTool } from "./device-tool.js";
 import * as GObject from "../gobject/index.js";
 import * as Pango from "../pango/index.js";
 export declare class Device extends GObject.GObject {
@@ -28,4 +28,8 @@ export declare class Device extends GObject.GObject {
     getTimestamp(): number;
     getVendorId(): string | null;
     hasBidiLayouts(): boolean;
+    connect(signal: "changed", handler: (self: Device) => void, after?: boolean): number;
+    connect(signal: "tool-changed", handler: (self: Device, tool: DeviceTool) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Device, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/device.js

@@ -1,10 +1,16 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
-import { DeviceTool } from "./device-tool.js";
 import { Display } from "./display.js";
 import { Seat } from "./seat.js";
 import { Surface } from "./surface.js";
+import { DeviceTool } from "./device-tool.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    changed: [],
+    "tool-changed": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => DeviceTool },
+    ],
+};
 export class Device extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -188,4 +194,28 @@ export class Device extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    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], Device);
+            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/gdk/display-manager.d.ts

@@ -8,4 +8,7 @@ export declare class DisplayManager extends GObject.GObject {
     listDisplays(): Display[];
     openDisplay(name?: string | null): Display | null;
     setDefaultDisplay(display: Display): void;
+    connect(signal: "display-opened", handler: (self: DisplayManager, display: Display) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DisplayManager, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/display-manager.js

@@ -2,6 +2,11 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { Display } from "./display.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "display-opened": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Display },
+    ],
+};
 export class DisplayManager extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -70,4 +75,28 @@ export class DisplayManager 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], DisplayManager);
+            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/gdk/display.d.ts

@@ -7,8 +7,8 @@ import { Device } from "./device.js";
 import { Event } from "./event.js";
 import type { GLContext } from "./glcontext.js";
 import { Monitor } from "./monitor.js";
-import { Seat } from "./seat.js";
 import { Surface } from "./surface.js";
+import { Seat } from "./seat.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 export declare class Display extends GObject.GObject {
@@ -44,4 +44,11 @@ export declare class Display extends GObject.GObject {
     supportsShadowWidth(): boolean;
     sync(): void;
     translateKey(keycode: number, state: ModifierType, group: number, keyval?: Ref<number> | null, effectiveGroup?: Ref<number> | null, level?: Ref<number> | null, consumed?: Ref<ModifierType> | null): boolean;
+    connect(signal: "closed", handler: (self: Display, isError: boolean) => void, after?: boolean): number;
+    connect(signal: "opened", handler: (self: Display) => void, after?: boolean): number;
+    connect(signal: "seat-added", handler: (self: Display, seat: Seat) => void, after?: boolean): number;
+    connect(signal: "seat-removed", handler: (self: Display, seat: Seat) => void, after?: boolean): number;
+    connect(signal: "setting-changed", handler: (self: Display, setting: string) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Display, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/display.js

@@ -7,6 +7,17 @@ import { Monitor } from "./monitor.js";
 import { Seat } from "./seat.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+const SIGNAL_META = {
+    closed: [{ type: { type: "boolean" } }],
+    opened: [],
+    "seat-added": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Seat },
+    ],
+    "seat-removed": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Seat },
+    ],
+    "setting-changed": [{ type: { type: "string", borrowed: false } }],
+};
 export class Display extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -420,4 +431,28 @@ export class Display extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    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], Display);
+            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/gdk/dmabuf-texture-builder.d.ts

@@ -33,4 +33,6 @@ export declare class DmabufTextureBuilder extends GObject.GObject {
     setUpdateRegion(region?: cairo.Region | null): void;
     setUpdateTexture(texture?: Texture | null): void;
     setWidth(width: number): void;
+    connect(signal: "notify", handler: (self: DmabufTextureBuilder, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/dmabuf-texture-builder.js

@@ -361,4 +361,18 @@ export class DmabufTextureBuilder 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], DmabufTextureBuilder);
+            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/gdk/drag.d.ts

@@ -1,4 +1,4 @@
-import { DragAction } from "./enums.js";
+import { DragAction, DragCancelReason } from "./enums.js";
 import { ContentFormats } from "./content-formats.js";
 import { ContentProvider } from "./content-provider.js";
 import { Device } from "./device.js";
@@ -19,4 +19,9 @@ export declare class Drag extends GObject.GObject {
     getSelectedAction(): DragAction;
     getSurface(): Surface;
     setHotspot(hotX: number, hotY: number): void;
+    connect(signal: "cancel", handler: (self: Drag, reason: DragCancelReason) => void, after?: boolean): number;
+    connect(signal: "dnd-finished", handler: (self: Drag) => void, after?: boolean): number;
+    connect(signal: "drop-performed", handler: (self: Drag) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Drag, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/drag.js

@@ -6,6 +6,11 @@ import { Device } from "./device.js";
 import { Display } from "./display.js";
 import { Surface } from "./surface.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    cancel: [{ type: { type: "int", size: 32, unsigned: false } }],
+    "dnd-finished": [],
+    "drop-performed": [],
+};
 export class Drag extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -155,4 +160,28 @@ export class Drag 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], Drag);
+            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/gdk/draw-context.d.ts

@@ -11,4 +11,6 @@ export declare class DrawContext extends GObject.GObject {
     getFrameRegion(): cairo.Region | null;
     getSurface(): Surface | null;
     isInFrame(): boolean;
+    connect(signal: "notify", handler: (self: DrawContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/draw-context.js

@@ -89,4 +89,18 @@ export class DrawContext extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], DrawContext);
+            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/gdk/drop.d.ts

@@ -20,4 +20,6 @@ export declare class Drop extends GObject.GObject {
     readFinish(result: Gio.AsyncResult, outMimeType: Ref<string>): Gio.InputStream | null;
     readValueFinish(result: Gio.AsyncResult): GObject.Value;
     status(actions: DragAction, preferred: DragAction): void;
+    connect(signal: "notify", handler: (self: Drop, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }