@gtkx/ffi 0.1.46 → 0.1.48

package/dist/generated/gtk/fixed-layout-child.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import * as Gsk from "../gsk/index.js";
 import { LayoutChild } from "./layout-child.js";
 /** `GtkLayoutChild` subclass for children in a `GtkFixedLayout`. */
@@ -13,4 +14,6 @@ export declare class FixedLayoutChild extends LayoutChild {
      * @param transform - a `GskTransform`
      */
     setTransform(transform: Gsk.Transform): void;
+    connect(signal: "notify", handler: (self: FixedLayoutChild, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/fixed-layout-child.js

@@ -58,4 +58,22 @@ export class FixedLayoutChild 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], FixedLayoutChild);
+            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/fixed-layout.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Places child widgets at fixed positions.
@@ -37,4 +38,6 @@ export declare class FixedLayout extends LayoutManager {
      */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    connect(signal: "notify", handler: (self: FixedLayout, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { LayoutManager } from "./layout-manager.js";
 /**
  * Places child widgets at fixed positions.
@@ -45,4 +46,22 @@ export class FixedLayout extends LayoutManager {
             borrowed: false,
         });
     }
+    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], FixedLayout);
+            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/fixed.d.ts

@@ -1,46 +1,9 @@
 import { Ref } from "@gtkx/native";
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gsk from "../gsk/index.js";
 import { Widget } from "./widget.js";
-/**
- * Places its child widgets at fixed positions and with fixed sizes.
- *
- * `GtkFixed` performs no automatic layout management.
- *
- * For most applications, you should not use this container! It keeps
- * you from having to learn about the other GTK containers, but it
- * results in broken applications.  With `GtkFixed`, the following
- * things will result in truncated text, overlapping widgets, and
- * other display bugs:
- *
- * - Themes, which may change widget sizes.
- *
- * - Fonts other than the one you used to write the app will of course
- * change the size of widgets containing text; keep in mind that
- * users may use a larger font because of difficulty reading the
- * default, or they may be using a different OS that provides different fonts.
- *
- * - Translation of text into other languages changes its size. Also,
- * display of non-English text will use a different font in many
- * cases.
- *
- * In addition, `GtkFixed` does not pay attention to text direction and
- * thus may produce unwanted results if your app is run under right-to-left
- * languages such as Hebrew or Arabic. That is: normally GTK will order
- * containers appropriately for the text direction, e.g. to put labels to
- * the right of the thing they label when using an RTL language, but it can’t
- * do that with `GtkFixed`. So if you need to reorder widgets depending on
- * the text direction, you would need to manually detect it and adjust child
- * positions accordingly.
- *
- * Finally, fixed positioning makes it kind of annoying to add/remove
- * UI elements, since you have to reposition all the other elements. This
- * is a long-term maintenance problem for your application.
- *
- * If you know none of these things are an issue for your application,
- * and prefer the simplicity of `GtkFixed`, by all means use the
- * widget. But you should be aware of the tradeoffs.
- */
 export declare class Fixed extends Widget {
     /**
      * Creates a new `GtkFixed`.
@@ -92,6 +55,19 @@ export declare class Fixed extends Widget {
      * @param transform - the transformation assigned to `widget`   to reset @widget's transform
      */
     setChildTransform(widget: Widget, transform?: Gsk.Transform | null): void;
+    connect(signal: "destroy", handler: (self: Fixed) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Fixed, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Fixed) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Fixed, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Fixed) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Fixed, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Fixed, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Fixed, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Fixed) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Fixed) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Fixed, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Fixed) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Fixed) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Fixed, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/fixed.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as Gsk from "../gsk/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -41,6 +42,44 @@ import { Widget } from "./widget.js";
  * and prefer the simplicity of `GtkFixed`, by all means use the
  * widget. But you should be aware of the tradeoffs.
  */
+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 Fixed extends Widget {
     /**
      * Creates a new `GtkFixed`.
@@ -208,12 +247,24 @@ export class Fixed 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], Fixed);
-            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/flow-box-child.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 { Widget } from "./widget.js";
 export declare class FlowBoxChild extends Widget {
@@ -49,6 +51,19 @@ export declare class FlowBoxChild extends Widget {
      */
     setChild(child?: Widget | null): void;
     connect(signal: "activate", handler: (self: FlowBoxChild) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: FlowBoxChild) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: FlowBoxChild, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: FlowBoxChild) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: FlowBoxChild, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: FlowBoxChild) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: FlowBoxChild, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: FlowBoxChild, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: FlowBoxChild, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: FlowBoxChild) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: FlowBoxChild) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: FlowBoxChild, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: FlowBoxChild) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: FlowBoxChild) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: FlowBoxChild, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/flow-box-child.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";
 /**
  * The kind of widget that can be added to a `GtkFlowBox`.
@@ -9,6 +10,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 FlowBoxChild extends Widget {
     /**

package/dist/generated/gtk/flow-box.d.ts

@@ -1,6 +1,7 @@
-import { MovementStep, Orientation, SelectionMode } from "./enums.js";
+import { DirectionType, MovementStep, Orientation, SelectionMode, StateFlags, TextDirection } from "./enums.js";
 import { Adjustment } from "./adjustment.js";
 import { FlowBoxChild } from "./flow-box-child.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";
@@ -293,6 +294,19 @@ export declare class FlowBox extends Widget {
     connect(signal: "selected-children-changed", handler: (self: FlowBox) => void, after?: boolean): number;
     connect(signal: "toggle-cursor-child", handler: (self: FlowBox) => void, after?: boolean): number;
     connect(signal: "unselect-all", handler: (self: FlowBox) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: FlowBox) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: FlowBox, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: FlowBox) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: FlowBox, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: FlowBox) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: FlowBox, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: FlowBox, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: FlowBox, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: FlowBox) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: FlowBox) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: FlowBox, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: FlowBox) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: FlowBox) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: FlowBox, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/flow-box.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { FlowBoxChild } from "./flow-box-child.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Puts child widgets in a reflowing grid.
@@ -85,6 +86,42 @@ const SIGNAL_META = {
     },
     "toggle-cursor-child": { 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 FlowBox extends Widget {
     /**

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

@@ -1,4 +1,5 @@
-import { FontChooserLevel } from "./enums.js";
+import { DirectionType, FontChooserLevel, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
@@ -162,6 +163,19 @@ export declare class FontButton extends Widget {
     setShowPreviewEntry(showPreviewEntry: boolean): void;
     connect(signal: "activate", handler: (self: FontButton) => void, after?: boolean): number;
     connect(signal: "font-set", handler: (self: FontButton) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: FontButton) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: FontButton, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: FontButton) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: FontButton, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: FontButton) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: FontButton, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: FontButton, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: FontButton, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: FontButton) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: FontButton) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: FontButton, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: FontButton) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: FontButton) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: FontButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -24,6 +25,42 @@ import { Widget } from "./widget.js";
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     "font-set": { 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 FontButton extends Widget {
     /**

package/dist/generated/gtk/font-chooser-dialog.d.ts

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

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

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as Pango from "../pango/index.js";
 import { Dialog } from "./dialog.js";
 /**
@@ -37,6 +38,42 @@ const SIGNAL_META = {
         returnType: { type: "boolean" },
     },
     "keys-changed": { params: [], returnType: { type: "undefined" } },
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
 };
 export class FontChooserDialog extends Dialog {
     constructor(...args) {

package/dist/generated/gtk/font-chooser-widget.d.ts

@@ -1,26 +1,8 @@
-import { FontChooserLevel } from "./enums.js";
+import { DirectionType, FontChooserLevel, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
-/**
- * The `GtkFontChooserWidget` widget lets the user select a font.
- *
- * It is used in the `GtkFontChooserDialog` widget to provide a
- * dialog for selecting fonts.
- *
- * To set the font which is initially selected, use
- * [method@Gtk.FontChooser.set_font] or [method@Gtk.FontChooser.set_font_desc].
- *
- * To get the selected font use [method@Gtk.FontChooser.get_font] or
- * [method@Gtk.FontChooser.get_font_desc].
- *
- * To change the text which is shown in the preview area, use
- * [method@Gtk.FontChooser.set_preview_text].
- *
- * # CSS nodes
- *
- * `GtkFontChooserWidget` has a single CSS node with name fontchooser.
- */
 export declare class FontChooserWidget extends Widget {
     /**
      * Creates a new `GtkFontChooserWidget`.
@@ -136,6 +118,19 @@ export declare class FontChooserWidget extends Widget {
      * @param showPreviewEntry - whether to show the editable preview entry or not
      */
     setShowPreviewEntry(showPreviewEntry: boolean): void;
+    connect(signal: "destroy", handler: (self: FontChooserWidget) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: FontChooserWidget, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: FontChooserWidget) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: FontChooserWidget, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: FontChooserWidget) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: FontChooserWidget, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: FontChooserWidget, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: FontChooserWidget, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: FontChooserWidget) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: FontChooserWidget) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: FontChooserWidget, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: FontChooserWidget) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: FontChooserWidget) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: FontChooserWidget, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }