@gtkx/ffi 0.1.47 → 0.1.49

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

@@ -7,6 +7,16 @@ import { CellRenderer } from "./cell-renderer.js";
  * `GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
  * Additionally, it can display a text on top of the progress bar.
  */
+const SIGNAL_META = {
+    "editing-canceled": { params: [], returnType: { type: "undefined" } },
+    "editing-started": {
+        params: [
+            { type: { type: "gobject", borrowed: true } },
+            { type: { type: "string", borrowed: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+};
 export class CellRendererProgress extends CellRenderer {
     /**
      * Creates a new `GtkCellRendererProgress`.
@@ -48,12 +58,24 @@ export class CellRendererProgress extends CellRenderer {
         ], { 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], CellRendererProgress);
-            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/cell-renderer-spin.d.ts

@@ -1,3 +1,4 @@
+import { CellEditable } from "./cell-editable.js";
 import * as GObject from "../gobject/index.js";
 import { CellRendererText } from "./cell-renderer-text.js";
 export declare class CellRendererSpin extends CellRendererText {
@@ -7,6 +8,8 @@ export declare class CellRendererSpin extends CellRendererText {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "edited", handler: (self: CellRendererSpin, path: string, newText: string) => void, after?: boolean): number;
+    connect(signal: "editing-canceled", handler: (self: CellRendererSpin) => void, after?: boolean): number;
+    connect(signal: "editing-started", handler: (self: CellRendererSpin, editable: CellEditable, path: string) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellRendererSpin, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -24,6 +24,14 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    "editing-canceled": { params: [], returnType: { type: "undefined" } },
+    "editing-started": {
+        params: [
+            { type: { type: "gobject", borrowed: true } },
+            { type: { type: "string", borrowed: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
 };
 export class CellRendererSpin extends CellRendererText {
     /**

package/dist/generated/gtk/cell-renderer-spinner.d.ts

@@ -1,19 +1,6 @@
+import { CellEditable } from "./cell-editable.js";
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
-/**
- * Renders a spinning animation in a cell
- *
- * `GtkCellRendererSpinner` renders a spinning animation in a cell, very
- * similar to `GtkSpinner`. It can often be used as an alternative
- * to a `GtkCellRendererProgress` for displaying indefinite activity,
- * instead of actual progress.
- *
- * To start the animation in a cell, set the `GtkCellRendererSpinner:active`
- * property to %TRUE and increment the `GtkCellRendererSpinner:pulse` property
- * at regular intervals. The usual way to set the cell renderer properties
- * for each cell is to bind them to columns in your tree model using e.g.
- * gtk_tree_view_column_add_attribute().
- */
 export declare class CellRendererSpinner extends CellRenderer {
     /**
      * Returns a new cell renderer which will show a spinner to indicate
@@ -21,6 +8,8 @@ export declare class CellRendererSpinner extends CellRenderer {
      */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "editing-canceled", handler: (self: CellRendererSpinner) => void, after?: boolean): number;
+    connect(signal: "editing-started", handler: (self: CellRendererSpinner, editable: CellEditable, path: string) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellRendererSpinner, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -15,6 +15,16 @@ import { CellRenderer } from "./cell-renderer.js";
  * for each cell is to bind them to columns in your tree model using e.g.
  * gtk_tree_view_column_add_attribute().
  */
+const SIGNAL_META = {
+    "editing-canceled": { params: [], returnType: { type: "undefined" } },
+    "editing-started": {
+        params: [
+            { type: { type: "gobject", borrowed: true } },
+            { type: { type: "string", borrowed: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+};
 export class CellRendererSpinner extends CellRenderer {
     /**
      * Returns a new cell renderer which will show a spinner to indicate
@@ -30,12 +40,24 @@ export class CellRendererSpinner extends CellRenderer {
         });
     }
     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], CellRendererSpinner);
-            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/cell-renderer-text.d.ts

@@ -1,3 +1,4 @@
+import { CellEditable } from "./cell-editable.js";
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
 export declare class CellRendererText extends CellRenderer {
@@ -24,6 +25,8 @@ export declare class CellRendererText extends CellRenderer {
      */
     setFixedHeightFromFont(numberOfRows: number): void;
     connect(signal: "edited", handler: (self: CellRendererText, path: string, newText: string) => void, after?: boolean): number;
+    connect(signal: "editing-canceled", handler: (self: CellRendererText) => void, after?: boolean): number;
+    connect(signal: "editing-started", handler: (self: CellRendererText, editable: CellEditable, path: string) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellRendererText, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -19,6 +19,14 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    "editing-canceled": { params: [], returnType: { type: "undefined" } },
+    "editing-started": {
+        params: [
+            { type: { type: "gobject", borrowed: true } },
+            { type: { type: "string", borrowed: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
 };
 export class CellRendererText extends CellRenderer {
     /**

package/dist/generated/gtk/cell-renderer-toggle.d.ts

@@ -1,3 +1,4 @@
+import { CellEditable } from "./cell-editable.js";
 import * as GObject from "../gobject/index.js";
 import { CellRenderer } from "./cell-renderer.js";
 export declare class CellRendererToggle extends CellRenderer {
@@ -48,6 +49,8 @@ export declare class CellRendererToggle extends CellRenderer {
      */
     setRadio(radio: boolean): void;
     connect(signal: "toggled", handler: (self: CellRendererToggle, path: string) => void, after?: boolean): number;
+    connect(signal: "editing-canceled", handler: (self: CellRendererToggle) => void, after?: boolean): number;
+    connect(signal: "editing-started", handler: (self: CellRendererToggle, editable: CellEditable, path: string) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellRendererToggle, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -14,6 +14,14 @@ const SIGNAL_META = {
         params: [{ type: { type: "string", borrowed: false } }],
         returnType: { type: "undefined" },
     },
+    "editing-canceled": { params: [], returnType: { type: "undefined" } },
+    "editing-started": {
+        params: [
+            { type: { type: "gobject", borrowed: true } },
+            { type: { type: "string", borrowed: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
 };
 export class CellRendererToggle extends CellRenderer {
     /**

package/dist/generated/gtk/cell-renderer.d.ts

@@ -1,6 +1,5 @@
 import { Ref } from "@gtkx/native";
 import { CellRendererState, SizeRequestMode, StateFlags } from "./enums.js";
-import { Requisition } from "./requisition.js";
 import { CellEditable } from "./cell-editable.js";
 import { Snapshot } from "./snapshot.js";
 import { Widget } from "./widget.js";
@@ -29,7 +28,7 @@ export declare class CellRenderer extends GObject.InitiallyUnowned {
      * @param cellArea - cell area which would be passed to gtk_cell_renderer_render()
      * @param alignedArea - the return location for the space inside `cell_area`                that would actually be used to render.
      */
-    getAlignedArea(widget: Widget, flags: CellRendererState, cellArea: Gdk.Rectangle, alignedArea: Ref<Gdk.Rectangle>): void;
+    getAlignedArea(widget: Widget, flags: CellRendererState, cellArea: Gdk.Rectangle, alignedArea: Ref<unknown>): void;
     /**
      * Fills in `xalign` and `yalign` with the appropriate values of @cell.
      * @param xalign - location to fill in with the x alignment of the cell
@@ -79,7 +78,7 @@ export declare class CellRenderer extends GObject.InitiallyUnowned {
      * @param minimumSize - location for storing the minimum size
      * @param naturalSize - location for storing the natural size
      */
-    getPreferredSize(widget: Widget, minimumSize?: Ref<Requisition> | null, naturalSize?: Ref<Requisition> | null): void;
+    getPreferredSize(widget: Widget, minimumSize?: Ref<unknown> | null, naturalSize?: Ref<unknown> | null): void;
     /**
      * Retrieves a renderer’s natural size when rendered to @widget.
      * @param widget - the `GtkWidget` this cell will be rendering to

package/dist/generated/gtk/cell-view.d.ts

@@ -1,33 +1,13 @@
-import { Orientation } from "./enums.js";
+import { DirectionType, Orientation, StateFlags, TextDirection } from "./enums.js";
 import { TreePath } from "./tree-path.js";
 import { CellArea } from "./cell-area.js";
 import { CellAreaContext } from "./cell-area-context.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
-/**
- * A widget displaying a single row of a GtkTreeModel
- *
- * A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
- * and `GtkCellAreaContext`. A `GtkCellAreaContext` can be provided to the
- * `GtkCellView` at construction time in order to keep the cellview in context
- * of a group of cell views, this ensures that the renderers displayed will
- * be properly aligned with each other (like the aligned cells in the menus
- * of `GtkComboBox`).
- *
- * `GtkCellView` is `GtkOrientable` in order to decide in which orientation
- * the underlying `GtkCellAreaContext` should be allocated. Taking the `GtkComboBox`
- * menu as an example, cellviews should be oriented horizontally if the menus are
- * listed top-to-bottom and thus all share the same width but may have separate
- * individual heights (left-to-right menus should be allocated vertically since
- * they all share the same height but may have variable widths).
- *
- * ## CSS nodes
- *
- * GtkCellView has a single CSS node with name cellview.
- */
 export declare class CellView extends Widget {
     /**
      * Creates a new `GtkCellView` widget.
@@ -204,6 +184,19 @@ export declare class CellView extends Widget {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "destroy", handler: (self: CellView) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: CellView, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: CellView) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: CellView, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: CellView) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: CellView, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: CellView, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: CellView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: CellView) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: CellView) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: CellView, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: CellView) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: CellView) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CellView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -4,6 +4,7 @@ import { TreePath } from "./tree-path.js";
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * A widget displaying a single row of a GtkTreeModel
@@ -26,6 +27,44 @@ import { Widget } from "./widget.js";
  *
  * GtkCellView has a single CSS node with name cellview.
  */
+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 CellView extends Widget {
     /**
      * Creates a new `GtkCellView` widget.
@@ -484,12 +523,24 @@ export class CellView 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], CellView);
-            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/center-box.d.ts

@@ -1,43 +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 three children in a row, keeping the middle child
- * centered as well as possible.
- *
- *
- *
- * To add children to `GtkCenterBox`, use [method@Gtk.CenterBox.set_start_widget],
- * [method@Gtk.CenterBox.set_center_widget] and
- * [method@Gtk.CenterBox.set_end_widget].
- *
- * The sizing and positioning of children can be influenced with the
- * align and expand properties of the children.
- *
- * # GtkCenterBox as GtkBuildable
- *
- * The `GtkCenterBox` implementation of the `GtkBuildable` interface
- * supports placing children in the 3 positions by specifying “start”, “center”
- * or “end” as the “type” attribute of a `<child>` element.
- *
- * # CSS nodes
- *
- * `GtkCenterBox` uses a single CSS node with the name “box”,
- *
- * The first child of the `GtkCenterBox` will be allocated depending on the
- * text direction, i.e. in left-to-right layouts it will be allocated on the
- * left and in right-to-left layouts on the right.
- *
- * In vertical orientation, the nodes of the children are arranged from top to
- * bottom.
- *
- * # Accessibility
- *
- * Until GTK 4.10, `GtkCenterBox` used the [enum@Gtk.AccessibleRole.group] role.
- *
- * Starting from GTK 4.12, `GtkCenterBox` uses the [enum@Gtk.AccessibleRole.generic]
- * role.
- */
 export declare class CenterBox extends Widget {
     /**
      * Creates a new `GtkCenterBox`.
@@ -119,6 +83,19 @@ export declare class CenterBox extends Widget {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "destroy", handler: (self: CenterBox) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: CenterBox, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: CenterBox) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: CenterBox, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: CenterBox) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: CenterBox, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: CenterBox, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: CenterBox, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: CenterBox) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: CenterBox) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: CenterBox, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: CenterBox) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: CenterBox) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CenterBox, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/center-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 three children in a row, keeping the middle child
@@ -38,6 +39,44 @@ import { Widget } from "./widget.js";
  * Starting from GTK 4.12, `GtkCenterBox` 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 CenterBox extends Widget {
     /**
      * Creates a new `GtkCenterBox`.
@@ -247,12 +286,24 @@ export class CenterBox 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], CenterBox);
-            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/center-layout.d.ts

@@ -1,5 +1,6 @@
 import { BaselinePosition, Orientation } from "./enums.js";
 import { Widget } from "./widget.js";
+import * as GObject from "../gobject/index.js";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Manages up to three children.
@@ -83,4 +84,6 @@ export declare class CenterLayout extends LayoutManager {
      * @param widget - the new start widget
      */
     setStartWidget(widget?: Widget | null): void;
+    connect(signal: "notify", handler: (self: CenterLayout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -211,4 +211,22 @@ export class CenterLayout 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], CenterLayout);
+            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/check-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";
@@ -156,6 +158,19 @@ export declare class CheckButton extends Widget {
     setDetailedActionName(detailedActionName: string): void;
     connect(signal: "activate", handler: (self: CheckButton) => void, after?: boolean): number;
     connect(signal: "toggled", handler: (self: CheckButton) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: CheckButton) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: CheckButton, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: CheckButton) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: CheckButton, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: CheckButton) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: CheckButton, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: CheckButton, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: CheckButton, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: CheckButton) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: CheckButton) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: CheckButton, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: CheckButton) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: CheckButton) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CheckButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/check-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";
 /**
@@ -70,6 +71,42 @@ import { Widget } from "./widget.js";
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     toggled: { 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 CheckButton extends Widget {
     /**