@gtkx/ffi 0.1.46 → 0.1.48

package/dist/generated/gtk/column-view-sorter.d.ts

@@ -1,41 +1,8 @@
 import { Ref } from "@gtkx/native";
-import { SortType } from "./enums.js";
+import { SortType, SorterChange } from "./enums.js";
 import { ColumnViewColumn } from "./column-view-column.js";
 import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
-/**
- * Sorts [class@Gtk.ColumnView] columns.
- *
- * The sorter returned by [method@Gtk.ColumnView.get_sorter] is
- * a `GtkColumnViewSorter`.
- *
- * In column views, sorting can be configured by associating
- * sorters with columns, and users can invert sort order by clicking
- * on column headers. The API of `GtkColumnViewSorter` is designed
- * to allow saving and restoring this configuration.
- *
- * If you are only interested in the primary sort column (i.e. the
- * column where a sort indicator is shown in the header), then
- * you can just look at [property@Gtk.ColumnViewSorter:primary-sort-column]
- * and [property@Gtk.ColumnViewSorter:primary-sort-order].
- *
- * If you want to store the full sort configuration, including
- * secondary sort columns that are used for tie breaking, then
- * you can use [method@Gtk.ColumnViewSorter.get_nth_sort_column].
- * To get notified about changes, use [signal@Gtk.Sorter::changed].
- *
- * To restore a saved sort configuration on a `GtkColumnView`,
- * use code like:
- *
- * ```
- * sorter = gtk_column_view_get_sorter (view);
- * for (i = gtk_column_view_sorter_get_n_sort_columns (sorter) - 1; i >= 0; i--)
- * {
- * column = gtk_column_view_sorter_get_nth_sort_column (sorter, i, &order);
- * gtk_column_view_sort_by_column (view, column, order);
- * }
- * ```
- */
 export declare class ColumnViewSorter extends Sorter {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
@@ -77,6 +44,7 @@ export declare class ColumnViewSorter extends Sorter {
      * `GTK_SORT_ASCENDING`.
      */
     getPrimarySortOrder(): SortType;
+    connect(signal: "changed", handler: (self: ColumnViewSorter, change: SorterChange) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ColumnViewSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -35,6 +35,12 @@ import { Sorter } from "./sorter.js";
  * }
  * ```
  */
+const SIGNAL_META = {
+    changed: {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+};
 export class ColumnViewSorter extends Sorter {
     constructor(...args) {
         super(...args);
@@ -134,12 +140,24 @@ export class ColumnViewSorter extends Sorter {
         ], { type: "int", size: 32, unsigned: false });
     }
     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], ColumnViewSorter);
-            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/column-view.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from "@gtkx/native";
-import { ListScrollFlags, ListTabBehavior, ScrollablePolicy, SortType } from "./enums.js";
+import { DirectionType, ListScrollFlags, ListTabBehavior, ScrollablePolicy, SortType, StateFlags, TextDirection } from "./enums.js";
 import { Border } from "./border.js";
 import { ScrollInfo } from "./scroll-info.js";
 import { Adjustment } from "./adjustment.js";
@@ -7,6 +7,7 @@ import { ColumnViewColumn } from "./column-view-column.js";
 import { ListItemFactory } from "./list-item-factory.js";
 import { SelectionModel } from "./selection-model.js";
 import { Sorter } from "./sorter.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
@@ -253,6 +254,19 @@ export declare class ColumnView extends Widget {
      */
     setVscrollPolicy(policy: ScrollablePolicy): void;
     connect(signal: "activate", handler: (self: ColumnView, position: number) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: ColumnView) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: ColumnView, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: ColumnView) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: ColumnView, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: ColumnView) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: ColumnView, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: ColumnView, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: ColumnView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: ColumnView) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: ColumnView) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: ColumnView, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: ColumnView) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: ColumnView) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ColumnView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -4,6 +4,7 @@ import { Adjustment } from "./adjustment.js";
 import { ListItemFactory } from "./list-item-factory.js";
 import { SelectionModel } from "./selection-model.js";
 import { Sorter } from "./sorter.js";
+import { Tooltip } from "./tooltip.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -77,6 +78,42 @@ const SIGNAL_META = {
         params: [{ type: { type: "int", size: 32, unsigned: true } }],
         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 ColumnView extends Widget {
     constructor(...args) {

package/dist/generated/gtk/combo-box-text.d.ts

@@ -1,4 +1,5 @@
-import { ScrollType } from "./enums.js";
+import { DirectionType, ScrollType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { ComboBox } from "./combo-box.js";
 export declare class ComboBoxText extends ComboBox {
@@ -96,6 +97,19 @@ export declare class ComboBoxText extends ComboBox {
     connect(signal: "move-active", handler: (self: ComboBoxText, scrollType: ScrollType) => void, after?: boolean): number;
     connect(signal: "popdown", handler: (self: ComboBoxText) => boolean, after?: boolean): number;
     connect(signal: "popup", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: ComboBoxText, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: ComboBoxText, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: ComboBoxText, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: ComboBoxText, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: ComboBoxText, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: ComboBoxText, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: ComboBoxText) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: ComboBoxText) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ComboBoxText, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import { ComboBox } from "./combo-box.js";
 /**
  * A `GtkComboBoxText` is a simple variant of `GtkComboBox` for text-only
@@ -71,6 +72,42 @@ const SIGNAL_META = {
     },
     popdown: { params: [], returnType: { type: "boolean" } },
     popup: { 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 ComboBoxText extends ComboBox {
     /**

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

@@ -1,9 +1,10 @@
 import { Ref } from "@gtkx/native";
-import { ScrollType, SensitivityType } from "./enums.js";
+import { DirectionType, ScrollType, SensitivityType, StateFlags, TextDirection } from "./enums.js";
 import { TreeIter } from "./tree-iter.js";
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
@@ -315,6 +316,19 @@ export declare class ComboBox extends Widget {
     connect(signal: "move-active", handler: (self: ComboBox, scrollType: ScrollType) => void, after?: boolean): number;
     connect(signal: "popdown", handler: (self: ComboBox) => boolean, after?: boolean): number;
     connect(signal: "popup", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: ComboBox, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: ComboBox, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: ComboBox, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: ComboBox, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: ComboBox, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: ComboBox, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: ComboBox) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: ComboBox) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ComboBox, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -3,6 +3,7 @@ import { getObject } from "@gtkx/ffi";
 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 `GtkComboBox` is a widget that allows the user to choose from a list of
@@ -79,6 +80,42 @@ const SIGNAL_META = {
     },
     popdown: { params: [], returnType: { type: "boolean" } },
     popup: { 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 ComboBox extends Widget {
     /**

package/dist/generated/gtk/constraint-layout-child.d.ts

@@ -1,6 +1,9 @@
+import * as GObject from "../gobject/index.js";
 import { LayoutChild } from "./layout-child.js";
 /** `GtkLayoutChild` subclass for children in a `GtkConstraintLayout`. */
 export declare class ConstraintLayoutChild extends LayoutChild {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: ConstraintLayoutChild, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/constraint-layout-child.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { LayoutChild } from "./layout-child.js";
 /** `GtkLayoutChild` subclass for children in a `GtkConstraintLayout`. */
 export class ConstraintLayoutChild extends LayoutChild {
@@ -12,4 +13,22 @@ export class ConstraintLayoutChild extends LayoutChild {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    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], ConstraintLayoutChild);
+            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/constraint-layout.d.ts

@@ -1,6 +1,7 @@
 import { Constraint } from "./constraint.js";
 import { ConstraintGuide } from "./constraint-guide.js";
 import * as GLib from "../glib/index.js";
+import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { LayoutManager } from "./layout-manager.js";
 /**
@@ -334,4 +335,6 @@ export declare class ConstraintLayout extends LayoutManager {
      * of the `<object>` tag used to construct the @buildable.
      */
     getBuildableId(): string | null;
+    connect(signal: "notify", handler: (self: ConstraintLayout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -468,4 +468,22 @@ export class ConstraintLayout extends LayoutManager {
             },
         ], { type: "string", borrowed: true });
     }
+    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], ConstraintLayout);
+            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/custom-filter.d.ts

@@ -1,6 +1,6 @@
+import { FilterChange } from "./enums.js";
 import * as GObject from "../gobject/index.js";
 import { Filter } from "./filter.js";
-/** Determines whether to include items with a callback. */
 export declare class CustomFilter extends Filter {
     /**
      * Creates a new filter using the given function to filter items.
@@ -30,6 +30,7 @@ export declare class CustomFilter extends Filter {
      * @param userDestroy - destroy notify for @user_data
      */
     setFilterFunc(userDestroy: () => void, matchFunc?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    connect(signal: "changed", handler: (self: CustomFilter, change: FilterChange) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CustomFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -2,6 +2,12 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Filter } from "./filter.js";
 /** Determines whether to include items with a callback. */
+const SIGNAL_META = {
+    changed: {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+};
 export class CustomFilter extends Filter {
     constructor(...args) {
         super(...args);
@@ -61,12 +67,24 @@ export class CustomFilter 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], CustomFilter);
-            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/custom-layout.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Uses closures for size negotiation.
@@ -21,4 +22,6 @@ export declare class CustomLayout extends LayoutManager {
     constructor(measure: (...args: unknown[]) => unknown, allocate: (...args: unknown[]) => unknown, requestMode?: (...args: unknown[]) => unknown | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: CustomLayout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Uses closures for size negotiation.
@@ -30,4 +31,22 @@ export class CustomLayout extends LayoutManager {
             },
         ], { 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], CustomLayout);
+            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/custom-sorter.d.ts

@@ -1,6 +1,6 @@
+import { SorterChange } from "./enums.js";
 import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
-/** Sorts items via a callback function. */
 export declare class CustomSorter extends Sorter {
     /**
      * Creates a new `GtkSorter` that works by calling
@@ -11,7 +11,7 @@ export declare class CustomSorter extends Sorter {
      * @param userData - user data to pass to @sort_func
      * @param userDestroy - destroy notify for @user_data
      */
-    constructor(sortFunc?: (...args: unknown[]) => unknown | null, userData?: number | null, userDestroy?: () => void | null);
+    constructor(sortFunc?: (a: unknown, b: unknown) => number | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
     /**
@@ -28,7 +28,8 @@ export declare class CustomSorter extends Sorter {
      * @param userData - user data to pass to @match_func
      * @param userDestroy - destroy notify for @user_data
      */
-    setSortFunc(userDestroy: () => void, sortFunc?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    setSortFunc(sortFunc?: (a: unknown, b: unknown) => number | null): void;
+    connect(signal: "changed", handler: (self: CustomSorter, change: SorterChange) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: CustomSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -2,28 +2,31 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Sorter } from "./sorter.js";
 /** Sorts items via a callback function. */
+const SIGNAL_META = {
+    changed: {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+};
 export class CustomSorter extends Sorter {
     constructor(...args) {
         super(...args);
     }
     createPtr(args) {
-        const [sortFunc, userData, userDestroy] = args;
+        const [sortFunc] = args;
         return call("libgtk-4.so.1", "gtk_custom_sorter_new", [
             {
-                type: { type: "callback" },
+                type: {
+                    type: "callback",
+                    trampoline: "compareDataFunc",
+                    argTypes: [
+                        { type: "gobject", borrowed: true },
+                        { type: "gobject", borrowed: true },
+                    ],
+                },
                 value: sortFunc,
                 optional: true,
             },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: userDestroy,
-                optional: true,
-            },
         ], { type: "gobject", borrowed: false });
     }
     /**
@@ -40,35 +43,45 @@ export class CustomSorter extends Sorter {
      * @param userData - user data to pass to @match_func
      * @param userDestroy - destroy notify for @user_data
      */
-    setSortFunc(userDestroy, sortFunc, userData) {
+    setSortFunc(sortFunc) {
         call("libgtk-4.so.1", "gtk_custom_sorter_set_sort_func", [
             {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
             {
-                type: { type: "callback" },
+                type: {
+                    type: "callback",
+                    trampoline: "compareDataFunc",
+                    argTypes: [
+                        { type: "gobject", borrowed: true },
+                        { type: "gobject", borrowed: true },
+                    ],
+                },
                 value: sortFunc,
                 optional: true,
             },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: userDestroy,
-            },
         ], { 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], CustomSorter);
-            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 },