@gtkx/ffi 0.1.46 → 0.1.48

package/dist/generated/gtk/range.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Base class for widgets which visualize an adjustment.
@@ -35,6 +36,42 @@ const SIGNAL_META = {
         returnType: { type: "undefined" },
     },
     "value-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 Range extends Widget {
     constructor(...args) {

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

@@ -1,29 +1,7 @@
-import { RevealerTransitionType } from "./enums.js";
+import { DirectionType, RevealerTransitionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Animates the transition of its child from invisible to visible.
- *
- * The style of transition can be controlled with
- * [method@Gtk.Revealer.set_transition_type].
- *
- * These animations respect the [property@Gtk.Settings:gtk-enable-animations]
- * setting.
- *
- * # CSS nodes
- *
- * `GtkRevealer` has a single CSS node with name revealer.
- * When styling `GtkRevealer` using CSS, remember that it only hides its contents,
- * not itself. That means applied margin, padding and borders will be visible even
- * when the [property@Gtk.Revealer:reveal-child] property is set to %FALSE.
- *
- * # Accessibility
- *
- * `GtkRevealer` uses the [enum@Gtk.AccessibleRole.group] role.
- *
- * The child of `GtkRevealer`, if set, is always available in the accessibility
- * tree, regardless of the state of the revealer widget.
- */
 export declare class Revealer extends Widget {
     /**
      * Creates a new `GtkRevealer`.
@@ -86,6 +64,19 @@ export declare class Revealer extends Widget {
      * @param transition - the new transition type
      */
     setTransitionType(transition: RevealerTransitionType): void;
+    connect(signal: "destroy", handler: (self: Revealer) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Revealer, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Revealer) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Revealer, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Revealer) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Revealer, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Revealer, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Revealer, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Revealer) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Revealer) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Revealer, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Revealer) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Revealer) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Revealer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/revealer.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";
 /**
  * Animates the transition of its child from invisible to visible.
@@ -24,6 +25,44 @@ import { Widget } from "./widget.js";
  * The child of `GtkRevealer`, if set, is always available in the accessibility
  * tree, regardless of the state of the revealer widget.
  */
+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 Revealer extends Widget {
     /**
      * Creates a new `GtkRevealer`.
@@ -177,12 +216,24 @@ export class Revealer 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], Revealer);
-            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/scale-button.d.ts

@@ -1,6 +1,7 @@
-import { Orientation } from "./enums.js";
+import { DirectionType, Orientation, StateFlags, TextDirection } from "./enums.js";
 import { Adjustment } from "./adjustment.js";
 import { Button } from "./button.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class ScaleButton extends Widget {
@@ -91,6 +92,19 @@ export declare class ScaleButton extends Widget {
     connect(signal: "popdown", handler: (self: ScaleButton) => void, after?: boolean): number;
     connect(signal: "popup", handler: (self: ScaleButton) => void, after?: boolean): number;
     connect(signal: "value-changed", handler: (self: ScaleButton, value: number) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: ScaleButton) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: ScaleButton, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: ScaleButton) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: ScaleButton, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: ScaleButton) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: ScaleButton, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: ScaleButton, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: ScaleButton, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: ScaleButton) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: ScaleButton) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: ScaleButton, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: ScaleButton) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: ScaleButton) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ScaleButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { Button } from "./button.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Provides a button which pops up a scale widget.
@@ -34,6 +35,42 @@ const SIGNAL_META = {
         params: [{ type: { type: "float", size: 64 } }],
         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 ScaleButton extends Widget {
     constructor(...args) {

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

@@ -1,6 +1,7 @@
 import { Ref } from "@gtkx/native";
-import { Orientation, PositionType, ScrollType } from "./enums.js";
+import { DirectionType, Orientation, PositionType, ScrollType, StateFlags, TextDirection } from "./enums.js";
 import { Adjustment } from "./adjustment.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Pango from "../pango/index.js";
 import { Range } from "./range.js";
@@ -141,6 +142,19 @@ export declare class Scale extends Range {
     connect(signal: "change-value", handler: (self: Scale, scroll: ScrollType, value: number) => boolean, after?: boolean): number;
     connect(signal: "move-slider", handler: (self: Scale, step: ScrollType) => void, after?: boolean): number;
     connect(signal: "value-changed", handler: (self: Scale) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: Scale) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Scale, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Scale) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Scale, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Scale) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Scale, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Scale, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Scale, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Scale) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Scale) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Scale, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Scale) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Scale) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Scale, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/scale.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as Pango from "../pango/index.js";
 import { Range } from "./range.js";
 /**
@@ -110,6 +111,42 @@ const SIGNAL_META = {
         returnType: { type: "undefined" },
     },
     "value-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 Scale extends Range {
     constructor(...args) {

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

@@ -1,51 +1,8 @@
-import { Orientation } from "./enums.js";
+import { DirectionType, Orientation, StateFlags, TextDirection } from "./enums.js";
 import { Adjustment } from "./adjustment.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Shows a horizontal or vertical scrollbar.
- *
- *
- *
- * Its position and movement are controlled by the adjustment that is passed to
- * or created by [ctor@Gtk.Scrollbar.new]. See [class@Gtk.Adjustment] for more
- * details. The [property@Gtk.Adjustment:value] field sets the position of the
- * thumb and must be between [property@Gtk.Adjustment:lower] and
- * [property@Gtk.Adjustment:upper] - [property@Gtk.Adjustment:page-size].
- * The [property@Gtk.Adjustment:page-size] represents the size of the visible
- * scrollable area.
- *
- * The fields [property@Gtk.Adjustment:step-increment] and
- * [property@Gtk.Adjustment:page-increment] fields are added to or subtracted
- * from the [property@Gtk.Adjustment:value] when the user asks to move by a step
- * (using e.g. the cursor arrow keys) or by a page (using e.g. the Page Down/Up
- * keys).
- *
- * # CSS nodes
- *
- * ```
- * scrollbar
- * ╰── range[.fine-tune]
- * ╰── trough
- * ╰── slider
- * ```
- *
- * `GtkScrollbar` has a main CSS node with name scrollbar and a subnode for its
- * contents. The main node gets the .horizontal or .vertical style classes applied,
- * depending on the scrollbar's orientation.
- *
- * The range node gets the style class .fine-tune added when the scrollbar is
- * in 'fine-tuning' mode.
- *
- * Other style classes that may be added to scrollbars inside
- * [class@Gtk.ScrolledWindow] include the positional classes (.left, .right,
- * .top, .bottom) and style classes related to overlay scrolling (.overlay-indicator,
- * .dragging, .hovering).
- *
- * # Accessibility
- *
- * `GtkScrollbar` uses the [enum@Gtk.AccessibleRole.scrollbar] role.
- */
 export declare class Scrollbar extends Widget {
     /**
      * Creates a new scrollbar with the given orientation.
@@ -73,6 +30,19 @@ export declare class Scrollbar extends Widget {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "destroy", handler: (self: Scrollbar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Scrollbar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Scrollbar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Scrollbar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Scrollbar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Scrollbar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Scrollbar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Scrollbar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Scrollbar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Scrollbar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Scrollbar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Scrollbar) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Scrollbar) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Scrollbar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/scrollbar.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Shows a horizontal or vertical scrollbar.
@@ -46,6 +47,44 @@ import { Widget } from "./widget.js";
  *
  * `GtkScrollbar` uses the [enum@Gtk.AccessibleRole.scrollbar] 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 Scrollbar extends Widget {
     constructor(...args) {
         super(...args);
@@ -121,12 +160,24 @@ export class Scrollbar 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], Scrollbar);
-            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/scrolled-window.d.ts

@@ -1,6 +1,7 @@
 import { Ref } from "@gtkx/native";
-import { CornerType, DirectionType, PolicyType, PositionType, ScrollType } from "./enums.js";
+import { CornerType, DirectionType, PolicyType, PositionType, ScrollType, StateFlags, TextDirection } from "./enums.js";
 import { Adjustment } from "./adjustment.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class ScrolledWindow extends Widget {
@@ -221,6 +222,19 @@ export declare class ScrolledWindow extends Widget {
     connect(signal: "edge-reached", handler: (self: ScrolledWindow, pos: PositionType) => void, after?: boolean): number;
     connect(signal: "move-focus-out", handler: (self: ScrolledWindow, directionType: DirectionType) => void, after?: boolean): number;
     connect(signal: "scroll-child", handler: (self: ScrolledWindow, scroll: ScrollType, horizontal: boolean) => boolean, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: ScrolledWindow) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: ScrolledWindow, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: ScrolledWindow) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: ScrolledWindow, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: ScrolledWindow) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: ScrolledWindow, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: ScrolledWindow, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: ScrolledWindow, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: ScrolledWindow) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: ScrolledWindow) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: ScrolledWindow, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: ScrolledWindow) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: ScrolledWindow) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: ScrolledWindow, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Makes its child scrollable.
@@ -101,6 +102,42 @@ const SIGNAL_META = {
         ],
         returnType: { type: "boolean" },
     },
+    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 ScrolledWindow extends Widget {
     /**

package/dist/generated/gtk/search-bar.d.ts

@@ -1,58 +1,8 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
 import { Editable } from "./editable.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Reveals a search entry when search is started.
- *
- *
- *
- * It can also contain additional widgets, such as drop-down menus,
- * or buttons.  The search bar would appear when a search is started
- * through typing on the keyboard, or the application’s search mode
- * is toggled on.
- *
- * For keyboard presses to start a search, the search bar must be told
- * of a widget to capture key events from through
- * [method@Gtk.SearchBar.set_key_capture_widget]. This widget will
- * typically be the top-level window, or a parent container of the
- * search bar. Common shortcuts such as Ctrl+F should be handled as an
- * application action, or through the menu items.
- *
- * You will also need to tell the search bar about which entry you
- * are using as your search entry using [method@Gtk.SearchBar.connect_entry].
- *
- * ## Creating a search bar
- *
- * The following example shows you how to create a more complex search
- * entry.
- *
- * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/search-bar.c)
- *
- * # Shortcuts and Gestures
- *
- * `GtkSearchBar` supports the following keyboard shortcuts:
- *
- * - `Escape` hides the search bar.
- *
- * # CSS nodes
- *
- * ```
- * searchbar
- * ╰── revealer
- * ╰── box
- * ├── [child]
- * ╰── [button.close]
- * ```
- *
- * `GtkSearchBar` has a main CSS node with name searchbar. It has a child
- * node with name revealer that contains a node with name box. The box node
- * contains both the CSS node of the child widget as well as an optional button
- * node which gets the .close style class applied.
- *
- * # Accessibility
- *
- * `GtkSearchBar` uses the [enum@Gtk.AccessibleRole.search] role.
- */
 export declare class SearchBar extends Widget {
     /**
      * Creates a `GtkSearchBar`.
@@ -123,6 +73,19 @@ export declare class SearchBar extends Widget {
      * @param visible - whether the close button will be shown or not
      */
     setShowCloseButton(visible: boolean): void;
+    connect(signal: "destroy", handler: (self: SearchBar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: SearchBar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: SearchBar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: SearchBar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: SearchBar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: SearchBar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: SearchBar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: SearchBar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: SearchBar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: SearchBar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: SearchBar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: SearchBar) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: SearchBar) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: SearchBar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }