@gtkx/ffi 0.1.12 → 0.1.14

package/dist/generated/gtk/gesture-click.d.ts

@@ -1,6 +1,19 @@
+import { EventSequenceState } from "./enums.js";
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureClick extends GestureSingle {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "pressed", handler: (self: GestureClick, nPress: number, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "released", handler: (self: GestureClick, nPress: number, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "stopped", handler: (self: GestureClick) => void, after?: boolean): number;
+    connect(signal: "unpaired-release", handler: (self: GestureClick, x: number, y: number, button: number, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "begin", handler: (self: GestureClick, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: GestureClick, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "end", handler: (self: GestureClick, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "sequence-state-changed", handler: (self: GestureClick, sequence: Gdk.EventSequence, state: EventSequenceState) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: GestureClick, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: GestureClick, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/gesture-click.js

@@ -1,6 +1,41 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { GestureSingle } from "./gesture-single.js";
+const SIGNAL_META = {
+    pressed: [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    released: [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    stopped: [],
+    "unpaired-release": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+        { type: { type: "int", size: 32, unsigned: true } },
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    begin: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    cancel: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    end: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    "sequence-state-changed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    update: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+};
 export class GestureClick extends GestureSingle {
     constructor(...args) {
         super(...args);
@@ -8,49 +43,25 @@ export class GestureClick extends GestureSingle {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_gesture_click_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            pressed: [
-                { type: { type: "int", size: 32, unsigned: false } },
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-            released: [
-                { type: { type: "int", size: 32, unsigned: false } },
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-            stopped: [],
-            "unpaired-release": [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-                { type: { type: "int", size: 32, unsigned: true } },
-                {
-                    type: {
-                        type: "boxed",
-                        borrowed: false,
-                        innerType: "GdkEventSequence",
-                    },
-                },
-            ],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: 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], GestureClick);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/gesture-drag.d.ts

@@ -1,9 +1,21 @@
 import { Ref } from "@gtkx/native";
+import { EventSequenceState } from "./enums.js";
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureDrag extends GestureSingle {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    getOffset(x?: Ref<number>, y?: Ref<number>): boolean;
-    getStartPoint(x?: Ref<number>, y?: Ref<number>): boolean;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    getOffset(x?: Ref<number> | null, y?: Ref<number> | null): boolean;
+    getStartPoint(x?: Ref<number> | null, y?: Ref<number> | null): boolean;
+    connect(signal: "drag-begin", handler: (self: GestureDrag, startX: number, startY: number) => void, after?: boolean): number;
+    connect(signal: "drag-end", handler: (self: GestureDrag, offsetX: number, offsetY: number) => void, after?: boolean): number;
+    connect(signal: "drag-update", handler: (self: GestureDrag, offsetX: number, offsetY: number) => void, after?: boolean): number;
+    connect(signal: "begin", handler: (self: GestureDrag, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: GestureDrag, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "end", handler: (self: GestureDrag, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "sequence-state-changed", handler: (self: GestureDrag, sequence: Gdk.EventSequence, state: EventSequenceState) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: GestureDrag, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: GestureDrag, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,6 +1,36 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { GestureSingle } from "./gesture-single.js";
+const SIGNAL_META = {
+    "drag-begin": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    "drag-end": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    "drag-update": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    begin: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    cancel: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    end: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    "sequence-state-changed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    update: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+};
 export class GestureDrag extends GestureSingle {
     constructor(...args) {
         super(...args);
@@ -8,7 +38,7 @@ export class GestureDrag extends GestureSingle {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_gesture_drag_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     getOffset(x, y) {
@@ -44,34 +74,21 @@ export class GestureDrag extends GestureSingle {
         ], { type: "boolean" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            "drag-begin": [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-            "drag-end": [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-            "drag-update": [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: 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], GestureDrag);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/gesture-long-press.d.ts

@@ -1,8 +1,19 @@
+import { EventSequenceState } from "./enums.js";
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureLongPress extends GestureSingle {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     getDelayFactor(): number;
     setDelayFactor(delayFactor: number): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "cancelled", handler: (self: GestureLongPress) => void, after?: boolean): number;
+    connect(signal: "pressed", handler: (self: GestureLongPress, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "begin", handler: (self: GestureLongPress, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: GestureLongPress, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "end", handler: (self: GestureLongPress, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "sequence-state-changed", handler: (self: GestureLongPress, sequence: Gdk.EventSequence, state: EventSequenceState) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: GestureLongPress, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: GestureLongPress, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/gesture-long-press.js

@@ -1,6 +1,29 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { GestureSingle } from "./gesture-single.js";
+const SIGNAL_META = {
+    cancelled: [],
+    pressed: [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    begin: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    cancel: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    end: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    "sequence-state-changed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    update: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+};
 export class GestureLongPress extends GestureSingle {
     constructor(...args) {
         super(...args);
@@ -8,7 +31,7 @@ export class GestureLongPress extends GestureSingle {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_gesture_long_press_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     getDelayFactor() {
@@ -32,27 +55,21 @@ export class GestureLongPress extends GestureSingle {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            cancelled: [],
-            pressed: [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: 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], GestureLongPress);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/gesture-pan.d.ts

@@ -1,4 +1,6 @@
-import { Orientation } from "./enums.js";
+import { EventSequenceState, Orientation, PanDirection } from "./enums.js";
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { GestureDrag } from "./gesture-drag.js";
 export declare class GesturePan extends GestureDrag {
     constructor(orientation: Orientation);
@@ -6,5 +8,15 @@ export declare class GesturePan extends GestureDrag {
     protected createPtr(args: unknown[]): unknown;
     getOrientation(): Orientation;
     setOrientation(orientation: Orientation): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "pan", handler: (self: GesturePan, direction: PanDirection, offset: number) => void, after?: boolean): number;
+    connect(signal: "drag-begin", handler: (self: GesturePan, startX: number, startY: number) => void, after?: boolean): number;
+    connect(signal: "drag-end", handler: (self: GesturePan, offsetX: number, offsetY: number) => void, after?: boolean): number;
+    connect(signal: "drag-update", handler: (self: GesturePan, offsetX: number, offsetY: number) => void, after?: boolean): number;
+    connect(signal: "begin", handler: (self: GesturePan, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: GesturePan, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "end", handler: (self: GesturePan, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "sequence-state-changed", handler: (self: GesturePan, sequence: Gdk.EventSequence, state: EventSequenceState) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: GesturePan, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: GesturePan, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/gesture-pan.js

@@ -1,6 +1,40 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { GestureDrag } from "./gesture-drag.js";
+const SIGNAL_META = {
+    pan: [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "float", size: 64 } },
+    ],
+    "drag-begin": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    "drag-end": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    "drag-update": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    begin: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    cancel: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    end: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    "sequence-state-changed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    update: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+};
 export class GesturePan extends GestureDrag {
     constructor(...args) {
         super(...args);
@@ -12,7 +46,7 @@ export class GesturePan extends GestureDrag {
                 type: { type: "int", size: 32, unsigned: false },
                 value: orientation,
             },
-        ], { type: "gobject", borrowed: true });
+        ], { type: "gobject", borrowed: false });
     }
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_gesture_pan_get_orientation", [
@@ -35,26 +69,21 @@ export class GesturePan extends GestureDrag {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            pan: [
-                { type: { type: "int", size: 32, unsigned: false } },
-                { type: { type: "float", size: 64 } },
-            ],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: 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], GesturePan);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/gesture-rotate.d.ts

@@ -1,7 +1,17 @@
+import { EventSequenceState } from "./enums.js";
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { Gesture } from "./gesture.js";
 export declare class GestureRotate extends Gesture {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     getAngleDelta(): number;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "angle-changed", handler: (self: GestureRotate, angle: number, angleDelta: number) => void, after?: boolean): number;
+    connect(signal: "begin", handler: (self: GestureRotate, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: GestureRotate, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "end", handler: (self: GestureRotate, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "sequence-state-changed", handler: (self: GestureRotate, sequence: Gdk.EventSequence, state: EventSequenceState) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: GestureRotate, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: GestureRotate, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/gesture-rotate.js

@@ -1,6 +1,28 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { Gesture } from "./gesture.js";
+const SIGNAL_META = {
+    "angle-changed": [
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    begin: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    cancel: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    end: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    "sequence-state-changed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    update: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+};
 export class GestureRotate extends Gesture {
     constructor(...args) {
         super(...args);
@@ -8,7 +30,7 @@ export class GestureRotate extends Gesture {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_gesture_rotate_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     getAngleDelta() {
@@ -20,26 +42,21 @@ export class GestureRotate extends Gesture {
         ], { type: "float", size: 64 });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            "angle-changed": [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: 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], GestureRotate);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/gesture-single.d.ts

@@ -1,3 +1,5 @@
+import { EventSequenceState } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Gesture } from "./gesture.js";
 export declare class GestureSingle extends Gesture {
@@ -5,10 +7,17 @@ export declare class GestureSingle extends Gesture {
     protected createPtr(_args: unknown[]): unknown;
     getButton(): number;
     getCurrentButton(): number;
-    getCurrentSequence(): Gdk.EventSequence;
+    getCurrentSequence(): Gdk.EventSequence | null;
     getExclusive(): boolean;
     getTouchOnly(): boolean;
     setButton(button: number): void;
     setExclusive(exclusive: boolean): void;
     setTouchOnly(touchOnly: boolean): void;
+    connect(signal: "begin", handler: (self: GestureSingle, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: GestureSingle, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "end", handler: (self: GestureSingle, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "sequence-state-changed", handler: (self: GestureSingle, sequence: Gdk.EventSequence, state: EventSequenceState) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: GestureSingle, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: GestureSingle, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/gesture-single.js

@@ -2,6 +2,24 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as Gdk from "../gdk/index.js";
 import { Gesture } from "./gesture.js";
+const SIGNAL_META = {
+    begin: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    cancel: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    end: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+    "sequence-state-changed": [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    update: [
+        { type: { type: "boxed", borrowed: false, innerType: "GdkEventSequence" } },
+    ],
+};
 export class GestureSingle extends Gesture {
     constructor(...args) {
         super(...args);
@@ -101,4 +119,28 @@ export class GestureSingle extends Gesture {
             },
         ], { 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], GestureSingle);
+            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);
+                }
+                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/gesture-stylus.d.ts

@@ -1,4 +1,6 @@
 import { Ref } from "@gtkx/native";
+import { EventSequenceState } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { GestureSingle } from "./gesture-single.js";
 export declare class GestureStylus extends GestureSingle {
@@ -7,8 +9,18 @@ export declare class GestureStylus extends GestureSingle {
     getAxes(axes: Gdk.AxisUse[], values: Ref<number[]>): boolean;
     getAxis(axis: Gdk.AxisUse, value: Ref<number>): boolean;
     getBacklog(backlog: Ref<unknown[]>, nElems: Ref<number>): boolean;
-    getDeviceTool(): Gdk.DeviceTool;
+    getDeviceTool(): Gdk.DeviceTool | null;
     getStylusOnly(): boolean;
     setStylusOnly(stylusOnly: boolean): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "down", handler: (self: GestureStylus, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "motion", handler: (self: GestureStylus, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "proximity", handler: (self: GestureStylus, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "up", handler: (self: GestureStylus, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "begin", handler: (self: GestureStylus, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: GestureStylus, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "end", handler: (self: GestureStylus, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "sequence-state-changed", handler: (self: GestureStylus, sequence: Gdk.EventSequence, state: EventSequenceState) => void, after?: boolean): number;
+    connect(signal: "update", handler: (self: GestureStylus, sequence: Gdk.EventSequence) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: GestureStylus, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }