@gtkx/ffi 0.1.15 → 0.1.16

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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Box } from "./box.js";
 export class ShortcutsGroup extends Box {
     constructor(...args) {
@@ -27,4 +28,18 @@ export class ShortcutsGroup extends Box {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], ShortcutsGroup);
+            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/shortcuts-section.d.ts

@@ -1,7 +1,11 @@
 import { ShortcutsGroup } from "./shortcuts-group.js";
+import * as GObject from "../gobject/index.js";
 import { Box } from "./box.js";
 export declare class ShortcutsSection extends Box {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     addGroup(group: ShortcutsGroup): void;
+    connect(signal: "change-current-page", handler: (self: ShortcutsSection, offset: number) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ShortcutsSection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/shortcuts-section.js

@@ -1,5 +1,9 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Box } from "./box.js";
+const SIGNAL_META = {
+    "change-current-page": [{ type: { type: "int", size: 32, unsigned: false } }],
+};
 export class ShortcutsSection extends Box {
     constructor(...args) {
         super(...args);
@@ -27,4 +31,28 @@ export class ShortcutsSection extends Box {
             },
         ], { 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], ShortcutsSection);
+            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/shortcuts-shortcut.d.ts

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

package/dist/generated/gtk/shortcuts-shortcut.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 export class ShortcutsShortcut extends Widget {
     constructor(...args) {
@@ -15,4 +16,18 @@ export class ShortcutsShortcut extends Widget {
             { 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], ShortcutsShortcut);
+            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/shortcuts-window.d.ts

@@ -1,7 +1,17 @@
 import { ShortcutsSection } from "./shortcuts-section.js";
+import * as GObject from "../gobject/index.js";
 import { Window } from "./window.js";
 export declare class ShortcutsWindow extends Window {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     addSection(section: ShortcutsSection): void;
+    connect(signal: "close", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "search", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "activate-default", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "activate-focus", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "close-request", handler: (self: ShortcutsWindow) => boolean, after?: boolean): number;
+    connect(signal: "enable-debugging", handler: (self: ShortcutsWindow, toggle: boolean) => boolean, after?: boolean): number;
+    connect(signal: "keys-changed", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ShortcutsWindow, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,5 +1,15 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Window } from "./window.js";
+const SIGNAL_META = {
+    close: [],
+    search: [],
+    "activate-default": [],
+    "activate-focus": [],
+    "close-request": [],
+    "enable-debugging": [{ type: { type: "boolean" } }],
+    "keys-changed": [],
+};
 export class ShortcutsWindow extends Window {
     constructor(...args) {
         super(...args);
@@ -27,4 +37,28 @@ export class ShortcutsWindow extends Window {
             },
         ], { 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], ShortcutsWindow);
+            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/signal-list-item-factory.js

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

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

@@ -28,4 +28,6 @@ export declare class SingleSelection extends GObject.GObject {
     unselectAll(): boolean;
     unselectItem(position: number): boolean;
     unselectRange(position: number, nItems: number): boolean;
+    connect(signal: "notify", handler: (self: SingleSelection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -312,4 +312,18 @@ export class SingleSelection 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], SingleSelection);
+            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/size-group.d.ts

@@ -11,4 +11,6 @@ export declare class SizeGroup extends GObject.GObject {
     removeWidget(widget: Widget): void;
     setMode(mode: SizeGroupMode): void;
     getBuildableId(): string | null;
+    connect(signal: "notify", handler: (self: SizeGroup, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/size-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 SizeGroup extends GObject.GObject {
     constructor(...args) {
@@ -73,4 +74,18 @@ export class SizeGroup extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], SizeGroup);
+            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/slice-list-model.d.ts

@@ -13,4 +13,6 @@ export declare class SliceListModel extends GObject.GObject {
     setSize(size: number): void;
     getSection(position: number, outStart: Ref<number>, outEnd: Ref<number>): void;
     sectionsChanged(position: number, nItems: number): void;
+    connect(signal: "notify", handler: (self: SliceListModel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/slice-list-model.js

@@ -128,4 +128,18 @@ export class SliceListModel 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], SliceListModel);
+            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/snapshot.d.ts

@@ -1,5 +1,6 @@
 import { StyleContext } from "./style-context.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Graphene from "../graphene/index.js";
 import * as Gsk from "../gsk/index.js";
@@ -58,4 +59,6 @@ export declare class Snapshot extends Gdk.Snapshot {
     transformMatrix(matrix: Graphene.Matrix): void;
     translate(point: Graphene.Point): void;
     translate_3d(point: Graphene.Point3D): void;
+    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/gtk/snapshot.js

@@ -1064,4 +1064,18 @@ export class Snapshot extends Gdk.Snapshot {
             },
         ], { type: "undefined" });
     }
+    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/gtk/sort-list-model.d.ts

@@ -17,4 +17,6 @@ export declare class SortListModel extends GObject.GObject {
     setSorter(sorter?: Sorter | null): void;
     getSection(position: number, outStart: Ref<number>, outEnd: Ref<number>): void;
     sectionsChanged(position: number, nItems: number): void;
+    connect(signal: "notify", handler: (self: SortListModel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/sort-list-model.js

@@ -159,4 +159,18 @@ export class SortListModel 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], SortListModel);
+            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/sorter.d.ts

@@ -6,4 +6,7 @@ export declare class Sorter extends GObject.GObject {
     changed(change: SorterChange): void;
     compare(item1: GObject.GObject, item2: GObject.GObject): Ordering;
     getOrder(): SorterOrder;
+    connect(signal: "changed", handler: (self: Sorter, change: SorterChange) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Sorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/sorter.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: [{ type: { type: "int", size: 32, unsigned: false } }],
+};
 export class Sorter extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -51,4 +55,28 @@ export class Sorter extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    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], Sorter);
+            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/spin-button.d.ts

@@ -1,7 +1,8 @@
 import { Ref } from "@gtkx/native";
-import { AccessiblePlatformState, Orientation, SpinButtonUpdatePolicy, SpinType } from "./enums.js";
+import { AccessiblePlatformState, Orientation, ScrollType, SpinButtonUpdatePolicy, SpinType } from "./enums.js";
 import { Adjustment } from "./adjustment.js";
 import { Editable } from "./editable.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class SpinButton extends Widget {
@@ -64,4 +65,12 @@ export declare class SpinButton extends Widget {
     setWidthChars(nChars: number): void;
     getOrientation(): Orientation;
     setOrientation(orientation: Orientation): void;
+    connect(signal: "activate", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "change-value", handler: (self: SpinButton, scroll: ScrollType) => void, after?: boolean): number;
+    connect(signal: "input", handler: (self: SpinButton, newValue: number) => number, after?: boolean): number;
+    connect(signal: "output", handler: (self: SpinButton) => boolean, after?: boolean): number;
+    connect(signal: "value-changed", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "wrapped", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: SpinButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -3,6 +3,14 @@ import { wrapPtr } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { Editable } from "./editable.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [],
+    "change-value": [{ type: { type: "int", size: 32, unsigned: false } }],
+    input: [{ type: { type: "float", size: 64 } }],
+    output: [],
+    "value-changed": [],
+    wrapped: [],
+};
 export class SpinButton extends Widget {
     constructor(...args) {
         super(...args);
@@ -666,4 +674,28 @@ export class SpinButton 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], SpinButton);
+            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/spinner.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Spinner extends Widget {
     constructor(...args: unknown[]);
@@ -6,4 +7,6 @@ export declare class Spinner extends Widget {
     setSpinning(spinning: boolean): void;
     start(): void;
     stop(): void;
+    connect(signal: "notify", handler: (self: Spinner, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/spinner.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 export class Spinner extends Widget {
     constructor(...args) {
@@ -46,4 +47,18 @@ export class Spinner 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], Spinner);
+            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/stack-page.d.ts

@@ -37,4 +37,6 @@ export declare class StackPage extends GObject.GObject {
     updatePropertyValue(nProperties: number, properties: AccessibleProperty[], values: GObject.Value[]): void;
     updateRelationValue(nRelations: number, relations: AccessibleRelation[], values: GObject.Value[]): void;
     updateStateValue(nStates: number, states: AccessibleState[], values: GObject.Value[]): void;
+    connect(signal: "notify", handler: (self: StackPage, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/stack-page.js

@@ -428,4 +428,18 @@ export class StackPage 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], StackPage);
+            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/stack-sidebar.d.ts

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

package/dist/generated/gtk/stack-sidebar.js

@@ -35,4 +35,18 @@ export class StackSidebar 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], StackSidebar);
+            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/stack-switcher.d.ts

@@ -1,5 +1,6 @@
 import { Orientation } from "./enums.js";
 import { Stack } from "./stack.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class StackSwitcher extends Widget {
     constructor(...args: unknown[]);
@@ -8,4 +9,6 @@ export declare class StackSwitcher extends Widget {
     setStack(stack?: Stack | null): void;
     getOrientation(): Orientation;
     setOrientation(orientation: Orientation): void;
+    connect(signal: "notify", handler: (self: StackSwitcher, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/stack-switcher.js

@@ -55,4 +55,18 @@ export class StackSwitcher 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], StackSwitcher);
+            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/stack.d.ts

@@ -1,6 +1,7 @@
 import { StackTransitionType } from "./enums.js";
 import { SelectionModel } from "./selection-model.js";
 import { StackPage } from "./stack-page.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Stack extends Widget {
     constructor(...args: unknown[]);
@@ -28,4 +29,6 @@ export declare class Stack extends Widget {
     setVisibleChild(child: Widget): void;
     setVisibleChildFull(name: string, transition: StackTransitionType): void;
     setVisibleChildName(name: string): void;
+    connect(signal: "notify", handler: (self: Stack, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/stack.js

@@ -280,4 +280,18 @@ export class Stack 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], Stack);
+            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/statusbar.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Statusbar extends Widget {
     constructor(...args: unknown[]);
@@ -7,4 +8,8 @@ export declare class Statusbar extends Widget {
     push(contextId: number, text: string): number;
     remove(contextId: number, messageId: number): void;
     removeAll(contextId: number): void;
+    connect(signal: "text-popped", handler: (self: Statusbar, contextId: number, text: string) => void, after?: boolean): number;
+    connect(signal: "text-pushed", handler: (self: Statusbar, contextId: number, text: string) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Statusbar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }