@gtkx/ffi 0.1.19 → 0.1.21

package/dist/generated/gtk/drop-target.js

@@ -4,21 +4,33 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 const SIGNAL_META = {
-    accept: [{ type: { type: "gobject", borrowed: false } }],
-    drop: [
-        { type: { type: "boxed", borrowed: false, innerType: "GValue" } },
-        { type: { type: "float", size: 64 } },
-        { type: { type: "float", size: 64 } },
-    ],
-    enter: [
-        { type: { type: "float", size: 64 } },
-        { type: { type: "float", size: 64 } },
-    ],
-    leave: [],
-    motion: [
-        { type: { type: "float", size: 64 } },
-        { type: { type: "float", size: 64 } },
-    ],
+    accept: {
+        params: [{ type: { type: "gobject", borrowed: false } }],
+        returnType: { type: "boolean" },
+    },
+    drop: {
+        params: [
+            { type: { type: "boxed", borrowed: false, innerType: "GValue" } },
+            { type: { type: "float", size: 64 } },
+            { type: { type: "float", size: 64 } },
+        ],
+        returnType: { type: "boolean" },
+    },
+    enter: {
+        params: [
+            { type: { type: "float", size: 64 } },
+            { type: { type: "float", size: 64 } },
+        ],
+        returnType: { type: "int", size: 32, unsigned: false },
+    },
+    leave: { params: [], returnType: { type: "undefined" } },
+    motion: {
+        params: [
+            { type: { type: "float", size: 64 } },
+            { type: { type: "float", size: 64 } },
+        ],
+        returnType: { type: "int", size: 32, unsigned: false },
+    },
 };
 export class DropTarget extends EventController {
     constructor(...args) {
@@ -176,13 +188,16 @@ export class DropTarget extends EventController {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], DropTarget);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -193,7 +208,10 @@ export class DropTarget extends EventController {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/editable-label.js

@@ -326,6 +326,7 @@ export class EditableLabel extends Widget {
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];
+        const returnType = undefined;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EditableLabel);
             return handler(self, ...args.slice(1));
@@ -333,7 +334,10 @@ export class EditableLabel extends Widget {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/emoji-chooser.js

@@ -2,9 +2,12 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { Popover } from "./popover.js";
 const SIGNAL_META = {
-    "emoji-picked": [{ type: { type: "string", borrowed: false } }],
-    "activate-default": [],
-    closed: [],
+    "emoji-picked": {
+        params: [{ type: { type: "string", borrowed: false } }],
+        returnType: { type: "undefined" },
+    },
+    "activate-default": { params: [], returnType: { type: "undefined" } },
+    closed: { params: [], returnType: { type: "undefined" } },
 };
 export class EmojiChooser extends Popover {
     constructor(...args) {
@@ -19,13 +22,16 @@ export class EmojiChooser extends Popover {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EmojiChooser);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -36,7 +42,10 @@ export class EmojiChooser extends Popover {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/entry-buffer.js

@@ -2,15 +2,21 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 const SIGNAL_META = {
-    "deleted-text": [
-        { type: { type: "int", size: 32, unsigned: true } },
-        { type: { type: "int", size: 32, unsigned: true } },
-    ],
-    "inserted-text": [
-        { type: { type: "int", size: 32, unsigned: true } },
-        { type: { type: "string", borrowed: false } },
-        { type: { type: "int", size: 32, unsigned: true } },
-    ],
+    "deleted-text": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: true } },
+            { type: { type: "int", size: 32, unsigned: true } },
+        ],
+        returnType: { type: "undefined" },
+    },
+    "inserted-text": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: true } },
+            { type: { type: "string", borrowed: false } },
+            { type: { type: "int", size: 32, unsigned: true } },
+        ],
+        returnType: { type: "undefined" },
+    },
 };
 export class EntryBuffer extends GObject.GObject {
     constructor(...args) {
@@ -164,13 +170,16 @@ export class EntryBuffer extends GObject.GObject {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EntryBuffer);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -181,7 +190,10 @@ export class EntryBuffer extends GObject.GObject {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/entry-completion.js

@@ -1,20 +1,30 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { CellArea } from "./cell-area.js";
+import { CellRenderer } from "./cell-renderer.js";
 import { TreeModel } from "./tree-model.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
 const SIGNAL_META = {
-    "cursor-on-match": [
-        { type: { type: "gobject", borrowed: false } },
-        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
-    ],
-    "insert-prefix": [{ type: { type: "string", borrowed: false } }],
-    "match-selected": [
-        { type: { type: "gobject", borrowed: false } },
-        { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
-    ],
-    "no-matches": [],
+    "cursor-on-match": {
+        params: [
+            { type: { type: "gobject", borrowed: false } },
+            { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+        ],
+        returnType: { type: "boolean" },
+    },
+    "insert-prefix": {
+        params: [{ type: { type: "string", borrowed: false } }],
+        returnType: { type: "boolean" },
+    },
+    "match-selected": {
+        params: [
+            { type: { type: "gobject", borrowed: false } },
+            { type: { type: "boxed", borrowed: false, innerType: "GtkTreeIter" } },
+        ],
+        returnType: { type: "boolean" },
+    },
+    "no-matches": { params: [], returnType: { type: "undefined" } },
 };
 export class EntryCompletion extends GObject.GObject {
     constructor(...args) {
@@ -323,12 +333,18 @@ export class EntryCompletion extends GObject.GObject {
         return wrapPtr(ptr, CellArea);
     }
     getCells() {
-        return call("libgtk-4.so.1", "gtk_cell_layout_get_cells", [
+        const ptrs = call("libgtk-4.so.1", "gtk_cell_layout_get_cells", [
             {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "array", itemType: { type: "gobject" } });
+        ], {
+            type: "array",
+            itemType: { type: "gobject" },
+            listType: "glist",
+            borrowed: true,
+        });
+        return ptrs.map((ptr) => wrapPtr(ptr, CellRenderer));
     }
     packEnd(cell, expand) {
         call("libgtk-4.so.1", "gtk_cell_layout_pack_end", [
@@ -405,13 +421,16 @@ export class EntryCompletion extends GObject.GObject {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EntryCompletion);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -422,7 +441,10 @@ export class EntryCompletion extends GObject.GObject {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/entry.js

@@ -8,9 +8,15 @@ import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
 const SIGNAL_META = {
-    activate: [],
-    "icon-press": [{ type: { type: "int", size: 32, unsigned: false } }],
-    "icon-release": [{ type: { type: "int", size: 32, unsigned: false } }],
+    activate: { params: [], returnType: { type: "undefined" } },
+    "icon-press": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "icon-release": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
 };
 export class Entry extends Widget {
     constructor(...args) {
@@ -1042,13 +1048,16 @@ export class Entry extends Widget {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], Entry);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -1059,7 +1068,10 @@ export class Entry extends Widget {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/event-controller-focus.js

@@ -2,8 +2,8 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
 const SIGNAL_META = {
-    enter: [],
-    leave: [],
+    enter: { params: [], returnType: { type: "undefined" } },
+    leave: { params: [], returnType: { type: "undefined" } },
 };
 export class EventControllerFocus extends EventController {
     constructor(...args) {
@@ -34,13 +34,16 @@ export class EventControllerFocus extends EventController {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EventControllerFocus);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -51,7 +54,10 @@ export class EventControllerFocus extends EventController {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/event-controller-key.js

@@ -3,18 +3,27 @@ import { wrapPtr } from "@gtkx/ffi";
 import { IMContext } from "./imcontext.js";
 import { EventController } from "./event-controller.js";
 const SIGNAL_META = {
-    "im-update": [],
-    "key-pressed": [
-        { type: { type: "int", size: 32, unsigned: true } },
-        { type: { type: "int", size: 32, unsigned: true } },
-        { type: { type: "int", size: 32, unsigned: false } },
-    ],
-    "key-released": [
-        { type: { type: "int", size: 32, unsigned: true } },
-        { type: { type: "int", size: 32, unsigned: true } },
-        { type: { type: "int", size: 32, unsigned: false } },
-    ],
-    modifiers: [{ type: { type: "int", size: 32, unsigned: false } }],
+    "im-update": { params: [], returnType: { type: "undefined" } },
+    "key-pressed": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: true } },
+            { type: { type: "int", size: 32, unsigned: true } },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "boolean" },
+    },
+    "key-released": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: true } },
+            { type: { type: "int", size: 32, unsigned: true } },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "undefined" },
+    },
+    modifiers: {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
 };
 export class EventControllerKey extends EventController {
     constructor(...args) {
@@ -72,13 +81,16 @@ export class EventControllerKey extends EventController {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EventControllerKey);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -89,7 +101,10 @@ export class EventControllerKey extends EventController {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/event-controller-legacy.js

@@ -2,7 +2,10 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
 const SIGNAL_META = {
-    event: [{ type: { type: "gobject", borrowed: false } }],
+    event: {
+        params: [{ type: { type: "gobject", borrowed: false } }],
+        returnType: { type: "boolean" },
+    },
 };
 export class EventControllerLegacy extends EventController {
     constructor(...args) {
@@ -17,13 +20,16 @@ export class EventControllerLegacy extends EventController {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EventControllerLegacy);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -34,7 +40,10 @@ export class EventControllerLegacy extends EventController {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/event-controller-motion.js

@@ -2,15 +2,21 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
 const SIGNAL_META = {
-    enter: [
-        { type: { type: "float", size: 64 } },
-        { type: { type: "float", size: 64 } },
-    ],
-    leave: [],
-    motion: [
-        { type: { type: "float", size: 64 } },
-        { type: { type: "float", size: 64 } },
-    ],
+    enter: {
+        params: [
+            { type: { type: "float", size: 64 } },
+            { type: { type: "float", size: 64 } },
+        ],
+        returnType: { type: "undefined" },
+    },
+    leave: { params: [], returnType: { type: "undefined" } },
+    motion: {
+        params: [
+            { type: { type: "float", size: 64 } },
+            { type: { type: "float", size: 64 } },
+        ],
+        returnType: { type: "undefined" },
+    },
 };
 export class EventControllerMotion extends EventController {
     constructor(...args) {
@@ -41,13 +47,16 @@ export class EventControllerMotion extends EventController {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EventControllerMotion);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -58,7 +67,10 @@ export class EventControllerMotion extends EventController {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/event-controller-scroll.js

@@ -2,16 +2,22 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
 const SIGNAL_META = {
-    decelerate: [
-        { type: { type: "float", size: 64 } },
-        { type: { type: "float", size: 64 } },
-    ],
-    scroll: [
-        { type: { type: "float", size: 64 } },
-        { type: { type: "float", size: 64 } },
-    ],
-    "scroll-begin": [],
-    "scroll-end": [],
+    decelerate: {
+        params: [
+            { type: { type: "float", size: 64 } },
+            { type: { type: "float", size: 64 } },
+        ],
+        returnType: { type: "undefined" },
+    },
+    scroll: {
+        params: [
+            { type: { type: "float", size: 64 } },
+            { type: { type: "float", size: 64 } },
+        ],
+        returnType: { type: "boolean" },
+    },
+    "scroll-begin": { params: [], returnType: { type: "undefined" } },
+    "scroll-end": { params: [], returnType: { type: "undefined" } },
 };
 export class EventControllerScroll extends EventController {
     constructor(...args) {
@@ -57,13 +63,16 @@ export class EventControllerScroll extends EventController {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EventControllerScroll);
             const signalArgs = args.slice(1);
             if (!meta)
                 return handler(self, ...signalArgs);
-            const wrapped = meta.map((m, i) => {
+            const wrapped = meta.params.map((m, i) => {
                 if (m.getCls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.getCls());
                 }
@@ -74,7 +83,10 @@ export class EventControllerScroll extends EventController {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }

package/dist/generated/gtk/event-controller.js

@@ -150,6 +150,7 @@ export class EventController extends GObject.GObject {
     connect(signal, handler, after = false) {
         const selfType = { type: "gobject", borrowed: true };
         const argTypes = [selfType];
+        const returnType = undefined;
         const wrappedHandler = (...args) => {
             const self = wrapPtr(args[0], EventController);
             return handler(self, ...args.slice(1));
@@ -157,7 +158,10 @@ export class EventController extends GObject.GObject {
         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 }, value: wrappedHandler },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
             { type: { type: "boolean" }, value: after },
         ], { type: "int", size: 64, unsigned: true });
     }