@gtkx/ffi 0.1.46 → 0.1.48

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

@@ -1,5 +1,6 @@
-import { AssistantPageType } from "./enums.js";
+import { AssistantPageType, DirectionType, StateFlags, TextDirection } from "./enums.js";
 import { AssistantPage } from "./assistant-page.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
@@ -181,6 +182,19 @@ export declare class Assistant extends Window {
     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: "destroy", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Assistant, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Assistant, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Assistant, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Assistant, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Assistant, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Assistant, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Assistant) => void, after?: boolean): number;
+    connect(signal: "unrealize", 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

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { AssistantPage } from "./assistant-page.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 import * as Gio from "../gio/index.js";
 import { Window } from "./window.js";
@@ -61,6 +62,42 @@ const SIGNAL_META = {
         returnType: { type: "boolean" },
     },
     "keys-changed": { params: [], returnType: { type: "undefined" } },
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
 };
 export class Assistant extends Window {
     /**

package/dist/generated/gtk/bin-layout.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * A layout manager for widgets with a single child.
@@ -13,4 +14,6 @@ export declare class BinLayout extends LayoutManager {
      */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: BinLayout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/bin-layout.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * A layout manager for widgets with a single child.
@@ -21,4 +22,22 @@ export class BinLayout extends LayoutManager {
             borrowed: false,
         });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], BinLayout);
+            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, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/bool-filter.d.ts

@@ -1,7 +1,7 @@
+import { FilterChange } from "./enums.js";
 import { Expression } from "./expression.js";
 import * as GObject from "../gobject/index.js";
 import { Filter } from "./filter.js";
