@gtkx/ffi 0.1.46 → 0.1.48

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) {

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

@@ -1,92 +1,8 @@
 import { Ref } from "@gtkx/native";
-import { BaselinePosition, Orientation, PositionType } from "./enums.js";
+import { BaselinePosition, DirectionType, Orientation, PositionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Arranges its child widgets in rows and columns.
- *
- *
- *
- * It supports arbitrary positions and horizontal/vertical spans.
- *
- * Children are added using [method@Gtk.Grid.attach]. They can span multiple
- * rows or columns. It is also possible to add a child next to an existing
- * child, using [method@Gtk.Grid.attach_next_to]. To remove a child from the
- * grid, use [method@Gtk.Grid.remove].
- *
- * The behaviour of `GtkGrid` when several children occupy the same grid
- * cell is undefined.
- *
- * # GtkGrid as GtkBuildable
- *
- * Every child in a `GtkGrid` has access to a custom [iface@Gtk.Buildable]
- * element, called `<layout>`. It can by used to specify a position in the
- * grid and optionally spans. All properties that can be used in the `<layout>`
- * element are implemented by [class@Gtk.GridLayoutChild].
- *
- * It is implemented by `GtkWidget` using [class@Gtk.LayoutManager].
- *
- * To showcase it, here is a simple example:
- *
- * ```xml
- * <object class="GtkGrid" id="my_grid">
- * <child>
- * <object class="GtkButton" id="button1">
- * <property name="label">Button 1</property>
- * <layout>
- * <property name="column">0</property>
- * <property name="row">0</property>
- * </layout>
- * </object>
- * </child>
- * <child>
- * <object class="GtkButton" id="button2">
- * <property name="label">Button 2</property>
- * <layout>
- * <property name="column">1</property>
- * <property name="row">0</property>
- * </layout>
- * </object>
- * </child>
- * <child>
- * <object class="GtkButton" id="button3">
- * <property name="label">Button 3</property>
- * <layout>
- * <property name="column">2</property>
- * <property name="row">0</property>
- * <property name="row-span">2</property>
- * </layout>
- * </object>
- * </child>
- * <child>
- * <object class="GtkButton" id="button4">
- * <property name="label">Button 4</property>
- * <layout>
- * <property name="column">0</property>
- * <property name="row">1</property>
- * <property name="column-span">2</property>
- * </layout>
- * </object>
- * </child>
- * </object>
- * ```
- *
- * It organizes the first two buttons side-by-side in one cell each.
- * The third button is in the last column but spans across two rows.
- * This is defined by the `row-span` property. The last button is
- * located in the second row and spans across two columns, which is
- * defined by the `column-span` property.
- *
- * # CSS nodes
- *
- * `GtkGrid` uses a single CSS node with name `grid`.
- *
- * # Accessibility
- *
- * Until GTK 4.10, `GtkGrid` used the [enum@Gtk.AccessibleRole.group] role.
- *
- * Starting from GTK 4.12, `GtkGrid` uses the [enum@Gtk.AccessibleRole.generic] role.
- */
 export declare class Grid extends Widget {
     /**
      * Creates a new grid widget.
@@ -270,6 +186,19 @@ export declare class Grid extends Widget {
      * @param orientation - the orientable’s new orientation
      */
     setOrientation(orientation: Orientation): void;
+    connect(signal: "destroy", handler: (self: Grid) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Grid, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Grid) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Grid, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Grid) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Grid, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Grid, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Grid, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Grid) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Grid) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Grid, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Grid) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Grid) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Grid, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/grid.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Arranges its child widgets in rows and columns.
@@ -86,6 +87,44 @@ import { Widget } from "./widget.js";
  *
  * Starting from GTK 4.12, `GtkGrid` uses the [enum@Gtk.AccessibleRole.generic] role.
  */
+const SIGNAL_META = {
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
+};
 export class Grid extends Widget {
     /**
      * Creates a new grid widget.
@@ -597,12 +636,24 @@ export class Grid 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], Grid);
-            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/header-bar.d.ts

@@ -1,78 +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";
-/**
- * Creates a custom titlebar for a window.
- *
- *
- *
- * `GtkHeaderBar` is similar to a horizontal `GtkCenterBox`. It allows
- * children to be placed at the start or the end. In addition, it allows
- * the window title to be displayed. The title will be centered with respect
- * to the width of the box, even if the children at either side take up
- * different amounts of space.
- *
- * `GtkHeaderBar` can add typical window frame controls, such as minimize,
- * maximize and close buttons, or the window icon.
- *
- * For these reasons, `GtkHeaderBar` is the natural choice for use as the
- * custom titlebar widget of a `GtkWindow` (see [method@Gtk.Window.set_titlebar]),
- * as it gives features typical of titlebars while allowing the addition of
- * child widgets.
- *
- * ## GtkHeaderBar as GtkBuildable
- *
- * The `GtkHeaderBar` implementation of the `GtkBuildable` interface supports
- * adding children at the start or end sides by specifying “start” or “end” as
- * the “type” attribute of a `<child>` element, or setting the title widget by
- * specifying “title” value.
- *
- * By default the `GtkHeaderBar` uses a `GtkLabel` displaying the title of the
- * window it is contained in as the title widget, equivalent to the following
- * UI definition:
- *
- * ```xml
- * <object class="GtkHeaderBar">
- * <property name="title-widget">
- * <object class="GtkLabel">
- * <property name="label" translatable="yes">Label</property>
- * <property name="single-line-mode">True</property>
- * <property name="ellipsize">end</property>
- * <property name="width-chars">5</property>
- * <style>
- * <class name="title"/>
- * </style>
- * </object>
- * </property>
- * </object>
- * ```
- *
- * # CSS nodes
- *
- * ```
- * headerbar
- * ╰── windowhandle
- * ╰── box
- * ├── box.start
- * │   ├── windowcontrols.start
- * │   ╰── [other children]
- * ├── [Title Widget]
- * ╰── box.end
- * ├── [other children]
- * ╰── windowcontrols.end
- * ```
- *
- * A `GtkHeaderBar`'s CSS node is called `headerbar`. It contains a `windowhandle`
- * subnode, which contains a `box` subnode, which contains two `box` subnodes at
- * the start and end of the header bar, as well as a center node that represents
- * the title.
- *
- * Each of the boxes contains a `windowcontrols` subnode, see
- * [class@Gtk.WindowControls] for details, as well as other children.
- *
- * # Accessibility
- *
- * `GtkHeaderBar` uses the [enum@Gtk.AccessibleRole.group] role.
- */
 export declare class HeaderBar extends Widget {
     /**
      * Creates a new `GtkHeaderBar` widget.
@@ -171,6 +100,19 @@ export declare class HeaderBar extends Widget {
      * @param setting - true to show native window controls
      */
     setUseNativeControls(setting: boolean): void;
+    connect(signal: "destroy", handler: (self: HeaderBar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: HeaderBar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: HeaderBar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: HeaderBar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: HeaderBar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: HeaderBar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: HeaderBar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: HeaderBar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: HeaderBar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: HeaderBar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: HeaderBar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: HeaderBar) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: HeaderBar) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: HeaderBar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/header-bar.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";
 /**
  * Creates a custom titlebar for a window.
@@ -74,6 +75,44 @@ import { Widget } from "./widget.js";
  *
  * `GtkHeaderBar` 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 HeaderBar extends Widget {
     /**
      * Creates a new `GtkHeaderBar` widget.
@@ -290,12 +329,24 @@ export class HeaderBar 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], HeaderBar);
-            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/icon-view.d.ts

@@ -1,13 +1,13 @@
 import { Ref } from "@gtkx/native";
-import { IconViewDropPosition, MovementStep, Orientation, ScrollablePolicy, SelectionMode } from "./enums.js";
+import { DirectionType, IconViewDropPosition, MovementStep, Orientation, ScrollablePolicy, SelectionMode, StateFlags, TextDirection } from "./enums.js";
 import { Border } from "./border.js";
 import { TreeIter } from "./tree-iter.js";
 import { TreePath } from "./tree-path.js";
 import { Adjustment } from "./adjustment.js";
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
-import { Tooltip } from "./tooltip.js";
 import { TreeModel } from "./tree-model.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
@@ -564,6 +564,19 @@ export declare class IconView extends Widget {
     connect(signal: "selection-changed", handler: (self: IconView) => void, after?: boolean): number;
     connect(signal: "toggle-cursor-item", handler: (self: IconView) => void, after?: boolean): number;
     connect(signal: "unselect-all", handler: (self: IconView) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: IconView) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: IconView, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: IconView) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: IconView, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: IconView) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: IconView, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: IconView, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: IconView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: IconView) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: IconView) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: IconView, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: IconView) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: IconView) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: IconView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -5,6 +5,7 @@ import { Adjustment } from "./adjustment.js";
 import { CellArea } from "./cell-area.js";
 import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
+import { Tooltip } from "./tooltip.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -56,6 +57,42 @@ const SIGNAL_META = {
     "selection-changed": { params: [], returnType: { type: "undefined" } },
     "toggle-cursor-item": { params: [], returnType: { type: "undefined" } },
     "unselect-all": { 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 IconView extends Widget {
     /**

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

@@ -1,50 +1,10 @@
-import { IconSize, ImageType } from "./enums.js";
+import { DirectionType, IconSize, ImageType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as GdkPixbuf from "../gdkpixbuf/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
-/**
- * Displays an image.
- *
- *
- *
- * Various kinds of object can be displayed as an image; most typically,
- * you would load a `GdkTexture` from a file, using the convenience function
- * [ctor@Gtk.Image.new_from_file], for instance:
- *
- * ```c
- * GtkWidget *image = gtk_image_new_from_file ("myfile.png");
- * ```
- *
- * If the file isn’t loaded successfully, the image will contain a
- * “broken image” icon similar to that used in many web browsers.
- *
- * If you want to handle errors in loading the file yourself, for example
- * by displaying an error message, then load the image with an image
- * loading framework such as libglycin, then create the `GtkImage` with
- * [ctor@Gtk.Image.new_from_paintable].
- *
- * Sometimes an application will want to avoid depending on external data
- * files, such as image files. See the documentation of `GResource` inside
- * GIO, for details. In this case, [property@Gtk.Image:resource],
- * [ctor@Gtk.Image.new_from_resource], and [method@Gtk.Image.set_from_resource]
- * should be used.
- *
- * `GtkImage` displays its image as an icon, with a size that is determined
- * by the application. See [class@Gtk.Picture] if you want to show an image
- * at is actual size.
- *
- * ## CSS nodes
- *
- * `GtkImage` has a single CSS node with the name `image`. The style classes
- * `.normal-icons` or `.large-icons` may appear, depending on the
- * [property@Gtk.Image:icon-size] property.
- *
- * ## Accessibility
- *
- * `GtkImage` uses the [enum@Gtk.AccessibleRole.img] role.
- */
 export declare class Image extends Widget {
     /**
      * Creates a new empty `GtkImage` widget.
@@ -250,6 +210,19 @@ export declare class Image extends Widget {
      * @param pixelSize - the new pixel size
      */
     setPixelSize(pixelSize: number): void;
+    connect(signal: "destroy", handler: (self: Image) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Image, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Image) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Image, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Image) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Image, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Image, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Image, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Image) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Image) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Image, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Image) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Image) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Image, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/image.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
@@ -44,6 +45,44 @@ import { Widget } from "./widget.js";
  *
  * `GtkImage` uses the [enum@Gtk.AccessibleRole.img] 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 Image extends Widget {
     /**
      * Creates a new empty `GtkImage` widget.
@@ -456,12 +495,24 @@ export class Image 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], Image);
-            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 },