@gtkx/ffi 0.1.15 → 0.1.17

package/dist/generated/gtk/color-chooser-widget.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 export class ColorChooserWidget extends Widget {
     constructor(...args) {
@@ -92,4 +93,18 @@ export class ColorChooserWidget 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], ColorChooserWidget);
+            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/color-dialog-button.d.ts

@@ -1,4 +1,5 @@
 import { ColorDialog } from "./color-dialog.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class ColorDialogButton extends Widget {
@@ -9,4 +10,7 @@ export declare class ColorDialogButton extends Widget {
     getRgba(): Gdk.RGBA;
     setDialog(dialog: ColorDialog): void;
     setRgba(color: Gdk.RGBA): void;
+    connect(signal: "activate", handler: (self: ColorDialogButton) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ColorDialogButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/color-dialog-button.js

@@ -3,6 +3,9 @@ import { wrapPtr } from "@gtkx/ffi";
 import { ColorDialog } from "./color-dialog.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [],
+};
 export class ColorDialogButton extends Widget {
     constructor(...args) {
         super(...args);
@@ -65,4 +68,28 @@ export class ColorDialogButton 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], ColorDialogButton);
+            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/color-dialog.d.ts

@@ -12,4 +12,6 @@ export declare class ColorDialog extends GObject.GObject {
     setModal(modal: boolean): void;
     setTitle(title: string): void;
     setWithAlpha(withAlpha: boolean): void;
+    connect(signal: "notify", handler: (self: ColorDialog, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/color-dialog.js

@@ -132,4 +132,18 @@ export class ColorDialog 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], ColorDialog);
+            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/column-view-column.d.ts

@@ -26,4 +26,6 @@ export declare class ColumnViewColumn extends GObject.GObject {
     setSorter(sorter?: Sorter | null): void;
     setTitle(title?: string | null): void;
     setVisible(visible: boolean): void;
+    connect(signal: "notify", handler: (self: ColumnViewColumn, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/column-view-column.js

@@ -222,4 +222,18 @@ export class ColumnViewColumn 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], ColumnViewColumn);
+            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/column-view-row.d.ts

@@ -15,4 +15,6 @@ export declare class ColumnViewRow extends GObject.GObject {
     setActivatable(activatable: boolean): void;
     setFocusable(focusable: boolean): void;
     setSelectable(selectable: boolean): void;
+    connect(signal: "notify", handler: (self: ColumnViewRow, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/column-view-row.js

@@ -143,4 +143,18 @@ export class ColumnViewRow 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], ColumnViewRow);
+            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/column-view-sorter.d.ts

@@ -1,6 +1,7 @@
 import { Ref } from "@gtkx/native";
 import { SortType } from "./enums.js";
 import { ColumnViewColumn } from "./column-view-column.js";
+import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
 export declare class ColumnViewSorter extends Sorter {
     constructor(...args: unknown[]);
@@ -9,4 +10,6 @@ export declare class ColumnViewSorter extends Sorter {
     getNthSortColumn(position: number, sortOrder: Ref<SortType>): ColumnViewColumn | null;
     getPrimarySortColumn(): ColumnViewColumn | null;
     getPrimarySortOrder(): SortType;
+    connect(signal: "notify", handler: (self: ColumnViewSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/column-view-sorter.js

@@ -66,4 +66,18 @@ export class ColumnViewSorter extends Sorter {
             },
         ], { 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], ColumnViewSorter);
+            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/column-view.d.ts

@@ -7,6 +7,7 @@ import { ColumnViewColumn } from "./column-view-column.js";
 import { ListItemFactory } from "./list-item-factory.js";
 import { SelectionModel } from "./selection-model.js";
 import { Sorter } from "./sorter.js";
+import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
 export declare class ColumnView extends Widget {
@@ -47,4 +48,7 @@ export declare class ColumnView extends Widget {
     setHscrollPolicy(policy: ScrollablePolicy): void;
     setVadjustment(vadjustment?: Adjustment | null): void;
     setVscrollPolicy(policy: ScrollablePolicy): void;
+    connect(signal: "activate", handler: (self: ColumnView, position: number) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ColumnView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/column-view.js

@@ -6,6 +6,9 @@ import { SelectionModel } from "./selection-model.js";
 import { Sorter } from "./sorter.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [{ type: { type: "int", size: 32, unsigned: true } }],
+};
 export class ColumnView extends Widget {
     constructor(...args) {
         super(...args);
@@ -417,4 +420,28 @@ export class ColumnView 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], ColumnView);
+            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/combo-box-text.d.ts

@@ -1,3 +1,5 @@
+import { ScrollType } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import { ComboBox } from "./combo-box.js";
 export declare class ComboBoxText extends ComboBox {
     constructor(...args: unknown[]);
@@ -12,4 +14,12 @@ export declare class ComboBoxText extends ComboBox {
     prependText(text: string): void;
     remove(position: number): void;
     removeAll(): void;
+    connect(signal: "activate", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "changed", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "format-entry-text", handler: (self: ComboBoxText, path: string) => string, after?: boolean): number;
+    connect(signal: "move-active", handler: (self: ComboBoxText, scrollType: ScrollType) => void, after?: boolean): number;
+    connect(signal: "popdown", handler: (self: ComboBoxText) => boolean, after?: boolean): number;
+    connect(signal: "popup", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ComboBoxText, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/combo-box-text.js

@@ -1,6 +1,14 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { ComboBox } from "./combo-box.js";
+const SIGNAL_META = {
+    activate: [],
+    changed: [],
+    "format-entry-text": [{ type: { type: "string", borrowed: false } }],
+    "move-active": [{ type: { type: "int", size: 32, unsigned: false } }],
+    popdown: [],
+    popup: [],
+};
 export class ComboBoxText extends ComboBox {
     constructor(...args) {
         super(...args);
@@ -138,4 +146,28 @@ export class ComboBoxText extends ComboBox {
             },
         ], { 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], ComboBoxText);
+            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/combo-box.d.ts

@@ -1,9 +1,10 @@
 import { Ref } from "@gtkx/native";
-import { SensitivityType } from "./enums.js";
+import { ScrollType, SensitivityType } from "./enums.js";
 import { TreeIter } from "./tree-iter.js";
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class ComboBox extends Widget {
@@ -47,4 +48,12 @@ export declare class ComboBox extends Widget {
     packStart(cell: CellRenderer, expand: boolean): void;
     reorder(cell: CellRenderer, position: number): void;
     setCellDataFunc(cell: CellRenderer, destroy: () => void, func?: (...args: unknown[]) => unknown | null, funcData?: number | null): void;
+    connect(signal: "activate", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "changed", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "format-entry-text", handler: (self: ComboBox, path: string) => string, after?: boolean): number;
+    connect(signal: "move-active", handler: (self: ComboBox, scrollType: ScrollType) => void, after?: boolean): number;
+    connect(signal: "popdown", handler: (self: ComboBox) => boolean, after?: boolean): number;
+    connect(signal: "popup", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ComboBox, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/combo-box.js

@@ -3,6 +3,14 @@ import { wrapPtr } from "@gtkx/ffi";
 import { CellArea } from "./cell-area.js";
 import { TreeModel } from "./tree-model.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [],
+    changed: [],
+    "format-entry-text": [{ type: { type: "string", borrowed: false } }],
+    "move-active": [{ type: { type: "int", size: 32, unsigned: false } }],
+    popdown: [],
+    popup: [],
+};
 export class ComboBox extends Widget {
     constructor(...args) {
         super(...args);
@@ -454,4 +462,28 @@ export class ComboBox 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], ComboBox);
+            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/constraint-guide.d.ts

@@ -14,4 +14,6 @@ export declare class ConstraintGuide extends GObject.GObject {
     setName(name?: string | null): void;
     setNatSize(width: number, height: number): void;
     setStrength(strength: ConstraintStrength): void;
+    connect(signal: "notify", handler: (self: ConstraintGuide, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/constraint-guide.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 export class ConstraintGuide extends GObject.GObject {
     constructor(...args) {
@@ -164,4 +165,18 @@ export class ConstraintGuide 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], ConstraintGuide);
+            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/constraint.d.ts

@@ -17,4 +17,6 @@ export declare class Constraint extends GObject.GObject {
     isAttached(): boolean;
     isConstant(): boolean;
     isRequired(): boolean;
+    connect(signal: "notify", handler: (self: Constraint, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/constraint.js

@@ -162,4 +162,18 @@ export class Constraint 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], Constraint);
+            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/css-provider.d.ts

@@ -1,3 +1,4 @@
+import { CssSection } from "./css-section.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
@@ -12,4 +13,7 @@ export declare class CssProvider extends GObject.GObject {
     loadFromString(string: string): void;
     loadNamed(name: string, variant?: string | null): void;
     toString(): string;
+    connect(signal: "parsing-error", handler: (self: CssProvider, section: CssSection, error: GLib.GError) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: CssProvider, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/css-provider.js

@@ -1,5 +1,12 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "parsing-error": [
+        { type: { type: "boxed", borrowed: false, innerType: "GtkCssSection" } },
+        { type: { type: "boxed", borrowed: false, innerType: "GError" } },
+    ],
+};
 export class CssProvider extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -110,4 +117,28 @@ export class CssProvider extends GObject.GObject {
             },
         ], { type: "string" });
     }
+    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], CssProvider);
+            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/custom-filter.d.ts

@@ -1,7 +1,10 @@
+import * as GObject from "../gobject/index.js";
 import { Filter } from "./filter.js";
 export declare class CustomFilter extends Filter {
     constructor(userDestroy: () => void, matchFunc?: (...args: unknown[]) => unknown | null, userData?: number | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
     setFilterFunc(userDestroy: () => void, matchFunc?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    connect(signal: "notify", handler: (self: CustomFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/custom-filter.js

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

@@ -1,7 +1,10 @@
+import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
 export declare class CustomSorter extends Sorter {
     constructor(sortFunc?: (...args: unknown[]) => unknown | null, userData?: number | null, userDestroy?: () => void | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
     setSortFunc(userDestroy: () => void, sortFunc?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    connect(signal: "notify", handler: (self: CustomSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/custom-sorter.js

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

@@ -1,6 +1,7 @@
 import { Box } from "./box.js";
 import { HeaderBar } from "./header-bar.js";
 import { Widget } from "./widget.js";
+import * as GObject from "../gobject/index.js";
 import { Window } from "./window.js";
 export declare class Dialog extends Window {
     constructor(...args: unknown[]);
@@ -14,4 +15,13 @@ export declare class Dialog extends Window {
     response(responseId: number): void;
     setDefaultResponse(responseId: number): void;
     setResponseSensitive(responseId: number, setting: boolean): void;
+    connect(signal: "close", handler: (self: Dialog) => void, after?: boolean): number;
+    connect(signal: "response", handler: (self: Dialog, responseId: number) => void, after?: boolean): number;
+    connect(signal: "activate-default", handler: (self: Dialog) => void, after?: boolean): number;
+    connect(signal: "activate-focus", handler: (self: Dialog) => void, after?: boolean): number;
+    connect(signal: "close-request", handler: (self: Dialog) => boolean, after?: boolean): number;
+    connect(signal: "enable-debugging", handler: (self: Dialog, toggle: boolean) => boolean, after?: boolean): number;
+    connect(signal: "keys-changed", handler: (self: Dialog) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Dialog, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/dialog.js

@@ -4,6 +4,15 @@ import { Box } from "./box.js";
 import { HeaderBar } from "./header-bar.js";
 import { Widget } from "./widget.js";
 import { Window } from "./window.js";
+const SIGNAL_META = {
+    close: [],
+    response: [{ type: { type: "int", size: 32, unsigned: false } }],
+    "activate-default": [],
+    "activate-focus": [],
+    "close-request": [],
+    "enable-debugging": [{ type: { type: "boolean" } }],
+    "keys-changed": [],
+};
 export class Dialog extends Window {
     constructor(...args) {
         super(...args);
@@ -132,4 +141,28 @@ export class Dialog 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], Dialog);
+            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 });
+    }
 }