-/** Evaluates a boolean expression to determine whether to include items. */
 export declare class BoolFilter extends Filter {
     /**
      * Creates a new bool filter.
@@ -32,6 +32,7 @@ export declare class BoolFilter extends Filter {
      * @param invert - true to invert
      */
     setInvert(invert: boolean): void;
+    connect(signal: "changed", handler: (self: BoolFilter, change: FilterChange) => void, after?: boolean): number;
     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

@@ -3,6 +3,12 @@ import { getObject } from "@gtkx/ffi";
 import { Expression } from "./expression.js";
 import { Filter } from "./filter.js";
 /** Evaluates a boolean expression to determine whether to include items. */
+const SIGNAL_META = {
+    changed: {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+};
 export class BoolFilter extends Filter {
     constructor(...args) {
         super(...args);
@@ -80,12 +86,24 @@ export class BoolFilter extends Filter {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0], BoolFilter);
-            return handler(self, ...args.slice(1));
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(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 },

package/dist/generated/gtk/box-layout.d.ts

@@ -1,4 +1,5 @@
 import { BaselinePosition, Orientation } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Arranges children in a single row or column.
@@ -76,4 +77,6 @@ export declare class BoxLayout extends LayoutManager {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "notify", handler: (self: BoxLayout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Arranges children in a single row or column.
@@ -171,4 +172,22 @@ export class BoxLayout extends LayoutManager {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], BoxLayout);
+            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, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -1,42 +1,7 @@
-import { BaselinePosition, Orientation } from "./enums.js";
+import { BaselinePosition, DirectionType, Orientation, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Arranges child widgets into a single row or column.
- *
- *
- *
- * Whether it is a row or column depends on the value of its
- * [property@Gtk.Orientable:orientation] property. Within the other
- * dimension, all children are allocated the same size. The
- * [property@Gtk.Widget:halign] and [property@Gtk.Widget:valign]
- * properties can be used on the children to influence their allocation.
- *
- * Use repeated calls to [method@Gtk.Box.append] to pack widgets into a
- * `GtkBox` from start to end. Use [method@Gtk.Box.remove] to remove widgets
- * from the `GtkBox`. [method@Gtk.Box.insert_child_after] can be used to add
- * a child at a particular position.
- *
- * Use [method@Gtk.Box.set_homogeneous] to specify whether or not all children
- * of the `GtkBox` are forced to get the same amount of space.
- *
- * Use [method@Gtk.Box.set_spacing] to determine how much space will be minimally
- * placed between all children in the `GtkBox`. Note that spacing is added
- * *between* the children.
- *
- * Use [method@Gtk.Box.reorder_child_after] to move a child to a different
- * place in the box.
- *
- * # CSS nodes
- *
- * `GtkBox` uses a single CSS node with name box.
- *
- * # Accessibility
- *
- * Until GTK 4.10, `GtkBox` used the [enum@Gtk.AccessibleRole.group] role.
- *
- * Starting from GTK 4.12, `GtkBox` uses the [enum@Gtk.AccessibleRole.generic] role.
- */
 export declare class Box extends Widget {
     /**
      * Creates a new box.
@@ -142,6 +107,19 @@ export declare class Box extends Widget {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "destroy", handler: (self: Box) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Box, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Box) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Box, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Box) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Box, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Box, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Box, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Box) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Box) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Box, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Box) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Box) => void, after?: boolean): number;
     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,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Arranges child widgets into a single row or column.
@@ -37,6 +38,44 @@ import { Widget } from "./widget.js";
  *
  * Starting from GTK 4.12, `GtkBox` uses the [enum@Gtk.AccessibleRole.generic] role.
  */
+const SIGNAL_META = {
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
+};
 export class Box extends Widget {
     constructor(...args) {
         super(...args);
@@ -306,12 +345,24 @@ export class Box extends Widget {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0], Box);
-            return handler(self, ...args.slice(1));
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(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 },

package/dist/generated/gtk/builder-list-item-factory.d.ts

@@ -1,5 +1,6 @@
 import { BuilderScope } from "./builder-scope.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import { ListItemFactory } from "./list-item-factory.js";
 /**
  * Creates widgets by instantiating `GtkBuilder` UI templates.
@@ -64,4 +65,6 @@ export declare class BuilderListItemFactory extends ListItemFactory {
      * Gets the scope used when constructing listitems.
      */
     getScope(): BuilderScope | null;
+    connect(signal: "notify", handler: (self: BuilderListItemFactory, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/builder-list-item-factory.js

@@ -122,4 +122,22 @@ export class BuilderListItemFactory extends ListItemFactory {
             return null;
         return getObject(ptr, BuilderScope);
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], BuilderListItemFactory);
+            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, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

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

@@ -1,3 +1,5 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
@@ -178,6 +180,19 @@ export declare class Button extends Widget {
     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: "destroy", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Button, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Button, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Button, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Button, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Button, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Button, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Button) => void, after?: boolean): number;
+    connect(signal: "unrealize", 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

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -42,6 +43,42 @@ import { Widget } from "./widget.js";
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     clicked: { params: [], returnType: { type: "undefined" } },
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
 };
 export class Button extends Widget {
     /**

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

@@ -1,3 +1,5 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
@@ -125,6 +127,19 @@ export declare class Calendar extends Widget {
     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: "destroy", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Calendar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Calendar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Calendar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Calendar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Calendar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Calendar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Calendar) => void, after?: boolean): number;
+    connect(signal: "unrealize", 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

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -63,6 +64,42 @@ const SIGNAL_META = {
     "next-year": { params: [], returnType: { type: "undefined" } },
     "prev-month": { params: [], returnType: { type: "undefined" } },
     "prev-year": { params: [], returnType: { type: "undefined" } },
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
 };
 export class Calendar extends Widget {
     /**

package/dist/generated/gtk/callback-action.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { ShortcutAction } from "./shortcut-action.js";
 /** Invokes a callback. */
 export declare class CallbackAction extends ShortcutAction {
@@ -11,4 +12,6 @@ export declare class CallbackAction extends ShortcutAction {
     constructor(callback: (...args: unknown[]) => unknown, destroy: () => void, data?: number | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: CallbackAction, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/callback-action.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { ShortcutAction } from "./shortcut-action.js";
 /** Invokes a callback. */
 export class CallbackAction extends ShortcutAction {
@@ -23,4 +24,22 @@ export class CallbackAction extends ShortcutAction {
             },
         ], { type: "gobject", borrowed: false });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], CallbackAction);
+            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, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/cell-area-box.d.ts

@@ -1,27 +1,11 @@
 import { Orientation } from "./enums.js";
+import { TreeIter } from "./tree-iter.js";
+import { CellEditable } from "./cell-editable.js";
+import { TreeModel } from "./tree-model.js";
+import { CellRenderer } from "./cell-renderer.js";
 import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { CellArea } from "./cell-area.js";
-/**
- * A cell area that renders GtkCellRenderers into a row or a column
- *
- * The `GtkCellAreaBox` renders cell renderers into a row or a column
- * depending on its `GtkOrientation`.
- *
- * GtkCellAreaBox uses a notion of packing. Packing
- * refers to adding cell renderers with reference to a particular position
- * in a `GtkCellAreaBox`. There are two reference positions: the
- * start and the end of the box.
- * When the `GtkCellAreaBox` is oriented in the %GTK_ORIENTATION_VERTICAL
- * orientation, the start is defined as the top of the box and the end is
- * defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation
- * start is defined as the left side and the end is defined as the right
- * side.
- *
- * Alignments of `GtkCellRenderer`s rendered in adjacent rows can be
- * configured by configuring the `GtkCellAreaBox` align child cell property
- * with gtk_cell_area_cell_set_property() or by specifying the "align"
- * argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().
- */
 export declare class CellAreaBox extends CellArea {
     /**
      * Creates a new `GtkCellAreaBox`.
@@ -46,6 +30,10 @@ export declare class CellAreaBox extends CellArea {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "add-editable", handler: (self: CellAreaBox, renderer: CellRenderer, editable: CellEditable, cellArea: Gdk.Rectangle, path: string) => void, after?: boolean): number;
+    connect(signal: "apply-attributes", handler: (self: CellAreaBox, model: TreeModel, iter: TreeIter, isExpander: boolean, isExpanded: boolean) => void, after?: boolean): number;
+    connect(signal: "focus-changed", handler: (self: CellAreaBox, renderer: CellRenderer, path: string) => void, after?: boolean): number;
+    connect(signal: "remove-editable", handler: (self: CellAreaBox, renderer: CellRenderer, editable: CellEditable) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellAreaBox, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }