@gtkx/ffi 0.1.15 → 0.1.17

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

@@ -26,4 +26,18 @@ export class AssistantPage extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return wrapPtr(ptr, Widget);
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], AssistantPage);
+            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/assistant.d.ts

@@ -1,6 +1,7 @@
 import { AssistantPageType } from "./enums.js";
 import { AssistantPage } from "./assistant-page.js";
 import { Widget } from "./widget.js";
+import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Window } from "./window.js";
 export declare class Assistant extends Window {
@@ -29,4 +30,16 @@ export declare class Assistant extends Window {
     setPageTitle(page: Widget, title: string): void;
     setPageType(page: Widget, type: AssistantPageType): void;
     updateButtonsState(): void;
+    connect(signal: "apply", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "cancel", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "close", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "escape", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "prepare", handler: (self: Assistant, page: Widget) => void, after?: boolean): number;
+    connect(signal: "activate-default", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "activate-focus", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "close-request", handler: (self: Assistant) => boolean, after?: boolean): number;
+    connect(signal: "enable-debugging", handler: (self: Assistant, toggle: boolean) => boolean, after?: boolean): number;
+    connect(signal: "keys-changed", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Assistant, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/assistant.js

@@ -4,6 +4,20 @@ import { AssistantPage } from "./assistant-page.js";
 import { Widget } from "./widget.js";
 import * as Gio from "../gio/index.js";
 import { Window } from "./window.js";
+const SIGNAL_META = {
+    apply: [],
+    cancel: [],
+    close: [],
+    escape: [],
+    prepare: [
+        { type: { type: "gobject", borrowed: false }, getCls: () => Widget },
+    ],
+    "activate-default": [],
+    "activate-focus": [],
+    "close-request": [],
+    "enable-debugging": [{ type: { type: "boolean" } }],
+    "keys-changed": [],
+};
 export class Assistant extends Window {
     constructor(...args) {
         super(...args);
@@ -291,4 +305,28 @@ export class Assistant 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], Assistant);
+            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/atcontext.d.ts

@@ -8,4 +8,7 @@ export declare class ATContext extends GObject.GObject {
     protected createPtr(args: unknown[]): unknown;
     getAccessible(): Accessible;
     getAccessibleRole(): AccessibleRole;
+    connect(signal: "state-change", handler: (self: ATContext) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: ATContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/atcontext.js

@@ -2,6 +2,9 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { Accessible } from "./accessible.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "state-change": [],
+};
 export class ATContext extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -40,4 +43,28 @@ export class ATContext 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], ATContext);
+            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/bookmark-list.d.ts

@@ -9,4 +9,6 @@ export declare class BookmarkList extends GObject.GObject {
     isLoading(): boolean;
     setAttributes(attributes?: string | null): void;
     setIoPriority(ioPriority: number): void;
+    connect(signal: "notify", handler: (self: BookmarkList, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/bookmark-list.js

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

@@ -1,4 +1,5 @@
 import { Expression } from "./expression.js";
+import * as GObject from "../gobject/index.js";
 import { Filter } from "./filter.js";
 export declare class BoolFilter extends Filter {
     constructor(expression?: Expression | null);
@@ -8,4 +9,6 @@ export declare class BoolFilter extends Filter {
     getInvert(): boolean;
     setExpression(expression?: Expression | null): void;
     setInvert(invert: boolean): void;
+    connect(signal: "notify", handler: (self: BoolFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -58,4 +58,18 @@ export class BoolFilter 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], BoolFilter);
+            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/box.d.ts

@@ -1,4 +1,5 @@
 import { BaselinePosition, Orientation } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Box extends Widget {
     constructor(orientation: Orientation, spacing: number);
@@ -19,4 +20,6 @@ export declare class Box extends Widget {
     setSpacing(spacing: number): void;
     getOrientation(): Orientation;
     setOrientation(orientation: Orientation): void;
+    connect(signal: "notify", handler: (self: Box, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/box.js

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

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

package/dist/generated/gtk/builder-cscope.js

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

@@ -28,4 +28,6 @@ export declare class Builder extends GObject.GObject {
     setTranslationDomain(domain?: string | null): void;
     valueFromString(pspec: GObject.ParamSpec, string: string, value: Ref<GObject.Value>): boolean;
     valueFromStringType(type: number, string: string, value: Ref<GObject.Value>): boolean;
+    connect(signal: "notify", handler: (self: Builder, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/builder.js

@@ -515,4 +515,18 @@ export class Builder extends GObject.GObject {
         }
         return result;
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], Builder);
+            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/button.d.ts

@@ -1,4 +1,5 @@
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Button extends Widget {
     constructor(...args: unknown[]);
@@ -23,4 +24,8 @@ export declare class Button extends Widget {
     setActionName(actionName?: string | null): void;
     setActionTargetValue(targetValue?: GLib.Variant | null): void;
     setDetailedActionName(detailedActionName: string): void;
+    connect(signal: "activate", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "clicked", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Button, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/button.js

@@ -2,6 +2,10 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    activate: [],
+    clicked: [],
+};
 export class Button extends Widget {
     constructor(...args) {
         super(...args);
@@ -222,4 +226,28 @@ export class Button 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], Button);
+            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/calendar.d.ts

@@ -1,4 +1,5 @@
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class Calendar extends Widget {
     constructor(...args: unknown[]);
@@ -22,4 +23,11 @@ export declare class Calendar extends Widget {
     setShowWeekNumbers(value: boolean): void;
     setYear(year: number): void;
     unmarkDay(day: number): void;
+    connect(signal: "day-selected", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "next-month", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "next-year", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "prev-month", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "prev-year", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: Calendar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/calendar.js

@@ -2,6 +2,13 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import { Widget } from "./widget.js";
+const SIGNAL_META = {
+    "day-selected": [],
+    "next-month": [],
+    "next-year": [],
+    "prev-month": [],
+    "prev-year": [],
+};
 export class Calendar extends Widget {
     constructor(...args) {
         super(...args);
@@ -214,4 +221,28 @@ export class Calendar 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], Calendar);
+            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/cell-area-box.d.ts

@@ -1,4 +1,5 @@
 import { Orientation } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import { CellArea } from "./cell-area.js";
 export declare class CellAreaBox extends CellArea {
     constructor(...args: unknown[]);
@@ -7,4 +8,6 @@ export declare class CellAreaBox extends CellArea {
     setSpacing(spacing: number): void;
     getOrientation(): Orientation;
     setOrientation(orientation: Orientation): void;
+    connect(signal: "notify", handler: (self: CellAreaBox, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/cell-area-box.js

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

@@ -14,4 +14,6 @@ export declare class CellAreaContext extends GObject.GObject {
     pushPreferredHeight(minimumHeight: number, naturalHeight: number): void;
     pushPreferredWidth(minimumWidth: number, naturalWidth: number): void;
     reset(): void;
+    connect(signal: "notify", handler: (self: CellAreaContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/cell-area-context.js

@@ -200,4 +200,18 @@ export class CellAreaContext 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], CellAreaContext);
+            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/cell-area.d.ts

@@ -3,10 +3,10 @@ import { CellRendererState, DirectionType, Orientation, SizeRequestMode } from "
 import { TreeIter } from "./tree-iter.js";
 import { CellAreaContext } from "./cell-area-context.js";
 import { CellEditable } from "./cell-editable.js";
-import { CellRenderer } from "./cell-renderer.js";
 import { Snapshot } from "./snapshot.js";
 import { TreeModel } from "./tree-model.js";
 import { Widget } from "./widget.js";
+import { CellRenderer } from "./cell-renderer.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 export declare class CellArea extends GObject.InitiallyUnowned {
@@ -61,4 +61,10 @@ export declare class CellArea extends GObject.InitiallyUnowned {
     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: "add-editable", handler: (self: CellArea, renderer: CellRenderer, editable: CellEditable, cellArea: Gdk.Rectangle, path: string) => void, after?: boolean): number;
+    connect(signal: "apply-attributes", handler: (self: CellArea, model: TreeModel, iter: TreeIter, isExpander: boolean, isExpanded: boolean) => void, after?: boolean): number;
+    connect(signal: "focus-changed", handler: (self: CellArea, renderer: CellRenderer, path: string) => void, after?: boolean): number;
+    connect(signal: "remove-editable", handler: (self: CellArea, renderer: CellRenderer, editable: CellEditable) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: CellArea, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/cell-area.js

@@ -4,6 +4,28 @@ import { CellAreaContext } from "./cell-area-context.js";
 import { CellEditable } from "./cell-editable.js";
 import { CellRenderer } from "./cell-renderer.js";
 import * as GObject from "../gobject/index.js";
+const SIGNAL_META = {
+    "add-editable": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => CellRenderer },
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GdkRectangle" } },
+        { type: { type: "string", borrowed: false } },
+    ],
+    "apply-attributes": [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+        { type: { type: "boolean" } },
+        { type: { type: "boolean" } },
+    ],
+    "focus-changed": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => CellRenderer },
+        { type: { type: "string", borrowed: false } },
+    ],
+    "remove-editable": [
+        { type: { type: "gobject", borrowed: false }, getCls: () => CellRenderer },
+        { type: { type: "gobject", borrowed: false } },
+    ],
+};
 export class CellArea extends GObject.InitiallyUnowned {
     constructor(...args) {
         super(...args);
@@ -980,4 +1002,28 @@ export class CellArea extends GObject.InitiallyUnowned {
             },
         ], { 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], CellArea);
+            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/cell-renderer-accel.d.ts

@@ -1,5 +1,12 @@
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { CellRendererText } from "./cell-renderer-text.js";
 export declare class CellRendererAccel extends CellRendererText {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "accel-cleared", handler: (self: CellRendererAccel, pathString: string) => void, after?: boolean): number;
+    connect(signal: "accel-edited", handler: (self: CellRendererAccel, pathString: string, accelKey: number, accelMods: Gdk.ModifierType, hardwareKeycode: number) => void, after?: boolean): number;
+    connect(signal: "edited", handler: (self: CellRendererAccel, path: string, newText: string) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: CellRendererAccel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/cell-renderer-accel.js

@@ -1,5 +1,19 @@
 import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
 import { CellRendererText } from "./cell-renderer-text.js";
+const SIGNAL_META = {
+    "accel-cleared": [{ type: { type: "string", borrowed: false } }],
+    "accel-edited": [
+        { type: { type: "string", borrowed: false } },
+        { type: { type: "int", size: 32, unsigned: true } },
+        { type: { type: "int", size: 32, unsigned: false } },
+        { type: { type: "int", size: 32, unsigned: true } },
+    ],
+    edited: [
+        { type: { type: "string", borrowed: false } },
+        { type: { type: "string", borrowed: false } },
+    ],
+};
 export class CellRendererAccel extends CellRendererText {
     constructor(...args) {
         super(...args);
@@ -10,4 +24,28 @@ export class CellRendererAccel extends CellRendererText {
             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], CellRendererAccel);
+            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 });
+    }
 }