@gtkx/ffi 0.1.0 → 0.1.2

package/dist/generated/gtk/drag-source.js

@@ -1,9 +1,11 @@
 import { call } from "@gtkx/native";
 import { GestureSingle } from "./gesture-single.js";
 export class DragSource extends GestureSingle {
-    constructor() {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_drag_source_new", [], {
+    constructor(_args = []) {
+        super(_args);
+    }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gtk_drag_source_new", [], {
             type: "gobject",
             borrowed: true,
         });
@@ -113,17 +115,19 @@ export class DragSource extends GestureSingle {
             ],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

package/dist/generated/gtk/drawing-area.d.ts

@@ -1,6 +1,7 @@
 import { Widget } from "./widget.js";
 export declare class DrawingArea extends Widget {
-    constructor();
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getContentHeight(): number;
     getContentWidth(): number;
     setContentHeight(height: number): void;

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

@@ -1,9 +1,11 @@
 import { call } from "@gtkx/native";
 import { Widget } from "./widget.js";
 export class DrawingArea extends Widget {
-    constructor() {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_drawing_area_new", [], {
+    constructor(_args = []) {
+        super(_args);
+    }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gtk_drawing_area_new", [], {
             type: "gobject",
             borrowed: true,
         });
@@ -88,17 +90,19 @@ export class DrawingArea extends Widget {
             ],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,6 +1,7 @@
 import { EventController } from "./event-controller.js";
 export declare class DropControllerMotion extends EventController {
-    constructor();
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     containsPointer(): boolean;
     getDrop(): unknown;
     isPointer(): boolean;

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

@@ -1,9 +1,11 @@
 import { call } from "@gtkx/native";
 import { EventController } from "./event-controller.js";
 export class DropControllerMotion extends EventController {
-    constructor() {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_drop_controller_motion_new", [], {
+    constructor(_args = []) {
+        super(_args);
+    }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gtk_drop_controller_motion_new", [], {
             type: "gobject",
             borrowed: true,
         });
@@ -48,17 +50,19 @@ export class DropControllerMotion extends EventController {
             ],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

package/dist/generated/gtk/drop-down.d.ts

@@ -2,7 +2,9 @@ import { StringFilterMatchMode } from "./enums.js";
 import { Widget } from "./widget.js";
 export declare class DropDown extends Widget {
     constructor(model?: unknown, expression?: unknown);
+    constructor(_args: unknown[]);
     static downNewFromStrings(strings: string[]): DropDown;
+    protected createPtr(_args: unknown[]): unknown;
     getEnableSearch(): boolean;
     getExpression(): unknown;
     getFactory(): unknown;

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

@@ -1,18 +1,9 @@
 import { call } from "@gtkx/native";
 import { Widget } from "./widget.js";
 export class DropDown extends Widget {
-    constructor(model, expression) {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_drop_down_new", [
-            {
-                type: { type: "gobject" },
-                value: model,
-            },
-            {
-                type: { type: "gobject" },
-                value: expression,
-            },
-        ], { type: "gobject", borrowed: true });
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        super(_args);
     }
     static downNewFromStrings(strings) {
         const ptr = call("libgtk-4.so.1", "gtk_drop_down_new_from_strings", [
@@ -25,6 +16,19 @@ export class DropDown extends Widget {
         instance.ptr = ptr;
         return instance;
     }
+    createPtr(_args) {
+        const [model, expression] = _args;
+        return call("libgtk-4.so.1", "gtk_drop_down_new", [
+            {
+                type: { type: "gobject" },
+                value: model,
+            },
+            {
+                type: { type: "gobject" },
+                value: expression,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
     getEnableSearch() {
         return call("libgtk-4.so.1", "gtk_drop_down_get_enable_search", [
             {
@@ -275,17 +279,19 @@ export class DropDown extends Widget {
             activate: [],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

package/dist/generated/gtk/drop-target-async.d.ts

@@ -1,6 +1,8 @@
 import { EventController } from "./event-controller.js";
 export declare class DropTargetAsync extends EventController {
-    constructor(formats?: unknown, actions?: unknown);
+    constructor(actions: unknown, formats?: unknown);
+    constructor(_args: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getActions(): unknown;
     getFormats(): unknown;
     rejectDrop(drop: unknown): void;

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

@@ -1,9 +1,13 @@
 import { call } from "@gtkx/native";
 import { EventController } from "./event-controller.js";
 export class DropTargetAsync extends EventController {
-    constructor(formats, actions) {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_drop_target_async_new", [
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        super(_args);
+    }
+    createPtr(_args) {
+        const [formats, actions] = _args;
+        return call("libgtk-4.so.1", "gtk_drop_target_async_new", [
             {
                 type: { type: "gobject" },
                 value: formats,
@@ -99,17 +103,19 @@ export class DropTargetAsync extends EventController {
             ],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

package/dist/generated/gtk/drop-target.d.ts

@@ -1,7 +1,9 @@
 import { Ref } from "@gtkx/native";
 import { EventController } from "./event-controller.js";
 export declare class DropTarget extends EventController {
-    constructor(type?: number, actions?: unknown);
+    constructor(type: number, actions: unknown);
+    constructor(_args: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getActions(): unknown;
     getCurrentDrop(): unknown;
     getDrop(): unknown;

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

@@ -1,9 +1,13 @@
 import { call } from "@gtkx/native";
 import { EventController } from "./event-controller.js";
 export class DropTarget extends EventController {
-    constructor(type, actions) {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_drop_target_new", [
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        super(_args);
+    }
+    createPtr(_args) {
+        const [type, actions] = _args;
+        return call("libgtk-4.so.1", "gtk_drop_target_new", [
             {
                 type: { type: "int", size: 64, unsigned: true },
                 value: type,
@@ -168,17 +172,19 @@ export class DropTarget extends EventController {
             ],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,6 +1,8 @@
 import { Widget } from "./widget.js";
 export declare class EditableLabel extends Widget {
-    constructor(str?: string);
+    constructor(str: string);
+    constructor(_args: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getEditing(): boolean;
     startEditing(): void;
     stopEditing(commit: boolean): void;

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

@@ -1,9 +1,13 @@
 import { call } from "@gtkx/native";
 import { Widget } from "./widget.js";
 export class EditableLabel extends Widget {
-    constructor(str) {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_editable_label_new", [
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        super(_args);
+    }
+    createPtr(_args) {
+        const [str] = _args;
+        return call("libgtk-4.so.1", "gtk_editable_label_new", [
             {
                 type: { type: "string" },
                 value: str,

package/dist/generated/gtk/editable.js

@@ -333,17 +333,19 @@ export class Editable {
             ],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,5 +1,6 @@
 import { Popover } from "./popover.js";
 export declare class EmojiChooser extends Popover {
-    constructor();
+    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,9 +1,11 @@
 import { call } from "@gtkx/native";
 import { Popover } from "./popover.js";
 export class EmojiChooser extends Popover {
-    constructor() {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_emoji_chooser_new", [], {
+    constructor(_args = []) {
+        super(_args);
+    }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gtk_emoji_chooser_new", [], {
             type: "gobject",
             borrowed: true,
         });
@@ -13,17 +15,19 @@ export class EmojiChooser extends Popover {
             "emoji-picked": [{ type: { type: "string" } }],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,6 +1,8 @@
 export declare class EntryBuffer {
     ptr: unknown;
-    constructor(_skipCreate?: boolean, initialChars?: string, nInitialChars?: number);
+    constructor(nInitialChars: number, initialChars?: string);
+    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;

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

@@ -1,18 +1,22 @@
 import { call } from "@gtkx/native";
 export class EntryBuffer {
     ptr;
-    constructor(_skipCreate, initialChars, nInitialChars) {
-        if (!_skipCreate)
-            this.ptr = call("libgtk-4.so.1", "gtk_entry_buffer_new", [
-                {
-                    type: { type: "string" },
-                    value: initialChars,
-                },
-                {
-                    type: { type: "int", size: 32, unsigned: false },
-                    value: nInitialChars,
-                },
-            ], { type: "gobject", borrowed: true });
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        this.ptr = this.createPtr(_args);
+    }
+    createPtr(_args) {
+        const [initialChars, nInitialChars] = _args;
+        return call("libgtk-4.so.1", "gtk_entry_buffer_new", [
+            {
+                type: { type: "string" },
+                value: initialChars,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: nInitialChars,
+            },
+        ], { type: "gobject", borrowed: true });
     }
     deleteText(position, nChars) {
         return call("libgtk-4.so.1", "gtk_entry_buffer_delete_text", [
@@ -174,17 +178,19 @@ export class EntryBuffer {
             ],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,7 +1,8 @@
 export declare class EntryCompletion {
     ptr: unknown;
-    constructor();
+    constructor(_args?: unknown[]);
     static completionNewWithArea(area: unknown): EntryCompletion;
+    protected createPtr(_args: unknown[]): unknown;
     complete(): void;
     computePrefix(key: string): string;
     getCompletionPrefix(): string;

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

@@ -1,11 +1,8 @@
 import { call } from "@gtkx/native";
 export class EntryCompletion {
     ptr;
-    constructor() {
-        this.ptr = call("libgtk-4.so.1", "gtk_entry_completion_new", [], {
-            type: "gobject",
-            borrowed: true,
-        });
+    constructor(_args = []) {
+        this.ptr = this.createPtr(_args);
     }
     static completionNewWithArea(area) {
         const ptr = call("libgtk-4.so.1", "gtk_entry_completion_new_with_area", [
@@ -18,6 +15,12 @@ export class EntryCompletion {
         instance.ptr = ptr;
         return instance;
     }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gtk_entry_completion_new", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+    }
     complete() {
         call("libgtk-4.so.1", "gtk_entry_completion_complete", [
             {
@@ -307,17 +310,19 @@ export class EntryCompletion {
             "no-matches": [],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -2,8 +2,9 @@ import { Ref } from "@gtkx/native";
 import { EntryIconPosition, ImageType, InputHints, InputPurpose } from "./enums.js";
 import { Widget } from "./widget.js";
 export declare class Entry extends Widget {
-    constructor();
+    constructor(_args?: unknown[]);
     static newWithBuffer(buffer: unknown): Entry;
+    protected createPtr(_args: unknown[]): unknown;
     getActivatesDefault(): boolean;
     getAlignment(): number;
     getAttributes(): unknown;

package/dist/generated/gtk/entry.js

@@ -1,12 +1,8 @@
 import { call } from "@gtkx/native";
 import { Widget } from "./widget.js";
 export class Entry extends Widget {
-    constructor() {
-        super(true);
-        this.ptr = call("libgtk-4.so.1", "gtk_entry_new", [], {
-            type: "gobject",
-            borrowed: true,
-        });
+    constructor(_args = []) {
+        super(_args);
     }
     static newWithBuffer(buffer) {
         const ptr = call("libgtk-4.so.1", "gtk_entry_new_with_buffer", [
@@ -19,6 +15,12 @@ export class Entry extends Widget {
         instance.ptr = ptr;
         return instance;
     }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gtk_entry_new", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+    }
     getActivatesDefault() {
         return call("libgtk-4.so.1", "gtk_entry_get_activates_default", [
             {
@@ -936,17 +938,19 @@ export class Entry extends Widget {
             "icon-release": [{ type: { type: "int", size: 32, unsigned: false } }],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,6 +1,7 @@
 import { EventController } from "./event-controller.js";
 export declare class EventControllerFocus extends EventController {
-    constructor();
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     containsFocus(): boolean;
     isFocus(): boolean;
     connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;