@gtkx/ffi 0.1.15 → 0.1.17

package/dist/generated/gtk/video.js

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

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

@@ -3,6 +3,7 @@ import { ScrollablePolicy } from "./enums.js";
 import { Border } from "./border.js";
 import { ScrollInfo } from "./scroll-info.js";
 import { Adjustment } from "./adjustment.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Viewport extends Widget {
     constructor(hadjustment?: Adjustment | null, vadjustment?: Adjustment | null);
@@ -22,4 +23,6 @@ export declare class Viewport extends Widget {
     setHscrollPolicy(policy: ScrollablePolicy): void;
     setVadjustment(vadjustment?: Adjustment | null): void;
     setVscrollPolicy(policy: ScrollablePolicy): void;
+    connect(signal: "notify", handler: (self: Viewport, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/viewport.js

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

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

@@ -1,5 +1,11 @@
+import * as GObject from "../gobject/index.js";
 import { ScaleButton } from "./scale-button.js";
 export declare class VolumeButton extends ScaleButton {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "popdown", handler: (self: VolumeButton) => void, after?: boolean): number;
+    connect(signal: "popup", handler: (self: VolumeButton) => void, after?: boolean): number;
+    connect(signal: "value-changed", handler: (self: VolumeButton, value: number) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: VolumeButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

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

package/dist/generated/gtk/widget-paintable.d.ts

@@ -6,4 +6,6 @@ export declare class WidgetPaintable extends GObject.GObject {
     protected createPtr(args: unknown[]): unknown;
     getWidget(): Widget | null;
     setWidget(widget?: Widget | null): void;
+    connect(signal: "notify", handler: (self: WidgetPaintable, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/widget-paintable.js

@@ -38,4 +38,18 @@ export class WidgetPaintable 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], WidgetPaintable);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -10,6 +10,7 @@ import { Root } from "./root.js";
 import { Settings } from "./settings.js";
 import { Snapshot } from "./snapshot.js";
 import { StyleContext } from "./style-context.js";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
@@ -204,4 +205,19 @@ export declare class Widget extends GObject.InitiallyUnowned {
     updateRelationValue(nRelations: number, relations: AccessibleRelation[], values: GObject.Value[]): void;
     updateStateValue(nStates: number, states: AccessibleState[], values: GObject.Value[]): void;
     getBuildableId(): string | null;
+    connect(signal: "destroy", handler: (self: Widget) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Widget, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Widget) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Widget, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Widget) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Widget, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Widget, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Widget, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Widget) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Widget) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Widget, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Widget) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Widget) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Widget, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/widget.js

@@ -7,11 +7,32 @@ import { Native } from "./native.js";
 import { Root } from "./root.js";
 import { Settings } from "./settings.js";
 import { StyleContext } from "./style-context.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import * as cairo from "../cairo/index.js";
+const SIGNAL_META = {
+    destroy: [],
+    "direction-changed": [{ type: { type: "int", size: 32, unsigned: false } }],
+    hide: [],
+    "keynav-failed": [{ type: { type: "int", size: 32, unsigned: false } }],
+    map: [],
+    "mnemonic-activate": [{ type: { type: "boolean" } }],
+    "move-focus": [{ type: { type: "int", size: 32, unsigned: false } }],
+    "query-tooltip": [
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "boolean" } },
+        { type: { type: "gobject", borrowed: false }, getCls: () => Tooltip },
+    ],
+    realize: [],
+    show: [],
+    "state-flags-changed": [{ type: { type: "int", size: 32, unsigned: false } }],
+    unmap: [],
+    unrealize: [],
+};
 export class Widget extends GObject.InitiallyUnowned {
     constructor(...args) {
         super(...args);
@@ -2215,4 +2236,28 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "string", borrowed: true });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Widget);
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return wrapPtr(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/window-controls.d.ts

@@ -1,4 +1,5 @@
 import { PackType } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class WindowControls extends Widget {
     constructor(side: PackType);
@@ -11,4 +12,6 @@ export declare class WindowControls extends Widget {
     setDecorationLayout(layout?: string | null): void;
     setSide(side: PackType): void;
     setUseNativeControls(setting: boolean): void;
+    connect(signal: "notify", handler: (self: WindowControls, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/window-controls.js

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

package/dist/generated/gtk/window-group.d.ts

@@ -6,4 +6,6 @@ export declare class WindowGroup extends GObject.GObject {
     addWindow(window: Window): void;
     listWindows(): Window[];
     removeWindow(window: Window): void;
+    connect(signal: "notify", handler: (self: WindowGroup, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/window-group.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class WindowGroup extends GObject.GObject {
     constructor(...args) {
@@ -42,4 +43,18 @@ export class WindowGroup 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], WindowGroup);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            { type: { type: "callback", argTypes }, value: wrappedHandler },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/window-handle.d.ts

@@ -1,7 +1,10 @@
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class WindowHandle extends Widget {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     getChild(): Widget | null;
     setChild(child?: Widget | null): void;
+    connect(signal: "notify", handler: (self: WindowHandle, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/window-handle.js

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

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

@@ -2,6 +2,7 @@ import { Ref } from "@gtkx/native";
 import { WindowGravity } from "./enums.js";
 import { Application } from "./application.js";
 import { WindowGroup } from "./window-group.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Gsk from "../gsk/index.js";
@@ -75,4 +76,11 @@ export declare class Window extends Widget {
     getRenderer(): Gsk.Renderer | null;
     getSurface(): Gdk.Surface | null;
     getSurfaceTransform(x: Ref<number>, y: Ref<number>): void;
+    connect(signal: "activate-default", handler: (self: Window) => void, after?: boolean): number;
+    connect(signal: "activate-focus", handler: (self: Window) => void, after?: boolean): number;
+    connect(signal: "close-request", handler: (self: Window) => boolean, after?: boolean): number;
+    connect(signal: "enable-debugging", handler: (self: Window, toggle: boolean) => boolean, after?: boolean): number;
+    connect(signal: "keys-changed", handler: (self: Window) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Window, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/window.js

@@ -5,6 +5,13 @@ import { WindowGroup } from "./window-group.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gsk from "../gsk/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    "activate-default": [],
+    "activate-focus": [],
+    "close-request": [],
+    "enable-debugging": [{ type: { type: "boolean" } }],
+    "keys-changed": [],
+};
 export class Window extends Widget {
     constructor(...args) {
         super(...args);
@@ -680,4 +687,28 @@ export class Window extends Widget {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Window);
+            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/gtksource/annotation-provider.d.ts

@@ -8,4 +8,7 @@ export declare class AnnotationProvider extends GObject.GObject {
     populateHoverFinish(result: Gio.AsyncResult): boolean;
     removeAll(): void;
     removeAnnotation(annotation: Annotation): boolean;
+    connect(signal: "changed", handler: (self: AnnotationProvider) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: AnnotationProvider, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtksource/annotation-provider.js

@@ -1,6 +1,9 @@
 import { call } from "@gtkx/native";
-import { NativeError } from "@gtkx/ffi";
+import { NativeError, wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    changed: [],
+};
 export class AnnotationProvider extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -68,4 +71,28 @@ export class AnnotationProvider 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], AnnotationProvider);
+            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("libgtksourceview-5.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/gtksource/annotation.d.ts

@@ -9,4 +9,6 @@ export declare class Annotation extends GObject.GObject {
     getIcon(): Gio.Icon | null;
     getLine(): number;
     getStyle(): AnnotationStyle;
+    connect(signal: "notify", handler: (self: Annotation, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtksource/annotation.js

@@ -62,4 +62,18 @@ export class Annotation 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], Annotation);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtksourceview-5.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/gtksource/annotations.d.ts

@@ -5,4 +5,7 @@ export declare class Annotations extends GObject.GObject {
     protected createPtr(_args: unknown[]): unknown;
     addProvider(provider: AnnotationProvider): void;
     removeProvider(provider: AnnotationProvider): boolean;
+    connect(signal: "changed", handler: (self: Annotations) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Annotations, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtksource/annotations.js

@@ -1,5 +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 Annotations extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -35,4 +39,28 @@ export class Annotations 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], Annotations);
+            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("libgtksourceview-5.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/gtksource/buffer.d.ts

@@ -1,8 +1,9 @@
 import { Ref } from "@gtkx/native";
-import { ChangeCaseType, SortFlags } from "./enums.js";
+import { BracketMatchType, ChangeCaseType, SortFlags } from "./enums.js";
 import { Language } from "./language.js";
 import { Mark } from "./mark.js";
 import { StyleScheme } from "./style-scheme.js";
+import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
 export declare class Buffer extends Gtk.TextBuffer {
     constructor(table?: Gtk.TextTagTable | null);
@@ -35,4 +36,10 @@ export declare class Buffer extends Gtk.TextBuffer {
     setLanguage(language?: Language | null): void;
     setStyleScheme(scheme?: StyleScheme | null): void;
     sortLines(start: Gtk.TextIter, end: Gtk.TextIter, flags: SortFlags, column: number): void;
+    connect(signal: "bracket-matched", handler: (self: Buffer, iter: Gtk.TextIter, state: BracketMatchType) => void, after?: boolean): number;
+    connect(signal: "cursor-moved", handler: (self: Buffer) => void, after?: boolean): number;
+    connect(signal: "highlight-updated", handler: (self: Buffer, start: Gtk.TextIter, end: Gtk.TextIter) => void, after?: boolean): number;
+    connect(signal: "source-mark-updated", handler: (self: Buffer, mark: Gtk.TextMark) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Buffer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtksource/buffer.js

@@ -4,6 +4,18 @@ import { Language } from "./language.js";
 import { Mark } from "./mark.js";
 import { StyleScheme } from "./style-scheme.js";
 import * as Gtk from "../gtk/index.js";
+const SIGNAL_META = {
+    "bracket-matched": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTextIter" } },
+        { type: { type: "int", size: 32, unsigned: false } },
+    ],
+    "cursor-moved": [],
+    "highlight-updated": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTextIter" } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTextIter" } },
+    ],
+    "source-mark-updated": [{ type: { type: "gobject", borrowed: false } }],
+};
 export class Buffer extends Gtk.TextBuffer {
     constructor(...args) {
         super(...args);
@@ -489,4 +501,28 @@ export class Buffer extends Gtk.TextBuffer {
             },
         ], { 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], Buffer);
+            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("libgtksourceview-5.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/gtksource/completion-cell.d.ts

@@ -1,4 +1,5 @@
 import { CompletionColumn } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Gtk from "../gtk/index.js";
@@ -15,4 +16,6 @@ export declare class CompletionCell extends Gtk.Widget {
     setText(text?: string | null): void;
     setTextWithAttributes(text: string, attrs: Pango.AttrList): void;
     setWidget(child: Gtk.Widget): void;
+    connect(signal: "notify", handler: (self: CompletionCell, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtksource/completion-cell.js

@@ -123,4 +123,18 @@ export class CompletionCell extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], CompletionCell);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtksourceview-5.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/gtksource/completion-context.d.ts

@@ -23,4 +23,7 @@ export declare class CompletionContext extends GObject.GObject {
     getWord(): string;
     listProviders(): Gio.ListModel;
     setProposalsForProvider(provider: CompletionProvider, results?: Gio.ListModel | null): void;
+    connect(signal: "provider-model-changed", handler: (self: CompletionContext, provider: CompletionProvider, model: Gio.ListModel) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: CompletionContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }