@gtkx/ffi 0.1.0

package/dist/generated/gdk/vulkan-context.js

@@ -0,0 +1,34 @@
+import { call } from "@gtkx/native";
+import { DrawContext } from "./draw-context.js";
+export class VulkanContext extends DrawContext {
+    ptr = undefined;
+    constructor() {
+        super(true);
+    }
+    connect(signal, handler, after = false) {
+        const signalMeta = {
+            "images-updated": [],
+        };
+        const meta = signalMeta[signal];
+        const argTypes = meta?.map((m) => m.type);
+        const wrappedHandler = (...args) => {
+            if (!meta)
+                return handler(...args);
+            const wrapped = meta.map((m, i) => {
+                if (m.cls && args[i] != null) {
+                    const inst = Object.create(m.cls.prototype);
+                    inst.ptr = args[i];
+                    return inst;
+                }
+                return args[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/gdkpixbuf/enums.d.ts

@@ -0,0 +1,33 @@
+export declare enum Colorspace {
+    RGB = 0
+}
+export declare enum InterpType {
+    NEAREST = 0,
+    TILES = 1,
+    BILINEAR = 2,
+    HYPER = 3
+}
+export declare enum PixbufAlphaMode {
+    BILEVEL = 0,
+    FULL = 1
+}
+export declare enum PixbufError {
+    CORRUPT_IMAGE = 0,
+    INSUFFICIENT_MEMORY = 1,
+    BAD_OPTION = 2,
+    UNKNOWN_TYPE = 3,
+    UNSUPPORTED_OPERATION = 4,
+    FAILED = 5,
+    INCOMPLETE_ANIMATION = 6
+}
+export declare enum PixbufRotation {
+    NONE = 0,
+    COUNTERCLOCKWISE = 90,
+    UPSIDEDOWN = 180,
+    CLOCKWISE = 270
+}
+export declare enum PixbufFormatFlags {
+    WRITABLE = 1,
+    SCALABLE = 2,
+    THREADSAFE = 4
+}

package/dist/generated/gdkpixbuf/enums.js

@@ -0,0 +1,39 @@
+export var Colorspace;
+(function (Colorspace) {
+    Colorspace[Colorspace["RGB"] = 0] = "RGB";
+})(Colorspace || (Colorspace = {}));
+export var InterpType;
+(function (InterpType) {
+    InterpType[InterpType["NEAREST"] = 0] = "NEAREST";
+    InterpType[InterpType["TILES"] = 1] = "TILES";
+    InterpType[InterpType["BILINEAR"] = 2] = "BILINEAR";
+    InterpType[InterpType["HYPER"] = 3] = "HYPER";
+})(InterpType || (InterpType = {}));
+export var PixbufAlphaMode;
+(function (PixbufAlphaMode) {
+    PixbufAlphaMode[PixbufAlphaMode["BILEVEL"] = 0] = "BILEVEL";
+    PixbufAlphaMode[PixbufAlphaMode["FULL"] = 1] = "FULL";
+})(PixbufAlphaMode || (PixbufAlphaMode = {}));
+export var PixbufError;
+(function (PixbufError) {
+    PixbufError[PixbufError["CORRUPT_IMAGE"] = 0] = "CORRUPT_IMAGE";
+    PixbufError[PixbufError["INSUFFICIENT_MEMORY"] = 1] = "INSUFFICIENT_MEMORY";
+    PixbufError[PixbufError["BAD_OPTION"] = 2] = "BAD_OPTION";
+    PixbufError[PixbufError["UNKNOWN_TYPE"] = 3] = "UNKNOWN_TYPE";
+    PixbufError[PixbufError["UNSUPPORTED_OPERATION"] = 4] = "UNSUPPORTED_OPERATION";
+    PixbufError[PixbufError["FAILED"] = 5] = "FAILED";
+    PixbufError[PixbufError["INCOMPLETE_ANIMATION"] = 6] = "INCOMPLETE_ANIMATION";
+})(PixbufError || (PixbufError = {}));
+export var PixbufRotation;
+(function (PixbufRotation) {
+    PixbufRotation[PixbufRotation["NONE"] = 0] = "NONE";
+    PixbufRotation[PixbufRotation["COUNTERCLOCKWISE"] = 90] = "COUNTERCLOCKWISE";
+    PixbufRotation[PixbufRotation["UPSIDEDOWN"] = 180] = "UPSIDEDOWN";
+    PixbufRotation[PixbufRotation["CLOCKWISE"] = 270] = "CLOCKWISE";
+})(PixbufRotation || (PixbufRotation = {}));
+export var PixbufFormatFlags;
+(function (PixbufFormatFlags) {
+    PixbufFormatFlags[PixbufFormatFlags["WRITABLE"] = 1] = "WRITABLE";
+    PixbufFormatFlags[PixbufFormatFlags["SCALABLE"] = 2] = "SCALABLE";
+    PixbufFormatFlags[PixbufFormatFlags["THREADSAFE"] = 4] = "THREADSAFE";
+})(PixbufFormatFlags || (PixbufFormatFlags = {}));

package/dist/generated/gdkpixbuf/functions.d.ts

@@ -0,0 +1 @@
+export declare const pixbufErrorQuark: () => unknown;

package/dist/generated/gdkpixbuf/functions.js

@@ -0,0 +1,7 @@
+import { call } from "@gtkx/native";
+export const pixbufErrorQuark = () => {
+    return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_error_quark", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};

package/dist/generated/gdkpixbuf/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./pixbuf.js";
+export * from "./pixbuf-animation.js";
+export * from "./pixbuf-animation-iter.js";
+export * from "./pixbuf-loader.js";
+export * from "./pixbuf-non-anim.js";
+export * from "./pixbuf-simple-anim.js";
+export * from "./pixbuf-simple-anim-iter.js";
+export * from "./functions.js";
+export * from "./enums.js";

package/dist/generated/gdkpixbuf/index.js

@@ -0,0 +1,9 @@
+export * from "./pixbuf.js";
+export * from "./pixbuf-animation.js";
+export * from "./pixbuf-animation-iter.js";
+export * from "./pixbuf-loader.js";
+export * from "./pixbuf-non-anim.js";
+export * from "./pixbuf-simple-anim.js";
+export * from "./pixbuf-simple-anim-iter.js";
+export * from "./functions.js";
+export * from "./enums.js";

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.d.ts

@@ -0,0 +1,8 @@
+export declare class PixbufAnimationIter {
+    ptr: unknown;
+    constructor(_skipCreate?: boolean);
+    advance(currentTime?: unknown): boolean;
+    getDelayTime(): number;
+    getPixbuf(): unknown;
+    onCurrentlyLoadingFrame(): boolean;
+}

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.js

@@ -0,0 +1,41 @@
+import { call } from "@gtkx/native";
+export class PixbufAnimationIter {
+    ptr;
+    constructor(_skipCreate) { }
+    advance(currentTime) {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_advance", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: currentTime,
+            },
+        ], { type: "boolean" });
+    }
+    getDelayTime() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_get_delay_time", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    getPixbuf() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_get_pixbuf", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    onCurrentlyLoadingFrame() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_iter_on_currently_loading_frame", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+}

package/dist/generated/gdkpixbuf/pixbuf-animation.d.ts

@@ -0,0 +1,14 @@
+export declare class PixbufAnimation {
+    ptr: unknown;
+    constructor(_skipCreate?: boolean, filename?: string);
+    static animationNewFromResource(resourcePath: string): PixbufAnimation;
+    static animationNewFromStream(stream: unknown, cancellable?: unknown): PixbufAnimation;
+    static animationNewFromStreamFinish(asyncResult: unknown): PixbufAnimation;
+    getHeight(): number;
+    getIter(startTime?: unknown): unknown;
+    getStaticImage(): unknown;
+    getWidth(): number;
+    isStaticImage(): boolean;
+    ref(): unknown;
+    unref(): void;
+}

package/dist/generated/gdkpixbuf/pixbuf-animation.js

@@ -0,0 +1,110 @@
+import { call } from "@gtkx/native";
+export class PixbufAnimation {
+    ptr;
+    constructor(_skipCreate, filename) {
+        if (!_skipCreate)
+            this.ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_file", [
+                {
+                    type: { type: "string" },
+                    value: filename,
+                },
+            ], { type: "gobject", borrowed: true });
+    }
+    static animationNewFromResource(resourcePath) {
+        const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_resource", [
+            {
+                type: { type: "string" },
+                value: resourcePath,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(PixbufAnimation.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static animationNewFromStream(stream, cancellable) {
+        const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_stream", [
+            {
+                type: { type: "gobject" },
+                value: stream,
+            },
+            {
+                type: { type: "gobject" },
+                value: cancellable,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(PixbufAnimation.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static animationNewFromStreamFinish(asyncResult) {
+        const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_stream_finish", [
+            {
+                type: { type: "gobject" },
+                value: asyncResult,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(PixbufAnimation.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    getHeight() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_get_height", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    getIter(startTime) {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_get_iter", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: startTime,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getStaticImage() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_get_static_image", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getWidth() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_get_width", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    isStaticImage() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_is_static_image", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    ref() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_ref", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    unref() {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_unref", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+}

package/dist/generated/gdkpixbuf/pixbuf-loader.d.ts

@@ -0,0 +1,14 @@
+export declare class PixbufLoader {
+    ptr: unknown;
+    constructor();
+    static loaderNewWithMimeType(mimeType: string): PixbufLoader;
+    static loaderNewWithType(imageType: string): PixbufLoader;
+    close(): boolean;
+    getAnimation(): unknown;
+    getFormat(): unknown;
+    getPixbuf(): unknown;
+    setSize(width: number, height: number): void;
+    write(buf: number[], count: unknown): boolean;
+    writeBytes(buffer: unknown): boolean;
+    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+}

package/dist/generated/gdkpixbuf/pixbuf-loader.js

@@ -0,0 +1,181 @@
+import { call } from "@gtkx/native";
+export class PixbufLoader {
+    ptr;
+    constructor() {
+        this.ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_new", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+    }
+    static loaderNewWithMimeType(mimeType) {
+        const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_new_with_mime_type", [
+            {
+                type: { type: "string" },
+                value: mimeType,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(PixbufLoader.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static loaderNewWithType(imageType) {
+        const ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_new_with_type", [
+            {
+                type: { type: "string" },
+                value: imageType,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(PixbufLoader.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    close() {
+        const error = { value: null };
+        const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_close", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: error,
+            },
+        ], { type: "boolean" });
+        if (error.value !== null) {
+            const jsError = new Error("GLib Error occurred");
+            jsError.gError = error.value;
+            throw jsError;
+        }
+        return result;
+    }
+    getAnimation() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_get_animation", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getFormat() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_get_format", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getPixbuf() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_get_pixbuf", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    setSize(width, height) {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_set_size", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: width,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: height,
+            },
+        ], { type: "undefined" });
+    }
+    write(buf, count) {
+        const error = { value: null };
+        const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_write", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 8, unsigned: true },
+                },
+                value: buf,
+            },
+            {
+                type: { type: "gobject" },
+                value: count,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: error,
+            },
+        ], { type: "boolean" });
+        if (error.value !== null) {
+            const jsError = new Error("GLib Error occurred");
+            jsError.gError = error.value;
+            throw jsError;
+        }
+        return result;
+    }
+    writeBytes(buffer) {
+        const error = { value: null };
+        const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_loader_write_bytes", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: buffer,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: error,
+            },
+        ], { type: "boolean" });
+        if (error.value !== null) {
+            const jsError = new Error("GLib Error occurred");
+            jsError.gError = error.value;
+            throw jsError;
+        }
+        return result;
+    }
+    connect(signal, handler, after = false) {
+        const signalMeta = {
+            "area-prepared": [],
+            "area-updated": [
+                { type: { type: "int", size: 32, unsigned: false } },
+                { type: { type: "int", size: 32, unsigned: false } },
+                { type: { type: "int", size: 32, unsigned: false } },
+                { type: { type: "int", size: 32, unsigned: false } },
+            ],
+            closed: [],
+            "size-prepared": [
+                { type: { type: "int", size: 32, unsigned: false } },
+                { type: { type: "int", size: 32, unsigned: false } },
+            ],
+        };
+        const meta = signalMeta[signal];
+        const argTypes = meta?.map((m) => m.type);
+        const wrappedHandler = (...args) => {
+            if (!meta)
+                return handler(...args);
+            const wrapped = meta.map((m, i) => {
+                if (m.cls && args[i] != null) {
+                    const inst = Object.create(m.cls.prototype);
+                    inst.ptr = args[i];
+                    return inst;
+                }
+                return args[i];
+            });
+            return handler(...wrapped);
+        };
+        return call("libgdk_pixbuf-2.0.so.0", "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/gdkpixbuf/pixbuf-non-anim.d.ts

@@ -0,0 +1,4 @@
+import { PixbufAnimation } from "./pixbuf-animation.js";
+export declare class PixbufNonAnim extends PixbufAnimation {
+    constructor(pixbuf?: unknown);
+}

package/dist/generated/gdkpixbuf/pixbuf-non-anim.js

@@ -0,0 +1,13 @@
+import { call } from "@gtkx/native";
+import { PixbufAnimation } from "./pixbuf-animation.js";
+export class PixbufNonAnim extends PixbufAnimation {
+    constructor(pixbuf) {
+        super(true);
+        this.ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_non_anim_new", [
+            {
+                type: { type: "gobject" },
+                value: pixbuf,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+}

package/dist/generated/gdkpixbuf/pixbuf-simple-anim-iter.d.ts

@@ -0,0 +1,5 @@
+import { PixbufAnimationIter } from "./pixbuf-animation-iter.js";
+export declare class PixbufSimpleAnimIter extends PixbufAnimationIter {
+    ptr: unknown;
+    constructor();
+}

package/dist/generated/gdkpixbuf/pixbuf-simple-anim-iter.js

@@ -0,0 +1,7 @@
+import { PixbufAnimationIter } from "./pixbuf-animation-iter.js";
+export class PixbufSimpleAnimIter extends PixbufAnimationIter {
+    ptr = undefined;
+    constructor() {
+        super(true);
+    }
+}

package/dist/generated/gdkpixbuf/pixbuf-simple-anim.d.ts

@@ -0,0 +1,9 @@
+import { PixbufAnimation } from "./pixbuf-animation.js";
+export declare class PixbufSimpleAnim extends PixbufAnimation {
+    constructor(width?: number, height?: number, rate?: number);
+    addFrame(pixbuf: unknown): void;
+    getLoop(): boolean;
+    setLoop(loop: boolean): void;
+    get loop(): boolean;
+    set loop(_value: boolean);
+}

package/dist/generated/gdkpixbuf/pixbuf-simple-anim.js

@@ -0,0 +1,59 @@
+import { call } from "@gtkx/native";
+import { PixbufAnimation } from "./pixbuf-animation.js";
+export class PixbufSimpleAnim extends PixbufAnimation {
+    constructor(width, height, rate) {
+        super(true);
+        this.ptr = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_simple_anim_new", [
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: width,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: height,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: rate,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    addFrame(pixbuf) {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_simple_anim_add_frame", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: pixbuf,
+            },
+        ], { type: "undefined" });
+    }
+    getLoop() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_simple_anim_get_loop", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    setLoop(loop) {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_simple_anim_set_loop", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boolean" },
+                value: loop,
+            },
+        ], { type: "undefined" });
+    }
+    get loop() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set loop(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+}