@gtkx/ffi 0.1.46 → 0.1.48

package/dist/generated/gtk/text.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Editable } from "./editable.js";
 import { EntryBuffer } from "./entry-buffer.js";
+import { Tooltip } from "./tooltip.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
@@ -148,6 +149,42 @@ const SIGNAL_META = {
         returnType: { type: "undefined" },
     },
     "toggle-overwrite": { 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 Text extends Widget {
     /**

package/dist/generated/gtk/toggle-button.d.ts

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

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

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import { Button } from "./button.js";
 /**
  * Shows a button which remains “pressed-in” when clicked.
@@ -80,6 +81,42 @@ const SIGNAL_META = {
     toggled: { params: [], returnType: { type: "undefined" } },
     activate: { params: [], returnType: { type: "undefined" } },
     clicked: { 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 ToggleButton extends Button {
     /**

package/dist/generated/gtk/tree-expander.d.ts

@@ -1,84 +1,8 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
 import { TreeListRow } from "./tree-list-row.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Provides an expander for a tree-like list.
- *
- * It is typically placed as a bottommost child into a `GtkListView`
- * to allow users to expand and collapse children in a list with a
- * [class@Gtk.TreeListModel]. `GtkTreeExpander` provides the common UI
- * elements, gestures and keybindings for this purpose.
- *
- * On top of this, the "listitem.expand", "listitem.collapse" and
- * "listitem.toggle-expand" actions are provided to allow adding custom
- * UI for managing expanded state.
- *
- * It is important to mention that you want to set the
- * [property@Gtk.ListItem:focusable] property to FALSE when using this
- * widget, as you want the keyboard focus to be in the treexpander, and not
- * inside the list to make use of the keybindings.
- *
- * The `GtkTreeListModel` must be set to not be passthrough. Then it
- * will provide [class@Gtk.TreeListRow] items which can be set via
- * [method@Gtk.TreeExpander.set_list_row] on the expander.
- * The expander will then watch that row item automatically.
- * [method@Gtk.TreeExpander.set_child] sets the widget that displays
- * the actual row contents.
- *
- * `GtkTreeExpander` can be modified with properties such as
- * [property@Gtk.TreeExpander:indent-for-icon],
- * [property@Gtk.TreeExpander:indent-for-depth], and
- * [property@Gtk.TreeExpander:hide-expander] to achieve a different appearance.
- * This can even be done to influence individual rows, for example by binding
- * the [property@Gtk.TreeExpander:hide-expander] property to the item count of
- * the model of the treelistrow, to hide the expander for rows without children,
- * even if the row is expandable.
- *
- * ## Shortcuts and Gestures
- *
- * `GtkTreeExpander` supports the following keyboard shortcuts:
- *
- * - `+` or `*` expands the expander.
- * - `-` or `/` collapses the expander.
- * - Left and right arrow keys, when combined with `Shift` or
- * `Ctrl`+`Shift`, will expand or collapse, depending on
- * the locale's text direction.
- * - `Ctrl`+`␣` toggles the expander state.
- *
- * The row can also expand on drag gestures.
- *
- * ## Actions
- *
- * `GtkTreeExpander` defines a set of built-in actions:
- *
- * - `listitem.expand` expands the expander if it can be expanded.
- * - `listitem.collapse` collapses the expander.
- * - `listitem.toggle-expand` tries to expand the expander if it was collapsed
- * or collapses it if it was expanded.
- *
- * ## CSS nodes
- *
- * ```
- * treeexpander
- * ├── [indent]*
- * ├── [expander]
- * ╰── <child>
- * ```
- *
- * `GtkTreeExpander` has zero or one CSS nodes with the name "expander" that
- * should display the expander icon. The node will be `:checked` when it
- * is expanded. If the node is not expandable, an "indent" node will be
- * displayed instead.
- *
- * For every level of depth, another "indent" node is prepended.
- *
- * ## Accessibility
- *
- * Until GTK 4.10, `GtkTreeExpander` used the [enum@Gtk.AccessibleRole.group] role.
- *
- * Since GTK 4.12, `GtkTreeExpander` uses the [enum@Gtk.AccessibleRole.button] role.
- * Toggling it will change the `GTK_ACCESSIBLE_STATE_EXPANDED` state.
- */
 export declare class TreeExpander extends Widget {
     /**
      * Creates a new `GtkTreeExpander`
@@ -140,6 +64,19 @@ export declare class TreeExpander extends Widget {
      * @param listRow - a `GtkTreeListRow`
      */
     setListRow(listRow?: TreeListRow | null): void;
+    connect(signal: "destroy", handler: (self: TreeExpander) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: TreeExpander, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: TreeExpander) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: TreeExpander, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: TreeExpander) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: TreeExpander, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: TreeExpander, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: TreeExpander, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: TreeExpander) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: TreeExpander) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: TreeExpander, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: TreeExpander) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: TreeExpander) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: TreeExpander, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-expander.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { TreeListRow } from "./tree-list-row.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -81,6 +82,44 @@ import { Widget } from "./widget.js";
  * Since GTK 4.12, `GtkTreeExpander` uses the [enum@Gtk.AccessibleRole.button] role.
  * Toggling it will change the `GTK_ACCESSIBLE_STATE_EXPANDED` state.
  */
+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 TreeExpander extends Widget {
     /**
      * Creates a new `GtkTreeExpander`
@@ -258,12 +297,24 @@ export class TreeExpander 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], TreeExpander);
-            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/tree-list-row-sorter.d.ts

@@ -1,19 +1,6 @@
+import { SorterChange } from "./enums.js";
 import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
-/**
- * Applies a gives sorter to the levels in a tree.
- *
- * Here is an example for setting up a column view with a tree model and
- * a `GtkTreeListSorter`:
- *
- * ```c
- * column_sorter = gtk_column_view_get_sorter (view);
- * sorter = gtk_tree_list_row_sorter_new (g_object_ref (column_sorter));
- * sort_model = gtk_sort_list_model_new (tree_model, sorter);
- * selection = gtk_single_selection_new (sort_model);
- * gtk_column_view_set_model (view, G_LIST_MODEL (selection));
- * ```
- */
 export declare class TreeListRowSorter extends Sorter {
     /**
      * Create a special-purpose sorter that applies the sorting
@@ -38,6 +25,7 @@ export declare class TreeListRowSorter extends Sorter {
      * @param sorter - The sorter to use
      */
     setSorter(sorter?: Sorter | null): void;
+    connect(signal: "changed", handler: (self: TreeListRowSorter, change: SorterChange) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: TreeListRowSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/tree-list-row-sorter.js

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

@@ -1,14 +1,14 @@
 import { Ref } from "@gtkx/native";
-import { MovementStep, ScrollablePolicy, TreeViewDropPosition, TreeViewGridLines } from "./enums.js";
+import { DirectionType, MovementStep, ScrollablePolicy, StateFlags, TextDirection, TreeViewDropPosition, TreeViewGridLines } 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 { CellRenderer } from "./cell-renderer.js";
 import { Editable } from "./editable.js";
-import { Tooltip } from "./tooltip.js";
 import { TreeModel } from "./tree-model.js";
 import { TreeSelection } from "./tree-selection.js";
+import { Tooltip } from "./tooltip.js";
 import { TreeViewColumn } from "./tree-view-column.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
@@ -784,6 +784,19 @@ export declare class TreeView extends Widget {
     connect(signal: "test-expand-row", handler: (self: TreeView, iter: TreeIter, path: TreePath) => boolean, after?: boolean): number;
     connect(signal: "toggle-cursor-row", handler: (self: TreeView) => boolean, after?: boolean): number;
     connect(signal: "unselect-all", handler: (self: TreeView) => boolean, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: TreeView, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: TreeView, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: TreeView, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: TreeView, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: TreeView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: TreeView, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: TreeView) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: TreeView) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: TreeView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -4,6 +4,7 @@ import { Adjustment } from "./adjustment.js";
 import { Editable } from "./editable.js";
 import { TreeModel } from "./tree-model.js";
 import { TreeSelection } from "./tree-selection.js";
+import { Tooltip } from "./tooltip.js";
 import { TreeViewColumn } from "./tree-view-column.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
@@ -164,6 +165,42 @@ const SIGNAL_META = {
     },
     "toggle-cursor-row": { params: [], returnType: { type: "boolean" } },
     "unselect-all": { params: [], 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 TreeView extends Widget {
     /**

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

@@ -1,24 +1,9 @@
-import { GraphicsOffloadEnabled } from "./enums.js";
+import { DirectionType, GraphicsOffloadEnabled, StateFlags, TextDirection } from "./enums.js";
 import { MediaStream } from "./media-stream.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
-/**
- * Shows a `GtkMediaStream` with media controls.
- *
- *
- *
- * The controls are available separately as [class@Gtk.MediaControls].
- * If you just want to display a video without controls, you can treat it
- * like any other paintable and for example put it into a [class@Gtk.Picture].
- *
- * `GtkVideo` aims to cover use cases such as previews, embedded animations,
- * etc. It supports autoplay, looping, and simple media controls. It does
- * not have support for video overlays, multichannel audio, device
- * selection, or input. If you are writing a full-fledged video player,
- * you may want to use the [iface@Gdk.Paintable] API and a media framework
- * such as Gstreamer directly.
- */
 export declare class Video extends Widget {
     /**
      * Creates a new empty `GtkVideo`.
@@ -123,6 +108,19 @@ export declare class Video extends Widget {
      * @param resourcePath - the resource to set
      */
     setResource(resourcePath?: string | null): void;
+    connect(signal: "destroy", handler: (self: Video) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Video, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Video) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Video, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Video) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Video, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Video, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Video, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Video) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Video) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Video, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Video) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Video) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Video, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/video.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { MediaStream } from "./media-stream.js";
+import { Tooltip } from "./tooltip.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -19,6 +20,44 @@ import { Widget } from "./widget.js";
  * you may want to use the [iface@Gdk.Paintable] API and a media framework
  * such as Gstreamer directly.
  */
+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 Video extends Widget {
     /**
      * Creates a new empty `GtkVideo`.
@@ -289,12 +328,24 @@ export class Video 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], Video);
-            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/viewport.d.ts

@@ -1,30 +1,11 @@
 import { Ref } from "@gtkx/native";
-import { ScrollablePolicy } from "./enums.js";
+import { DirectionType, ScrollablePolicy, StateFlags, TextDirection } from "./enums.js";
 import { Border } from "./border.js";
 import { ScrollInfo } from "./scroll-info.js";
 import { Adjustment } from "./adjustment.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Implements scrollability for widgets that don't support scrolling
- * on their own.
- *
- * Use `GtkViewport` to scroll child widgets such as `GtkGrid`,
- * `GtkBox`, and so on.
- *
- * The `GtkViewport` will start scrolling content only if allocated
- * less than the child widget’s minimum size in a given orientation.
- *
- * # CSS nodes
- *
- * `GtkViewport` has a single CSS node with name `viewport`.
- *
- * # Accessibility
- *
- * Until GTK 4.10, `GtkViewport` used the [enum@Gtk.AccessibleRole.group] role.
- *
- * Starting from GTK 4.12, `GtkViewport` uses the [enum@Gtk.AccessibleRole.generic] role.
- */
 export declare class Viewport extends Widget {
     /**
      * Creates a new `GtkViewport`.
@@ -118,6 +99,19 @@ export declare class Viewport extends Widget {
      * @param policy - the vertical `GtkScrollablePolicy`
      */
     setVscrollPolicy(policy: ScrollablePolicy): void;
+    connect(signal: "destroy", handler: (self: Viewport) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Viewport, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Viewport) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Viewport, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Viewport) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Viewport, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Viewport, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Viewport, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Viewport) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Viewport) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Viewport, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Viewport) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Viewport) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Viewport, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }