@gtkx/ffi 0.1.15 → 0.1.17

package/dist/generated/gdk/drop.js

@@ -177,4 +177,18 @@ export class Drop 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], Drop);
+            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/frame-clock.d.ts

@@ -15,4 +15,13 @@ export declare class FrameClock extends GObject.GObject {
     getRefreshInfo(baseTime: number, presentationTimeReturn: Ref<number>, refreshIntervalReturn?: Ref<number> | null): void;
     getTimings(frameCounter: number): FrameTimings | null;
     requestPhase(phase: FrameClockPhase): void;
+    connect(signal: "after-paint", handler: (self: FrameClock) => void, after?: boolean): number;
+    connect(signal: "before-paint", handler: (self: FrameClock) => void, after?: boolean): number;
+    connect(signal: "flush-events", handler: (self: FrameClock) => void, after?: boolean): number;
+    connect(signal: "layout", handler: (self: FrameClock) => void, after?: boolean): number;
+    connect(signal: "paint", handler: (self: FrameClock) => void, after?: boolean): number;
+    connect(signal: "resume-events", handler: (self: FrameClock) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: FrameClock) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: FrameClock, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/frame-clock.js

@@ -2,6 +2,15 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { FrameTimings } from "./frame-timings.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "after-paint": [],
+    "before-paint": [],
+    "flush-events": [],
+    layout: [],
+    paint: [],
+    "resume-events": [],
+    update: [],
+};
 export class FrameClock extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -139,4 +148,28 @@ export class FrameClock 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], FrameClock);
+            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/gltexture-builder.d.ts

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

package/dist/generated/gdk/gltexture-builder.js

@@ -260,4 +260,18 @@ export class GLTextureBuilder 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], GLTextureBuilder);
+            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/memory-texture-builder.d.ts

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

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

@@ -273,4 +273,18 @@ export class MemoryTextureBuilder 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], MemoryTextureBuilder);
+            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/monitor.d.ts

@@ -19,4 +19,7 @@ export declare class Monitor extends GObject.GObject {
     getSubpixelLayout(): SubpixelLayout;
     getWidthMm(): number;
     isValid(): boolean;
+    connect(signal: "invalidate", handler: (self: Monitor) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Monitor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/monitor.js

@@ -2,6 +2,9 @@ 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 = {
+    invalidate: [],
+};
 export class Monitor extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -133,4 +136,28 @@ export class Monitor 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], Monitor);
+            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/seat.d.ts

@@ -1,7 +1,7 @@
 import { SeatCapabilities } from "./enums.js";
+import { Display } from "./display.js";
 import { Device } from "./device.js";
 import { DeviceTool } from "./device-tool.js";
-import { Display } from "./display.js";
 import * as GObject from "../gobject/index.js";
 export declare class Seat extends GObject.GObject {
     constructor(...args: unknown[]);
@@ -12,4 +12,10 @@ export declare class Seat extends GObject.GObject {
     getKeyboard(): Device | null;
     getPointer(): Device | null;
     getTools(): DeviceTool[];
+    connect(signal: "device-added", handler: (self: Seat, device: Device) => void, after?: boolean): number;
+    connect(signal: "device-removed", handler: (self: Seat, device: Device) => void, after?: boolean): number;
+    connect(signal: "tool-added", handler: (self: Seat, tool: DeviceTool) => void, after?: boolean): number;
+    connect(signal: "tool-removed", handler: (self: Seat, tool: DeviceTool) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Seat, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/seat.js

@@ -1,8 +1,23 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
-import { Device } from "./device.js";
 import { Display } from "./display.js";
+import { Device } from "./device.js";
+import { DeviceTool } from "./device-tool.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "device-added": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Device },
+    ],
+    "device-removed": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Device },
+    ],
+    "tool-added": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => DeviceTool },
+    ],
+    "tool-removed": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => DeviceTool },
+    ],
+};
 export class Seat extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -77,4 +92,28 @@ export class Seat extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "gobject" } });
     }
+    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], Seat);
+            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/snapshot.d.ts

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

package/dist/generated/gdk/snapshot.js

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

@@ -7,6 +7,8 @@ import { Display } from "./display.js";
 import { FrameClock } from "./frame-clock.js";
 import type { GLContext } from "./glcontext.js";
 import type { VulkanContext } from "./vulkan-context.js";
+import { Event } from "./event.js";
+import { Monitor } from "./monitor.js";
 import * as GObject from "../gobject/index.js";
 import * as cairo from "../cairo/index.js";
 export declare class Surface extends GObject.GObject {
@@ -39,4 +41,11 @@ export declare class Surface extends GObject.GObject {
     setInputRegion(region?: cairo.Region | null): void;
     setOpaqueRegion(region?: cairo.Region | null): void;
     translateCoordinates(to: Surface, x: Ref<number>, y: Ref<number>): boolean;
+    connect(signal: "enter-monitor", handler: (self: Surface, monitor: Monitor) => void, after?: boolean): number;
+    connect(signal: "event", handler: (self: Surface, event: Event) => boolean, after?: boolean): number;
+    connect(signal: "layout", handler: (self: Surface, width: number, height: number) => void, after?: boolean): number;
+    connect(signal: "leave-monitor", handler: (self: Surface, monitor: Monitor) => void, after?: boolean): number;
+    connect(signal: "render", handler: (self: Surface, region: cairo.Region) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Surface, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/surface.js

@@ -3,8 +3,26 @@ import { NativeError, wrapPtr } from "@gtkx/ffi";
 import { Cursor } from "./cursor.js";
 import { Display } from "./display.js";
 import { FrameClock } from "./frame-clock.js";
+import { Event } from "./event.js";
+import { Monitor } from "./monitor.js";
 import * as GObject from "../gobject/index.js";
 import * as cairo from "../cairo/index.js";
+const SIGNAL_META = {
+    "enter-monitor": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Monitor },
+    ],
+    event: [{ type: { type: "gobject", borrowed: false }, getCls: () => Event }],
+    layout: [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    "leave-monitor": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Monitor },
+    ],
+    render: [
+        { type: { type: "boxed", borrowed: false, innerType: "CairoRegion" } },
+    ],
+};
 export class Surface extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -353,4 +371,28 @@ export class Surface 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], Surface);
+            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/texture.d.ts

@@ -33,4 +33,6 @@ export declare class Texture extends GObject.GObject {
     invalidateContents(): void;
     invalidateSize(): void;
     snapshot(snapshot: Snapshot, width: number, height: number): void;
+    connect(signal: "notify", handler: (self: Texture, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdk/texture.js

@@ -271,4 +271,18 @@ export class Texture 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], Texture);
+            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/vulkan-context.js

@@ -29,8 +29,8 @@ export class VulkanContext extends DrawContext {
             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/gdkpixbuf/pixbuf-animation-iter.d.ts

@@ -7,4 +7,6 @@ export declare class PixbufAnimationIter extends GObject.GObject {
     getDelayTime(): number;
     getPixbuf(): Pixbuf;
     onCurrentlyLoadingFrame(): boolean;
+    connect(signal: "notify", handler: (self: PixbufAnimationIter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.js

@@ -50,4 +50,18 @@ export class PixbufAnimationIter 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], PixbufAnimationIter);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgdk_pixbuf-2.0.so.0", "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/gdkpixbuf/pixbuf-animation.d.ts

@@ -15,4 +15,6 @@ export declare class PixbufAnimation extends GObject.GObject {
     getStaticImage(): Pixbuf;
     getWidth(): number;
     isStaticImage(): boolean;
+    connect(signal: "notify", handler: (self: PixbufAnimation, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdkpixbuf/pixbuf-animation.js

@@ -114,4 +114,18 @@ export class PixbufAnimation 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], PixbufAnimation);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgdk_pixbuf-2.0.so.0", "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/gdkpixbuf/pixbuf-loader.d.ts

@@ -15,4 +15,10 @@ export declare class PixbufLoader extends GObject.GObject {
     setSize(width: number, height: number): void;
     write(buf: number[], count: number): boolean;
     writeBytes(buffer: GLib.Bytes): boolean;
+    connect(signal: "area-prepared", handler: (self: PixbufLoader) => void, after?: boolean): number;
+    connect(signal: "area-updated", handler: (self: PixbufLoader, x: number, y: number, width: number, height: number) => void, after?: boolean): number;
+    connect(signal: "closed", handler: (self: PixbufLoader) => void, after?: boolean): number;
+    connect(signal: "size-prepared", handler: (self: PixbufLoader, width: number, height: number) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: PixbufLoader, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdkpixbuf/pixbuf-loader.js

@@ -4,6 +4,20 @@ import { PixbufFormat } from "./pixbuf-format.js";
 import { Pixbuf } from "./pixbuf.js";
 import { PixbufAnimation } from "./pixbuf-animation.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "area-prepared": [],
+    "area-updated": [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    closed: [],
+    "size-prepared": [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+};
 export class PixbufLoader extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -177,4 +191,28 @@ export class PixbufLoader 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], PixbufLoader);
+            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("libgdk_pixbuf-2.0.so.0", "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/gdkpixbuf/pixbuf.d.ts

@@ -64,4 +64,6 @@ export declare class Pixbuf extends GObject.GObject {
     scale(dest: Pixbuf, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: InterpType): void;
     scaleSimple(destWidth: number, destHeight: number, interpType: InterpType): Pixbuf | null;
     setOption(key: string, value: string): boolean;
+    connect(signal: "notify", handler: (self: Pixbuf, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gdkpixbuf/pixbuf.js

@@ -1254,4 +1254,18 @@ export class Pixbuf 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], Pixbuf);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgdk_pixbuf-2.0.so.0", "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/gio/app-info-monitor.d.ts

@@ -3,4 +3,7 @@ export declare class AppInfoMonitor extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     static get(): AppInfoMonitor;
+    connect(signal: "changed", handler: (self: AppInfoMonitor) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: AppInfoMonitor, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gio/app-info-monitor.js

@@ -1,6 +1,9 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    changed: [],
+};
 export class AppInfoMonitor extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -23,4 +26,28 @@ export class AppInfoMonitor extends GObject.GObject {
         });
         return wrapPtr(ptr, AppInfoMonitor);
     }
+    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], AppInfoMonitor);
+            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("libgio-2.0.so.0", "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/gio/app-launch-context.d.ts

@@ -1,5 +1,6 @@
 import { AppInfo } from "./app-info.js";
 import { File } from "./file.js";
+import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 export declare class AppLaunchContext extends GObject.GObject {
     constructor(...args: unknown[]);
@@ -10,4 +11,9 @@ export declare class AppLaunchContext extends GObject.GObject {
     launchFailed(startupNotifyId: string): void;
     setenv(variable: string, value: string): void;
     unsetenv(variable: string): void;
+    connect(signal: "launch-failed", handler: (self: AppLaunchContext, startupNotifyId: string) => void, after?: boolean): number;
+    connect(signal: "launch-started", handler: (self: AppLaunchContext, info: AppInfo, platformData: GLib.Variant) => void, after?: boolean): number;
+    connect(signal: "launched", handler: (self: AppLaunchContext, info: AppInfo, platformData: GLib.Variant) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: AppLaunchContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }