@gtkx/ffi 0.1.46 → 0.1.48

package/dist/generated/gtk/shortcuts-shortcut.d.ts

@@ -1,14 +1,23 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * A `GtkShortcutsShortcut` represents a single keyboard shortcut or gesture
- * with a short text.
- *
- * This widget is only meant to be used with `GtkShortcutsWindow`.
- */
 export declare class ShortcutsShortcut extends Widget {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "destroy", handler: (self: ShortcutsShortcut) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: ShortcutsShortcut, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: ShortcutsShortcut) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: ShortcutsShortcut, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: ShortcutsShortcut) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: ShortcutsShortcut, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: ShortcutsShortcut, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: ShortcutsShortcut, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: ShortcutsShortcut) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: ShortcutsShortcut) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: ShortcutsShortcut, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: ShortcutsShortcut) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: ShortcutsShortcut) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ShortcutsShortcut, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/shortcuts-shortcut.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";
 /**
  * A `GtkShortcutsShortcut` represents a single keyboard shortcut or gesture
@@ -7,6 +8,44 @@ import { Widget } from "./widget.js";
  *
  * This widget is only meant to be used with `GtkShortcutsWindow`.
  */
+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 ShortcutsShortcut extends Widget {
     constructor(...args) {
         super(...args);
@@ -23,12 +62,24 @@ export class ShortcutsShortcut extends Widget {
         ], { type: "gobject", borrowed: true });
     }
     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], ShortcutsShortcut);
-            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/shortcuts-window.d.ts

@@ -1,4 +1,6 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
 import { ShortcutsSection } from "./shortcuts-section.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Window } from "./window.js";
 export declare class ShortcutsWindow extends Window {
@@ -22,6 +24,19 @@ export declare class ShortcutsWindow extends Window {
     connect(signal: "close-request", handler: (self: ShortcutsWindow) => boolean, after?: boolean): number;
     connect(signal: "enable-debugging", handler: (self: ShortcutsWindow, toggle: boolean) => boolean, after?: boolean): number;
     connect(signal: "keys-changed", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: ShortcutsWindow, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: ShortcutsWindow, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: ShortcutsWindow, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: ShortcutsWindow, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: ShortcutsWindow, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: ShortcutsWindow, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: ShortcutsWindow) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ShortcutsWindow, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/shortcuts-window.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import { Window } from "./window.js";
 /**
  * A `GtkShortcutsWindow` shows information about the keyboard shortcuts
@@ -72,6 +73,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 ShortcutsWindow extends Window {
     constructor(...args) {

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

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { ShortcutAction } from "./shortcut-action.js";
 /**
  * Emits a signal on a widget.
@@ -20,4 +21,6 @@ export declare class SignalAction extends ShortcutAction {
      * Returns the name of the signal that will be emitted.
      */
     getSignalName(): string;
+    connect(signal: "notify", handler: (self: SignalAction, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { ShortcutAction } from "./shortcut-action.js";
 /**
  * Emits a signal on a widget.
@@ -30,4 +31,22 @@ export class SignalAction extends ShortcutAction {
             },
         ], { 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], SignalAction);
+            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/spin-button.d.ts

@@ -1,7 +1,8 @@
 import { Ref } from "@gtkx/native";
-import { AccessiblePlatformState, Orientation, ScrollType, SpinButtonUpdatePolicy, SpinType } from "./enums.js";
+import { AccessiblePlatformState, DirectionType, Orientation, ScrollType, SpinButtonUpdatePolicy, SpinType, StateFlags, TextDirection } from "./enums.js";
 import { Adjustment } from "./adjustment.js";
 import { Editable } from "./editable.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";
@@ -449,6 +450,19 @@ export declare class SpinButton extends Widget {
     connect(signal: "output", handler: (self: SpinButton) => boolean, after?: boolean): number;
     connect(signal: "value-changed", handler: (self: SpinButton) => void, after?: boolean): number;
     connect(signal: "wrapped", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: SpinButton, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: SpinButton, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: SpinButton, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: SpinButton, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: SpinButton, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: SpinButton, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: SpinButton) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: SpinButton) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: SpinButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/spin-button.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { Editable } from "./editable.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Allows to enter or change numeric values.
@@ -135,6 +136,42 @@ const SIGNAL_META = {
     output: { params: [], returnType: { type: "boolean" } },
     "value-changed": { params: [], returnType: { type: "undefined" } },
     wrapped: { 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 SpinButton extends Widget {
     constructor(...args) {

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

@@ -1,26 +1,7 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Displays an icon-size spinning animation.
- *
- * It is often used as an alternative to a [class@Gtk.ProgressBar]
- * for displaying indefinite activity, instead of actual progress.
- *
- *
- *
- * To start the animation, use [method@Gtk.Spinner.start], to stop it
- * use [method@Gtk.Spinner.stop].
- *
- * # CSS nodes
- *
- * `GtkSpinner` has a single CSS node with the name spinner.
- * When the animation is active, the :checked pseudoclass is
- * added to this node.
- *
- * # Accessibility
- *
- * `GtkSpinner` uses the [enum@Gtk.AccessibleRole.progress_bar] role.
- */
 export declare class Spinner extends Widget {
     /**
      * Returns a new spinner widget. Not yet started.
@@ -44,6 +25,19 @@ export declare class Spinner extends Widget {
      * Stops the animation of the spinner.
      */
     stop(): void;
+    connect(signal: "destroy", handler: (self: Spinner) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Spinner, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Spinner) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Spinner, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Spinner) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Spinner, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Spinner, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Spinner, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Spinner) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Spinner) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Spinner, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Spinner) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Spinner) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Spinner, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/spinner.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";
 /**
  * Displays an icon-size spinning animation.
@@ -22,6 +23,44 @@ import { Widget } from "./widget.js";
  *
  * `GtkSpinner` uses the [enum@Gtk.AccessibleRole.progress_bar] 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 Spinner extends Widget {
     /**
      * Returns a new spinner widget. Not yet started.
@@ -85,12 +124,24 @@ export class Spinner 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], Spinner);
-            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/stack-sidebar.d.ts

@@ -1,25 +1,8 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
 import { Stack } from "./stack.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Uses a sidebar to switch between `GtkStack` pages.
- *
- *
- *
- * In order to use a `GtkStackSidebar`, you simply use a `GtkStack` to
- * organize your UI flow, and add the sidebar to your sidebar area. You
- * can use [method@Gtk.StackSidebar.set_stack] to connect the `GtkStackSidebar`
- * to the `GtkStack`.
- *
- * # CSS nodes
- *
- * `GtkStackSidebar` has a single CSS node with name stacksidebar and
- * style class .sidebar.
- *
- * When circumstances require it, `GtkStackSidebar` adds the
- * .needs-attention style class to the widgets representing the stack
- * pages.
- */
 export declare class StackSidebar extends Widget {
     /**
      * Creates a new `GtkStackSidebar`.
@@ -38,6 +21,19 @@ export declare class StackSidebar extends Widget {
      * @param stack - a `GtkStack`
      */
     setStack(stack: Stack): void;
+    connect(signal: "destroy", handler: (self: StackSidebar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: StackSidebar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: StackSidebar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: StackSidebar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: StackSidebar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: StackSidebar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: StackSidebar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: StackSidebar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: StackSidebar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: StackSidebar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: StackSidebar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: StackSidebar) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: StackSidebar) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: StackSidebar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/stack-sidebar.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Stack } from "./stack.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Uses a sidebar to switch between `GtkStack` pages.
@@ -21,6 +22,44 @@ import { Widget } from "./widget.js";
  * .needs-attention style class to the widgets representing the stack
  * pages.
  */
+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 StackSidebar extends Widget {
     /**
      * Creates a new `GtkStackSidebar`.
@@ -68,12 +107,24 @@ export class StackSidebar 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], StackSidebar);
-            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/stack-switcher.d.ts

@@ -1,41 +1,8 @@
-import { Orientation } from "./enums.js";
+import { DirectionType, Orientation, StateFlags, TextDirection } from "./enums.js";
 import { Stack } from "./stack.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Shows a row of buttons to switch between `GtkStack` pages.
- *
- *
- *
- * It acts as a controller for the associated `GtkStack`.
- *
- * All the content for the buttons comes from the properties of the stacks
- * [class@Gtk.StackPage] objects; the button visibility in a `GtkStackSwitcher`
- * widget is controlled by the visibility of the child in the `GtkStack`.
- *
- * It is possible to associate multiple `GtkStackSwitcher` widgets
- * with the same `GtkStack` widget.
- *
- * # CSS nodes
- *
- * `GtkStackSwitcher` has a single CSS node named stackswitcher and
- * style class .stack-switcher.
- *
- * When circumstances require it, `GtkStackSwitcher` adds the
- * .needs-attention style class to the widgets representing the
- * stack pages.
- *
- * # Accessibility
- *
- * `GtkStackSwitcher` uses the [enum@Gtk.AccessibleRole.tab_list] role
- * and uses the [enum@Gtk.AccessibleRole.tab] role for its buttons.
- *
- * # Orientable
- *
- * Since GTK 4.4, `GtkStackSwitcher` implements `GtkOrientable` allowing
- * the stack switcher to be made vertical with
- * `gtk_orientable_set_orientation()`.
- */
 export declare class StackSwitcher extends Widget {
     /**
      * Create a new `GtkStackSwitcher`.
@@ -60,6 +27,19 @@ export declare class StackSwitcher extends Widget {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "destroy", handler: (self: StackSwitcher) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: StackSwitcher, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: StackSwitcher) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: StackSwitcher, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: StackSwitcher) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: StackSwitcher, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: StackSwitcher, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: StackSwitcher, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: StackSwitcher) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: StackSwitcher) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: StackSwitcher, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: StackSwitcher) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: StackSwitcher) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: StackSwitcher, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }