@gtkx/ffi 0.1.11 → 0.1.14

package/dist/generated/gtk/drawing-area.js

@@ -1,5 +1,4 @@
 import { call } from "@gtkx/native";
-import { wrapPtr } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 export class DrawingArea extends Widget {
     constructor(...args) {
@@ -62,42 +61,13 @@ export class DrawingArea extends Widget {
                 value: drawFunc,
             },
             {
-                type: { type: "gobject" },
-                value: userData?.ptr ?? userData,
+                type: { type: "int", size: 64, unsigned: true },
+                value: userData,
             },
             {
-                type: { type: "gobject" },
-                value: destroy?.ptr ?? destroy,
+                type: { type: "callback", trampoline: "destroy" },
+                value: destroy,
             },
         ], { type: "undefined" });
     }
-    connect(signal, handler, after = false) {
-        const signalMeta = {
-            resize: [
-                { type: { type: "int", size: 32, unsigned: false } },
-                { 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/drop-controller-motion.d.ts

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

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

@@ -2,6 +2,17 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as Gdk from "../gdk/index.js";
 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 DropControllerMotion extends EventController {
     constructor(...args) {
         super(...args);
@@ -9,7 +20,7 @@ export class DropControllerMotion extends EventController {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gtk_drop_controller_motion_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     containsPointer() {
@@ -40,31 +51,21 @@ export class DropControllerMotion 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], DropControllerMotion);
             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/drop-down.d.ts

@@ -5,28 +5,27 @@ import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import { Widget } from "./widget.js";
 export declare class DropDown extends Widget {
-    constructor(model?: Gio.ListModel, expression?: Expression);
+    constructor(model?: Gio.ListModel | null, expression?: Expression | null);
     constructor(...args: unknown[]);
     static downNewFromStrings(strings: string[]): DropDown;
     protected createPtr(args: unknown[]): unknown;
     getEnableSearch(): boolean;
-    getExpression(): Expression;
-    getFactory(): ListItemFactory;
-    getHeaderFactory(): ListItemFactory;
-    getListFactory(): ListItemFactory;
-    getModel(): Gio.ListModel;
+    getExpression(): Expression | null;
+    getFactory(): ListItemFactory | null;
+    getHeaderFactory(): ListItemFactory | null;
+    getListFactory(): ListItemFactory | null;
+    getModel(): Gio.ListModel | null;
     getSearchMatchMode(): StringFilterMatchMode;
     getSelected(): number;
-    getSelectedItem(): GObject.GObject;
+    getSelectedItem(): GObject.GObject | null;
     getShowArrow(): boolean;
     setEnableSearch(enableSearch: boolean): void;
-    setExpression(expression?: Expression): void;
-    setFactory(factory?: ListItemFactory): void;
-    setHeaderFactory(factory?: ListItemFactory): void;
-    setListFactory(factory?: ListItemFactory): void;
-    setModel(model?: Gio.ListModel): void;
+    setExpression(expression?: Expression | null): void;
+    setFactory(factory?: ListItemFactory | null): void;
+    setHeaderFactory(factory?: ListItemFactory | null): void;
+    setListFactory(factory?: ListItemFactory | null): void;
+    setModel(model?: Gio.ListModel | null): void;
     setSearchMatchMode(searchMatchMode: StringFilterMatchMode): void;
     setSelected(position: number): void;
     setShowArrow(showArrow: boolean): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
 }

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

@@ -237,30 +237,4 @@ export class DropDown extends Widget {
             },
         ], { type: "undefined" });
     }
-    connect(signal, handler, after = false) {
-        const signalMeta = {
-            activate: [],
-        };
-        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/drop-target-async.d.ts

@@ -1,13 +1,20 @@
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 export declare class DropTargetAsync extends EventController {
-    constructor(actions: Gdk.DragAction, formats?: Gdk.ContentFormats);
+    constructor(actions: Gdk.DragAction, formats?: Gdk.ContentFormats | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
     getActions(): Gdk.DragAction;
-    getFormats(): Gdk.ContentFormats;
+    getFormats(): Gdk.ContentFormats | null;
     rejectDrop(drop: Gdk.Drop): void;
     setActions(actions: Gdk.DragAction): void;
-    setFormats(formats?: Gdk.ContentFormats): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    setFormats(formats?: Gdk.ContentFormats | null): void;
+    connect(signal: "accept", handler: (self: DropTargetAsync, drop: Gdk.Drop) => boolean, after?: boolean): number;
+    connect(signal: "drag-enter", handler: (self: DropTargetAsync, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction, after?: boolean): number;
+    connect(signal: "drag-leave", handler: (self: DropTargetAsync, drop: Gdk.Drop) => void, after?: boolean): number;
+    connect(signal: "drag-motion", handler: (self: DropTargetAsync, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction, after?: boolean): number;
+    connect(signal: "drop", handler: (self: DropTargetAsync, drop: Gdk.Drop, x: number, y: number) => boolean, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DropTargetAsync, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -2,6 +2,25 @@ import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
+const SIGNAL_META = {
+    accept: [{ type: { type: "gobject", borrowed: false } }],
+    "drag-enter": [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    "drag-leave": [{ type: { type: "gobject", borrowed: false } }],
+    "drag-motion": [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+    drop: [
+        { type: { type: "gobject", borrowed: false } },
+        { type: { type: "float", size: 64 } },
+        { type: { type: "float", size: 64 } },
+    ],
+};
 export class DropTargetAsync extends EventController {
     constructor(...args) {
         super(...args);
@@ -21,7 +40,7 @@ export class DropTargetAsync extends EventController {
                 type: { type: "int", size: 32, unsigned: false },
                 value: actions,
             },
-        ], { type: "gobject", borrowed: true });
+        ], { type: "gobject", borrowed: false });
     }
     getActions() {
         return call("libgtk-4.so.1", "gtk_drop_target_async_get_actions", [
@@ -88,39 +107,21 @@ export class DropTargetAsync extends EventController {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            accept: [{ type: { type: "gobject", borrowed: false } }],
-            "drag-enter": [
-                { type: { type: "gobject", borrowed: false } },
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-            "drag-leave": [{ type: { type: "gobject", borrowed: false } }],
-            "drag-motion": [
-                { type: { type: "gobject", borrowed: false } },
-                { type: { type: "float", size: 64 } },
-                { type: { type: "float", size: 64 } },
-            ],
-            drop: [
-                { type: { type: "gobject", borrowed: false } },
-                { 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], DropTargetAsync);
             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/drop-target.d.ts

@@ -7,15 +7,21 @@ export declare class DropTarget extends EventController {
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
     getActions(): Gdk.DragAction;
-    getCurrentDrop(): Gdk.Drop;
-    getDrop(): Gdk.Drop;
-    getFormats(): Gdk.ContentFormats;
-    getGtypes(nTypes?: Ref<unknown>): number[];
+    getCurrentDrop(): Gdk.Drop | null;
+    getDrop(): Gdk.Drop | null;
+    getFormats(): Gdk.ContentFormats | null;
+    getGtypes(nTypes?: Ref<number> | null): number[] | null;
     getPreload(): boolean;
-    getValue(): GObject.Value;
+    getValue(): GObject.Value | null;
     reject(): void;
     setActions(actions: Gdk.DragAction): void;
-    setGtypes(nTypes: unknown, types?: number[]): void;
+    setGtypes(nTypes: number, types?: number[] | null): void;
     setPreload(preload: boolean): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+    connect(signal: "accept", handler: (self: DropTarget, drop: Gdk.Drop) => boolean, after?: boolean): number;
+    connect(signal: "drop", handler: (self: DropTarget, value: GObject.Value, x: number, y: number) => boolean, after?: boolean): number;
+    connect(signal: "enter", handler: (self: DropTarget, x: number, y: number) => Gdk.DragAction, after?: boolean): number;
+    connect(signal: "leave", handler: (self: DropTarget) => void, after?: boolean): number;
+    connect(signal: "motion", handler: (self: DropTarget, x: number, y: number) => Gdk.DragAction, after?: boolean): number;
+    connect(signal: "notify", handler: (self: DropTarget, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

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

@@ -3,6 +3,23 @@ import { wrapPtr } from "@gtkx/ffi";
 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 } },
+    ],
+};
 export class DropTarget extends EventController {
     constructor(...args) {
         super(...args);
@@ -18,7 +35,7 @@ export class DropTarget extends EventController {
                 type: { type: "int", size: 32, unsigned: false },
                 value: actions,
             },
-        ], { type: "gobject", borrowed: true });
+        ], { type: "gobject", borrowed: false });
     }
     getActions() {
         return call("libgtk-4.so.1", "gtk_drop_target_get_actions", [
@@ -73,7 +90,10 @@ export class DropTarget extends EventController {
                 value: this.ptr,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 64, unsigned: true },
+                },
                 value: nTypes,
             },
         ], { type: "array", itemType: { type: "int", size: 64, unsigned: true } });
@@ -136,8 +156,8 @@ export class DropTarget extends EventController {
                 value: types,
             },
             {
-                type: { type: "gobject" },
-                value: nTypes?.ptr ?? nTypes,
+                type: { type: "int", size: 64, unsigned: true },
+                value: nTypes,
             },
         ], { type: "undefined" });
     }
@@ -154,37 +174,21 @@ export class DropTarget extends EventController {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
-        const signalMeta = {
-            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 } },
-            ],
-        };
-        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], DropTarget);
             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/editable-label.d.ts

@@ -15,12 +15,12 @@ export declare class EditableLabel extends Widget {
     finishDelegate(): void;
     getAlignment(): number;
     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;

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

@@ -182,7 +182,7 @@ export class EditableLabel 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", [

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

@@ -10,12 +10,12 @@ export declare class Editable {
     finishDelegate(): void;
     getAlignment(): number;
     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;

package/dist/generated/gtk/editable.js

@@ -147,7 +147,7 @@ export class Editable {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     getWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_width_chars", [

package/dist/generated/gtk/emoji-chooser.d.ts

@@ -2,5 +2,4 @@ import { Popover } from "./popover.js";
 export declare class EmojiChooser extends Popover {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
 }

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

@@ -1,5 +1,4 @@
 import { call } from "@gtkx/native";
-import { wrapPtr } from "@gtkx/ffi";
 import { Popover } from "./popover.js";
 export class EmojiChooser extends Popover {
     constructor(...args) {
@@ -11,30 +10,4 @@ export class EmojiChooser extends Popover {
             borrowed: true,
         });
     }
-    connect(signal, handler, after = false) {
-        const signalMeta = {
-            "emoji-picked": [{ type: { type: "string" } }],
-        };
-        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/entry-buffer.d.ts

@@ -1,17 +1,16 @@
-export declare class EntryBuffer {
-    ptr: unknown;
-    constructor(nInitialChars: number, initialChars?: string);
+import * as GObject from "../gobject/index.js";
+export declare class EntryBuffer extends GObject.GObject {
+    constructor(nInitialChars: number, initialChars?: string | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
     deleteText(position: number, nChars: number): number;
     emitDeletedText(position: number, nChars: number): void;
     emitInsertedText(position: number, chars: string, nChars: number): void;
-    getBytes(): unknown;
+    getBytes(): number;
     getLength(): number;
     getMaxLength(): number;
     getText(): string;
     insertText(position: number, chars: string, nChars: number): number;
     setMaxLength(maxLength: number): void;
     setText(chars: string, nChars: number): void;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
 }

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

@@ -1,9 +1,8 @@
 import { call } from "@gtkx/native";
-import { wrapPtr } from "@gtkx/ffi";
-export class EntryBuffer {
-    ptr;
+import * as GObject from "../gobject/index.js";
+export class EntryBuffer extends GObject.GObject {
     constructor(...args) {
-        this.ptr = this.createPtr(args);
+        super(...args);
     }
     createPtr(args) {
         const [initialChars, nInitialChars] = args;
@@ -16,7 +15,7 @@ export class EntryBuffer {
                 type: { type: "int", size: 32, unsigned: false },
                 value: nInitialChars,
             },
-        ], { type: "gobject", borrowed: true });
+        ], { type: "gobject", borrowed: false });
     }
     deleteText(position, nChars) {
         return call("libgtk-4.so.1", "gtk_entry_buffer_delete_text", [
@@ -76,7 +75,7 @@ export class EntryBuffer {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "gobject", borrowed: true });
+        ], { type: "int", size: 64, unsigned: true });
     }
     getLength() {
         return call("libgtk-4.so.1", "gtk_entry_buffer_get_length", [
@@ -100,7 +99,7 @@ export class EntryBuffer {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     insertText(position, chars, nChars) {
         return call("libgtk-4.so.1", "gtk_entry_buffer_insert_text", [
@@ -150,38 +149,4 @@ export class EntryBuffer {
             },
         ], { type: "undefined" });
     }
-    connect(signal, handler, after = false) {
-        const signalMeta = {
-            "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" } },
-                { type: { type: "int", size: 32, unsigned: true } },
-            ],
-        };
-        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 });
-    }
 }