@gtkx/ffi 0.1.12 → 0.1.14

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

@@ -13,32 +13,32 @@ export declare class Entry extends Widget {
     protected createPtr(_args: unknown[]): unknown;
     getActivatesDefault(): boolean;
     getAlignment(): number;
-    getAttributes(): Pango.AttrList;
+    getAttributes(): Pango.AttrList | null;
     getBuffer(): EntryBuffer;
-    getCompletion(): EntryCompletion;
+    getCompletion(): EntryCompletion | null;
     getCurrentIconDragSource(): number;
-    getExtraMenu(): Gio.MenuModel;
+    getExtraMenu(): Gio.MenuModel | null;
     getHasFrame(): boolean;
     getIconActivatable(iconPos: EntryIconPosition): boolean;
     getIconArea(iconPos: EntryIconPosition, iconArea: Ref<Gdk.Rectangle>): void;
     getIconAtPos(x: number, y: number): number;
-    getIconGicon(iconPos: EntryIconPosition): Gio.Icon;
-    getIconName(iconPos: EntryIconPosition): string;
-    getIconPaintable(iconPos: EntryIconPosition): Gdk.Paintable;
+    getIconGicon(iconPos: EntryIconPosition): Gio.Icon | null;
+    getIconName(iconPos: EntryIconPosition): string | null;
+    getIconPaintable(iconPos: EntryIconPosition): Gdk.Paintable | null;
     getIconSensitive(iconPos: EntryIconPosition): boolean;
     getIconStorageType(iconPos: EntryIconPosition): ImageType;
-    getIconTooltipMarkup(iconPos: EntryIconPosition): string;
-    getIconTooltipText(iconPos: EntryIconPosition): string;
+    getIconTooltipMarkup(iconPos: EntryIconPosition): string | null;
+    getIconTooltipText(iconPos: EntryIconPosition): string | null;
     getInputHints(): InputHints;
     getInputPurpose(): InputPurpose;
     getInvisibleChar(): unknown;
     getMaxLength(): number;
-    getMenuEntryIconText(iconPos: EntryIconPosition): string;
+    getMenuEntryIconText(iconPos: EntryIconPosition): string | null;
     getOverwriteMode(): boolean;
-    getPlaceholderText(): string;
+    getPlaceholderText(): string | null;
     getProgressFraction(): number;
     getProgressPulseStep(): number;
-    getTabs(): Pango.TabArray;
+    getTabs(): Pango.TabArray | null;
     getTextLength(): number;
     getVisibility(): boolean;
     grabFocusWithoutSelecting(): boolean;
@@ -48,43 +48,43 @@ export declare class Entry extends Widget {
     setAlignment(xalign: number): void;
     setAttributes(attrs: Pango.AttrList): void;
     setBuffer(buffer: EntryBuffer): void;
-    setCompletion(completion?: EntryCompletion): void;
-    setExtraMenu(model?: Gio.MenuModel): void;
+    setCompletion(completion?: EntryCompletion | null): void;
+    setExtraMenu(model?: Gio.MenuModel | null): void;
     setHasFrame(setting: boolean): void;
     setIconActivatable(iconPos: EntryIconPosition, activatable: boolean): void;
     setIconDragSource(iconPos: EntryIconPosition, provider: Gdk.ContentProvider, actions: Gdk.DragAction): void;
-    setIconFromGicon(iconPos: EntryIconPosition, icon?: Gio.Icon): void;
-    setIconFromIconName(iconPos: EntryIconPosition, iconName?: string): void;
-    setIconFromPaintable(iconPos: EntryIconPosition, paintable?: Gdk.Paintable): void;
+    setIconFromGicon(iconPos: EntryIconPosition, icon?: Gio.Icon | null): void;
+    setIconFromIconName(iconPos: EntryIconPosition, iconName?: string | null): void;
+    setIconFromPaintable(iconPos: EntryIconPosition, paintable?: Gdk.Paintable | null): void;
     setIconSensitive(iconPos: EntryIconPosition, sensitive: boolean): void;
-    setIconTooltipMarkup(iconPos: EntryIconPosition, tooltip?: string): void;
-    setIconTooltipText(iconPos: EntryIconPosition, tooltip?: string): void;
+    setIconTooltipMarkup(iconPos: EntryIconPosition, tooltip?: string | null): void;
+    setIconTooltipText(iconPos: EntryIconPosition, tooltip?: string | null): void;
     setInputHints(hints: InputHints): void;
     setInputPurpose(purpose: InputPurpose): void;
     setInvisibleChar(ch: unknown): void;
     setMaxLength(max: number): void;
     setMenuEntryIconText(iconPos: EntryIconPosition, text: string): void;
     setOverwriteMode(overwrite: boolean): void;
-    setPlaceholderText(text?: string): void;
+    setPlaceholderText(text?: string | null): void;
     setProgressFraction(fraction: number): void;
     setProgressPulseStep(fraction: number): void;
-    setTabs(tabs?: Pango.TabArray): void;
+    setTabs(tabs?: Pango.TabArray | null): void;
     setVisibility(visible: boolean): void;
     unsetInvisibleChar(): void;
     editingDone(): void;
     removeWidget(): void;
-    startEditing(event?: Gdk.Event): void;
+    startEditing(event?: Gdk.Event | null): void;
     delegateGetAccessiblePlatformState(state: AccessiblePlatformState): boolean;
     deleteSelection(): void;
     deleteText(startPos: number, endPos: number): void;
     finishDelegate(): void;
     getChars(startPos: number, endPos: number): string;
-    getDelegate(): Editable;
+    getDelegate(): Editable | null;
     getEditable(): boolean;
     getEnableUndo(): boolean;
     getMaxWidthChars(): number;
     getPosition(): number;
-    getSelectionBounds(startPos?: Ref<number>, endPos?: Ref<number>): boolean;
+    getSelectionBounds(startPos?: Ref<number> | null, endPos?: Ref<number> | null): boolean;
     getText(): string;
     getWidthChars(): number;
     initDelegate(): void;
@@ -96,5 +96,4 @@ export declare class Entry extends Widget {
     setPosition(position: number): void;
     setText(text: string): void;
     setWidthChars(nChars: number): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
 }

package/dist/generated/gtk/entry.js

@@ -65,8 +65,6 @@ export class Entry extends Widget {
                 value: this.ptr,
             },
         ], { type: "gobject", borrowed: true });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, EntryBuffer);
     }
     getCompletion() {
@@ -183,7 +181,7 @@ export class Entry extends Widget {
                 type: { type: "int", size: 32, unsigned: false },
                 value: iconPos,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     getIconPaintable(iconPos) {
         const ptr = call("libgtk-4.so.1", "gtk_entry_get_icon_paintable", [
@@ -290,7 +288,7 @@ export class Entry extends Widget {
                 type: { type: "int", size: 32, unsigned: false },
                 value: iconPos,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     getOverwriteMode() {
         return call("libgtk-4.so.1", "gtk_entry_get_overwrite_mode", [
@@ -306,7 +304,7 @@ export class Entry extends Widget {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     getProgressFraction() {
         return call("libgtk-4.so.1", "gtk_entry_get_progress_fraction", [
@@ -907,7 +905,7 @@ export class Entry extends Widget {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     getWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_width_chars", [
@@ -1036,32 +1034,4 @@ export class Entry extends Widget {
             },
         ], { type: "undefined" });
     }
-    connect(signal, handler, after = false) {
-        const signalMeta = {
-            activate: [],
-            "icon-press": [{ type: { type: "int", size: 32, unsigned: false } }],
-            "icon-release": [{ type: { type: "int", size: 32, unsigned: false } }],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: false };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
-        const wrappedHandler = (...args) => {
-            const signalArgs = args.slice(1);
-            if (!meta)
-                return handler(...signalArgs);
-            const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
-                }
-                return signalArgs[i];
-            });
-            return handler(...wrapped);
-        };
-        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: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
-    }
 }

package/dist/generated/gtk/event-controller-focus.d.ts

@@ -1,8 +1,12 @@
+import * as GObject from "../gobject/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerFocus extends EventController {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     containsFocus(): boolean;
     isFocus(): boolean;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "enter", handler: (self: EventControllerFocus) => void, after?: boolean): number;
+    connect(signal: "leave", handler: (self: EventControllerFocus) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EventControllerFocus, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,6 +1,10 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
+const SIGNAL_META = {
+    enter: [],
+    leave: [],
+};
 export class EventControllerFocus extends EventController {
     constructor(...args) {
         super(...args);
@@ -8,7 +12,7 @@ export class EventControllerFocus extends EventController {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_event_controller_focus_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     containsFocus() {
@@ -28,24 +32,21 @@ export class EventControllerFocus extends EventController {
         ], { type: "boolean" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            enter: [],
-            leave: [],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: false };
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
         const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
         const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], EventControllerFocus);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/event-controller-key.d.ts

@@ -1,12 +1,19 @@
 import { IMContext } from "./imcontext.js";
 import { Widget } from "./widget.js";
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerKey extends EventController {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     forward(widget: Widget): boolean;
     getGroup(): number;
-    getImContext(): IMContext;
-    setImContext(imContext?: IMContext): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    getImContext(): IMContext | null;
+    setImContext(imContext?: IMContext | null): void;
+    connect(signal: "im-update", handler: (self: EventControllerKey) => void, after?: boolean): number;
+    connect(signal: "key-pressed", handler: (self: EventControllerKey, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean, after?: boolean): number;
+    connect(signal: "key-released", handler: (self: EventControllerKey, keyval: number, keycode: number, state: Gdk.ModifierType) => void, after?: boolean): number;
+    connect(signal: "modifiers", handler: (self: EventControllerKey, state: Gdk.ModifierType) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EventControllerKey, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -2,6 +2,20 @@ import { call } from "@gtkx/native";
 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 } }],
+};
 export class EventControllerKey extends EventController {
     constructor(...args) {
         super(...args);
@@ -9,7 +23,7 @@ export class EventControllerKey extends EventController {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_event_controller_key_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     forward(widget) {
@@ -56,34 +70,21 @@ export class EventControllerKey extends EventController {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            "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 } }],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: false };
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
         const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
         const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], EventControllerKey);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/event-controller-legacy.d.ts

@@ -1,6 +1,10 @@
+import * as GObject from "../gobject/index.js";
+import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerLegacy extends EventController {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "event", handler: (self: EventControllerLegacy, event: Gdk.Event) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EventControllerLegacy, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,6 +1,9 @@
 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 } }],
+};
 export class EventControllerLegacy extends EventController {
     constructor(...args) {
         super(...args);
@@ -8,27 +11,25 @@ export class EventControllerLegacy extends EventController {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_event_controller_legacy_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            event: [{ type: { type: "gobject", borrowed: false } }],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: false };
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
         const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
         const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], EventControllerLegacy);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/event-controller-motion.d.ts

@@ -1,8 +1,13 @@
+import * as GObject from "../gobject/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerMotion extends EventController {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     containsPointer(): boolean;
     isPointer(): boolean;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "enter", handler: (self: EventControllerMotion, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "leave", handler: (self: EventControllerMotion) => void, after?: boolean): number;
+    connect(signal: "motion", handler: (self: EventControllerMotion, x: number, y: number) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EventControllerMotion, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,6 +1,17 @@
 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 } },
+    ],
+};
 export class EventControllerMotion extends EventController {
     constructor(...args) {
         super(...args);
@@ -8,7 +19,7 @@ export class EventControllerMotion extends EventController {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_event_controller_motion_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     containsPointer() {
@@ -28,31 +39,21 @@ export class EventControllerMotion extends EventController {
         ], { type: "boolean" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            enter: [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-            leave: [],
-            motion: [
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: false };
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
         const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
         const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], EventControllerMotion);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/event-controller-scroll.d.ts

@@ -1,4 +1,5 @@
 import { EventControllerScrollFlags } from "./enums.js";
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerScroll extends EventController {
@@ -8,5 +9,10 @@ export declare class EventControllerScroll extends EventController {
     getFlags(): EventControllerScrollFlags;
     getUnit(): Gdk.ScrollUnit;
     setFlags(flags: EventControllerScrollFlags): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "decelerate", handler: (self: EventControllerScroll, velX: number, velY: number) => void, after?: boolean): number;
+    connect(signal: "scroll", handler: (self: EventControllerScroll, dx: number, dy: number) => boolean, after?: boolean): number;
+    connect(signal: "scroll-begin", handler: (self: EventControllerScroll) => void, after?: boolean): number;
+    connect(signal: "scroll-end", handler: (self: EventControllerScroll) => void, after?: boolean): number;
+    connect(signal: "notify", handler: (self: EventControllerScroll, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -1,6 +1,18 @@
 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": [],
+};
 export class EventControllerScroll extends EventController {
     constructor(...args) {
         super(...args);
@@ -12,7 +24,7 @@ export class EventControllerScroll extends EventController {
                 type: { type: "int", size: 32, unsigned: false },
                 value: flags,
             },
-        ], { type: "gobject", borrowed: true });
+        ], { type: "gobject", borrowed: false });
     }
     getFlags() {
         return call("libgtk-4.so.1", "gtk_event_controller_scroll_get_flags", [
@@ -43,32 +55,21 @@ export class EventControllerScroll extends EventController {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            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": [],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: false };
+        const meta = SIGNAL_META[signal];
+        const selfType = { type: "gobject", borrowed: true };
         const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
         const wrappedHandler = (...args) => {
+            const self = wrapPtr(args[0], EventControllerScroll);
             const signalArgs = args.slice(1);
             if (!meta)
-                return handler(...signalArgs);
+                return handler(self, ...signalArgs);
             const wrapped = meta.map((m, i) => {
                 if (m.cls && signalArgs[i] != null) {
                     return wrapPtr(signalArgs[i], m.cls);
                 }
                 return signalArgs[i];
             });
-            return handler(...wrapped);
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/event-controller.d.ts

@@ -5,17 +5,17 @@ import * as Gdk from "../gdk/index.js";
 export declare class EventController extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    getCurrentEvent(): Gdk.Event;
-    getCurrentEventDevice(): Gdk.Device;
+    getCurrentEvent(): Gdk.Event | null;
+    getCurrentEventDevice(): Gdk.Device | null;
     getCurrentEventState(): Gdk.ModifierType;
     getCurrentEventTime(): number;
-    getName(): string;
+    getName(): string | null;
     getPropagationLimit(): PropagationLimit;
     getPropagationPhase(): PropagationPhase;
-    getWidget(): Widget;
+    getWidget(): Widget | null;
     reset(): void;
-    setName(name?: string): void;
+    setName(name?: string | null): void;
     setPropagationLimit(limit: PropagationLimit): void;
     setPropagationPhase(phase: PropagationPhase): void;
-    setStaticName(name?: string): void;
+    setStaticName(name?: string | null): void;
 }

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

@@ -62,7 +62,7 @@ export class EventController extends GObject.GObject {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     getPropagationLimit() {
         return call("libgtk-4.so.1", "gtk_event_controller_get_propagation_limit", [

package/dist/generated/gtk/every-filter.js

@@ -7,7 +7,7 @@ export class EveryFilter extends MultiFilter {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_every_filter_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
 }

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

@@ -1,22 +1,21 @@
 import { Widget } from "./widget.js";
 export declare class Expander extends Widget {
-    constructor(label?: string);
+    constructor(label?: string | null);
     constructor(...args: unknown[]);
-    static newWithMnemonic(label?: string): Expander;
+    static newWithMnemonic(label?: string | null): Expander;
     protected createPtr(args: unknown[]): unknown;
-    getChild(): Widget;
+    getChild(): Widget | null;
     getExpanded(): boolean;
-    getLabel(): string;
-    getLabelWidget(): Widget;
+    getLabel(): string | null;
+    getLabelWidget(): Widget | null;
     getResizeToplevel(): boolean;
     getUseMarkup(): boolean;
     getUseUnderline(): boolean;
-    setChild(child?: Widget): void;
+    setChild(child?: Widget | null): void;
     setExpanded(expanded: boolean): void;
-    setLabel(label?: string): void;
-    setLabelWidget(labelWidget?: Widget): void;
+    setLabel(label?: string | null): void;
+    setLabelWidget(labelWidget?: Widget | null): void;
     setResizeToplevel(resizeToplevel: boolean): void;
     setUseMarkup(useMarkup: boolean): void;
     setUseUnderline(useUnderline: boolean): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
 }