@gtkx/ffi 0.1.47 → 0.1.48

package/dist/generated/gtk/font-dialog-button.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { FontDialog } from "./font-dialog.js";
+import { Tooltip } from "./tooltip.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -23,6 +24,42 @@ import { Widget } from "./widget.js";
  */
 const SIGNAL_META = {
     activate: { 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 FontDialogButton extends Widget {
     constructor(...args) {

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

@@ -1,48 +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";
-/**
- * Surrounds its child with a decorative frame and an optional label.
- *
- *
- *
- * If present, the label is drawn inside the top edge of the frame.
- * The horizontal position of the label can be controlled with
- * [method@Gtk.Frame.set_label_align].
- *
- * `GtkFrame` clips its child. You can use this to add rounded corners
- * to widgets, but be aware that it also cuts off shadows.
- *
- * # GtkFrame as GtkBuildable
- *
- * An example of a UI definition fragment with GtkFrame:
- *
- * ```xml
- * <object class="GtkFrame">
- * <property name="label-widget">
- * <object class="GtkLabel" id="frame_label"/>
- * </property>
- * <property name="child">
- * <object class="GtkEntry" id="frame_content"/>
- * </property>
- * </object>
- * ```
- *
- * # CSS nodes
- *
- * ```
- * frame
- * ├── <label widget>
- * ╰── <child>
- * ```
- *
- * `GtkFrame` has a main CSS node with name “frame”, which is used to draw the
- * visible border. You can set the appearance of the border using CSS properties
- * like “border-style” on this node.
- *
- * # Accessibility
- *
- * `GtkFrame` uses the [enum@Gtk.AccessibleRole.group] role.
- */
 export declare class Frame extends Widget {
     /**
      * Creates a new `GtkFrame`, with optional label @label.
@@ -98,6 +57,19 @@ export declare class Frame extends Widget {
      * @param labelWidget - the new label widget
      */
     setLabelWidget(labelWidget?: Widget | null): void;
+    connect(signal: "destroy", handler: (self: Frame) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Frame, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Frame) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Frame, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Frame) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Frame, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Frame, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Frame, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Frame) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Frame) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Frame, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Frame) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Frame) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Frame, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/frame.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";
 /**
  * Surrounds its child with a decorative frame and an optional label.
@@ -44,6 +45,44 @@ import { Widget } from "./widget.js";
  *
  * `GtkFrame` uses the [enum@Gtk.AccessibleRole.group] 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 Frame extends Widget {
     constructor(...args) {
         super(...args);
@@ -185,12 +224,24 @@ export class Frame 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], Frame);
-            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/glarea.d.ts

@@ -1,4 +1,6 @@
 import { Ref } from "@gtkx/native";
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
@@ -159,6 +161,19 @@ export declare class GLArea extends Widget {
     connect(signal: "create-context", handler: (self: GLArea) => Gdk.GLContext, after?: boolean): number;
     connect(signal: "render", handler: (self: GLArea, context: Gdk.GLContext) => boolean, after?: boolean): number;
     connect(signal: "resize", handler: (self: GLArea, width: number, height: number) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: GLArea) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: GLArea, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: GLArea) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: GLArea, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: GLArea) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: GLArea, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: GLArea, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: GLArea, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: GLArea) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: GLArea) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: GLArea, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: GLArea) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: GLArea) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: GLArea, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/glarea.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
@@ -139,6 +140,42 @@ const SIGNAL_META = {
         ],
         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 GLArea extends Widget {
     /**

package/dist/generated/gtk/graphics-offload.d.ts

@@ -1,43 +1,7 @@
-import { GraphicsOffloadEnabled } from "./enums.js";
+import { DirectionType, GraphicsOffloadEnabled, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Bypasses gsk rendering by passing the content of its child directly to the compositor.
- *
- * Graphics offload is an optimization to reduce overhead and battery use that is
- * most useful for video content. It only works on some platforms and in certain
- * situations. GTK will automatically fall back to normal rendering if it doesn't.
- *
- * Graphics offload is most efficient if there are no controls drawn on top of the
- * video content.
- *
- * You should consider using graphics offload for your main widget if it shows
- * frequently changing content (such as a video, or a VM display) and you provide
- * the content in the form of dmabuf textures (see [class@Gdk.DmabufTextureBuilder]),
- * in particular if it may be fullscreen.
- *
- * Numerous factors can prohibit graphics offload:
- *
- * - Unsupported platforms. Currently, graphics offload only works on Linux with Wayland.
- *
- * - Clipping, such as rounded corners that cause the video content to not be rectangular
- *
- * - Unsupported dmabuf formats (see [method@Gdk.Display.get_dmabuf_formats])
- *
- * - Translucent video content (content with an alpha channel, even if it isn't used)
- *
- * - Transforms that are more complex than translations and scales
- *
- * - Filters such as opacity, grayscale or similar
- *
- * To investigate problems related graphics offload, GTK offers debug flags to print
- * out information about graphics offload and dmabuf use:
- *
- * GDK_DEBUG=offload
- * GDK_DEBUG=dmabuf
- *
- * The GTK inspector provides a visual debugging tool for graphics offload.
- */
 export declare class GraphicsOffload extends Widget {
     /**
      * Creates a new GtkGraphicsOffload widget.
@@ -89,6 +53,19 @@ export declare class GraphicsOffload extends Widget {
      * @param enabled - whether to enable offload
      */
     setEnabled(enabled: GraphicsOffloadEnabled): void;
+    connect(signal: "destroy", handler: (self: GraphicsOffload) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: GraphicsOffload, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: GraphicsOffload) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: GraphicsOffload, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: GraphicsOffload) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: GraphicsOffload, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: GraphicsOffload, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: GraphicsOffload, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: GraphicsOffload) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: GraphicsOffload) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: GraphicsOffload, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: GraphicsOffload) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: GraphicsOffload) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: GraphicsOffload, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/graphics-offload.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";
 /**
  * Bypasses gsk rendering by passing the content of its child directly to the compositor.
@@ -38,6 +39,44 @@ import { Widget } from "./widget.js";
  *
  * The GTK inspector provides a visual debugging tool for graphics offload.
  */
+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 GraphicsOffload extends Widget {
     constructor(...args) {
         super(...args);
@@ -154,12 +193,24 @@ export class GraphicsOffload 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], GraphicsOffload);
-            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/grid-layout-child.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { LayoutChild } from "./layout-child.js";
 /** `GtkLayoutChild` subclass for children in a `GtkGridLayout`. */
 export declare class GridLayoutChild extends LayoutChild {
@@ -39,4 +40,6 @@ export declare class GridLayoutChild extends LayoutChild {
      * @param span - the span of @child
      */
     setRowSpan(span: number): void;
+    connect(signal: "notify", handler: (self: GridLayoutChild, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/grid-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 `GtkGridLayout`. */
 export class GridLayoutChild extends LayoutChild {
@@ -124,4 +125,22 @@ export class GridLayoutChild extends LayoutChild {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], GridLayoutChild);
+            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/grid-layout.d.ts

@@ -1,4 +1,5 @@
 import { BaselinePosition } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Arranges child widgets in rows and columns.
@@ -87,4 +88,6 @@ export declare class GridLayout extends LayoutManager {
      * @param spacing - the amount of space between rows, in pixels
      */
     setRowSpacing(spacing: number): void;
+    connect(signal: "notify", handler: (self: GridLayout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Arranges child widgets in rows and columns.
@@ -210,4 +211,22 @@ export class GridLayout extends LayoutManager {
             },
         ], { type: "undefined" });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], GridLayout);
+            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/grid-view.d.ts

@@ -1,7 +1,8 @@
-import { ListScrollFlags, ListTabBehavior } from "./enums.js";
+import { DirectionType, ListScrollFlags, ListTabBehavior, StateFlags, TextDirection } from "./enums.js";
 import { ScrollInfo } from "./scroll-info.js";
 import { ListItemFactory } from "./list-item-factory.js";
 import { SelectionModel } from "./selection-model.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { ListBase } from "./list-base.js";
 export declare class GridView extends ListBase {
@@ -110,6 +111,19 @@ export declare class GridView extends ListBase {
      */
     setTabBehavior(tabBehavior: ListTabBehavior): void;
     connect(signal: "activate", handler: (self: GridView, position: number) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: GridView) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: GridView, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: GridView) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: GridView, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: GridView) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: GridView, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: GridView, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: GridView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: GridView) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: GridView) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: GridView, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: GridView) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: GridView) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: GridView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { ListItemFactory } from "./list-item-factory.js";
 import { SelectionModel } from "./selection-model.js";
+import { Tooltip } from "./tooltip.js";
 import { ListBase } from "./list-base.js";
 /**
  * Presents a large dynamic grid of items.
@@ -52,6 +53,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 GridView extends ListBase {
     constructor(...args) {