@gtkx/ffi 0.1.0

package/dist/generated/gobject/signal-group.js

@@ -0,0 +1,217 @@
+import { call } from "@gtkx/native";
+import { GObject } from "./object.js";
+export class SignalGroup extends GObject {
+    constructor(targetType) {
+        super(true);
+        this.ptr = call("libgobject-2.0.so.0", "g_signal_group_new", [
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: targetType,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    block() {
+        call("libgobject-2.0.so.0", "g_signal_group_block", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    connectSignal(detailedSignal, cHandler, data) {
+        call("libgobject-2.0.so.0", "g_signal_group_connect", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: detailedSignal,
+            },
+            {
+                type: { type: "gobject" },
+                value: cHandler,
+            },
+            {
+                type: { type: "gobject" },
+                value: data,
+            },
+        ], { type: "undefined" });
+    }
+    connectAfter(detailedSignal, cHandler, data) {
+        call("libgobject-2.0.so.0", "g_signal_group_connect_after", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: detailedSignal,
+            },
+            {
+                type: { type: "gobject" },
+                value: cHandler,
+            },
+            {
+                type: { type: "gobject" },
+                value: data,
+            },
+        ], { type: "undefined" });
+    }
+    connectClosure(detailedSignal, closure, after) {
+        call("libgobject-2.0.so.0", "g_signal_group_connect_closure", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: detailedSignal,
+            },
+            {
+                type: { type: "gobject" },
+                value: closure,
+            },
+            {
+                type: { type: "boolean" },
+                value: after,
+            },
+        ], { type: "undefined" });
+    }
+    connectData(detailedSignal, cHandler, notify, flags, data) {
+        call("libgobject-2.0.so.0", "g_signal_group_connect_data", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: detailedSignal,
+            },
+            {
+                type: { type: "gobject" },
+                value: cHandler,
+            },
+            {
+                type: { type: "gobject" },
+                value: data,
+            },
+            {
+                type: { type: "gobject" },
+                value: notify,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: flags,
+            },
+        ], { type: "undefined" });
+    }
+    connectObject(detailedSignal, cHandler, object, flags) {
+        call("libgobject-2.0.so.0", "g_signal_group_connect_object", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: detailedSignal,
+            },
+            {
+                type: { type: "gobject" },
+                value: cHandler,
+            },
+            {
+                type: { type: "gobject" },
+                value: object,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: flags,
+            },
+        ], { type: "undefined" });
+    }
+    connectSwapped(detailedSignal, cHandler, data) {
+        call("libgobject-2.0.so.0", "g_signal_group_connect_swapped", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: detailedSignal,
+            },
+            {
+                type: { type: "gobject" },
+                value: cHandler,
+            },
+            {
+                type: { type: "gobject" },
+                value: data,
+            },
+        ], { type: "undefined" });
+    }
+    dupTarget() {
+        return call("libgobject-2.0.so.0", "g_signal_group_dup_target", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    setTarget(target) {
+        call("libgobject-2.0.so.0", "g_signal_group_set_target", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: target,
+            },
+        ], { type: "undefined" });
+    }
+    unblock() {
+        call("libgobject-2.0.so.0", "g_signal_group_unblock", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    get target() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set target(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get targetType() {
+        throw new Error("Property getters not yet implemented");
+    }
+    on(signal, handler, after = false) {
+        const signalMeta = {
+            bind: [{ type: { type: "gobject", borrowed: false }, cls: GObject }],
+            unbind: [],
+        };
+        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("libgobject-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/gobject/type-module.d.ts

@@ -0,0 +1,13 @@
+import { TypeFlags } from "./enums.js";
+import { GObject } from "./object.js";
+export declare class TypeModule extends GObject {
+    ptr: unknown;
+    constructor();
+    addInterface(instanceType: number, interfaceType: number, interfaceInfo: unknown): void;
+    registerEnum(name: string, constStaticValues: unknown[]): number;
+    registerFlags(name: string, constStaticValues: unknown[]): number;
+    registerType(parentType: number, typeName: string, typeInfo: unknown, flags: TypeFlags): number;
+    setName(name: string): void;
+    unuse(): void;
+    use(): boolean;
+}

package/dist/generated/gobject/type-module.js

@@ -0,0 +1,112 @@
+import { call } from "@gtkx/native";
+import { GObject } from "./object.js";
+export class TypeModule extends GObject {
+    ptr = undefined;
+    constructor() {
+        super(true);
+    }
+    addInterface(instanceType, interfaceType, interfaceInfo) {
+        call("libgobject-2.0.so.0", "g_type_module_add_interface", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: instanceType,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: interfaceType,
+            },
+            {
+                type: { type: "gobject" },
+                value: interfaceInfo,
+            },
+        ], { type: "undefined" });
+    }
+    registerEnum(name, constStaticValues) {
+        return call("libgobject-2.0.so.0", "g_type_module_register_enum", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: name,
+            },
+            {
+                type: { type: "array", itemType: { type: "gobject" } },
+                value: constStaticValues,
+            },
+        ], { type: "int", size: 64, unsigned: true });
+    }
+    registerFlags(name, constStaticValues) {
+        return call("libgobject-2.0.so.0", "g_type_module_register_flags", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: name,
+            },
+            {
+                type: { type: "array", itemType: { type: "gobject" } },
+                value: constStaticValues,
+            },
+        ], { type: "int", size: 64, unsigned: true });
+    }
+    registerType(parentType, typeName, typeInfo, flags) {
+        return call("libgobject-2.0.so.0", "g_type_module_register_type", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: parentType,
+            },
+            {
+                type: { type: "string" },
+                value: typeName,
+            },
+            {
+                type: { type: "gobject" },
+                value: typeInfo,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: flags,
+            },
+        ], { type: "int", size: 64, unsigned: true });
+    }
+    setName(name) {
+        call("libgobject-2.0.so.0", "g_type_module_set_name", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: name,
+            },
+        ], { type: "undefined" });
+    }
+    unuse() {
+        call("libgobject-2.0.so.0", "g_type_module_unuse", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    use() {
+        return call("libgobject-2.0.so.0", "g_type_module_use", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+}

package/dist/generated/gobject/type-plugin.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class TypePlugin {
+    protected abstract ptr: unknown;
+    completeInterfaceInfo(instanceType: number, interfaceType: number, info: unknown): void;
+    completeTypeInfo(gType: number, info: unknown, valueTable: unknown): void;
+    unuse(): void;
+    use(): void;
+}

package/dist/generated/gobject/type-plugin.js

@@ -0,0 +1,59 @@
+import { call } from "@gtkx/native";
+export class TypePlugin {
+    completeInterfaceInfo(instanceType, interfaceType, info) {
+        call("libgobject-2.0.so.0", "g_type_plugin_complete_interface_info", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: instanceType,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: interfaceType,
+            },
+            {
+                type: { type: "gobject" },
+                value: info,
+            },
+        ], { type: "undefined" });
+    }
+    completeTypeInfo(gType, info, valueTable) {
+        call("libgobject-2.0.so.0", "g_type_plugin_complete_type_info", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 64, unsigned: true },
+                value: gType,
+            },
+            {
+                type: { type: "gobject" },
+                value: info,
+            },
+            {
+                type: { type: "gobject" },
+                value: valueTable,
+            },
+        ], { type: "undefined" });
+    }
+    unuse() {
+        call("libgobject-2.0.so.0", "g_type_plugin_unuse", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    use() {
+        call("libgobject-2.0.so.0", "g_type_plugin_use", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+}

package/dist/generated/graphene/enums.d.ts

@@ -0,0 +1,38 @@
+export declare enum EulerOrder {
+    DEFAULT = -1,
+    XYZ = 0,
+    YZX = 1,
+    ZXY = 2,
+    XZY = 3,
+    YXZ = 4,
+    ZYX = 5,
+    SXYZ = 6,
+    SXYX = 7,
+    SXZY = 8,
+    SXZX = 9,
+    SYZX = 10,
+    SYZY = 11,
+    SYXZ = 12,
+    SYXY = 13,
+    SZXY = 14,
+    SZXZ = 15,
+    SZYX = 16,
+    SZYZ = 17,
+    RZYX = 18,
+    RXYX = 19,
+    RYZX = 20,
+    RXZX = 21,
+    RXZY = 22,
+    RYZY = 23,
+    RZXY = 24,
+    RYXY = 25,
+    RYXZ = 26,
+    RZXZ = 27,
+    RXYZ = 28,
+    RZYZ = 29
+}
+export declare enum RayIntersectionKind {
+    NONE = 0,
+    ENTER = 1,
+    LEAVE = 2
+}

package/dist/generated/graphene/enums.js

@@ -0,0 +1,40 @@
+export var EulerOrder;
+(function (EulerOrder) {
+    EulerOrder[EulerOrder["DEFAULT"] = -1] = "DEFAULT";
+    EulerOrder[EulerOrder["XYZ"] = 0] = "XYZ";
+    EulerOrder[EulerOrder["YZX"] = 1] = "YZX";
+    EulerOrder[EulerOrder["ZXY"] = 2] = "ZXY";
+    EulerOrder[EulerOrder["XZY"] = 3] = "XZY";
+    EulerOrder[EulerOrder["YXZ"] = 4] = "YXZ";
+    EulerOrder[EulerOrder["ZYX"] = 5] = "ZYX";
+    EulerOrder[EulerOrder["SXYZ"] = 6] = "SXYZ";
+    EulerOrder[EulerOrder["SXYX"] = 7] = "SXYX";
+    EulerOrder[EulerOrder["SXZY"] = 8] = "SXZY";
+    EulerOrder[EulerOrder["SXZX"] = 9] = "SXZX";
+    EulerOrder[EulerOrder["SYZX"] = 10] = "SYZX";
+    EulerOrder[EulerOrder["SYZY"] = 11] = "SYZY";
+    EulerOrder[EulerOrder["SYXZ"] = 12] = "SYXZ";
+    EulerOrder[EulerOrder["SYXY"] = 13] = "SYXY";
+    EulerOrder[EulerOrder["SZXY"] = 14] = "SZXY";
+    EulerOrder[EulerOrder["SZXZ"] = 15] = "SZXZ";
+    EulerOrder[EulerOrder["SZYX"] = 16] = "SZYX";
+    EulerOrder[EulerOrder["SZYZ"] = 17] = "SZYZ";
+    EulerOrder[EulerOrder["RZYX"] = 18] = "RZYX";
+    EulerOrder[EulerOrder["RXYX"] = 19] = "RXYX";
+    EulerOrder[EulerOrder["RYZX"] = 20] = "RYZX";
+    EulerOrder[EulerOrder["RXZX"] = 21] = "RXZX";
+    EulerOrder[EulerOrder["RXZY"] = 22] = "RXZY";
+    EulerOrder[EulerOrder["RYZY"] = 23] = "RYZY";
+    EulerOrder[EulerOrder["RZXY"] = 24] = "RZXY";
+    EulerOrder[EulerOrder["RYXY"] = 25] = "RYXY";
+    EulerOrder[EulerOrder["RYXZ"] = 26] = "RYXZ";
+    EulerOrder[EulerOrder["RZXZ"] = 27] = "RZXZ";
+    EulerOrder[EulerOrder["RXYZ"] = 28] = "RXYZ";
+    EulerOrder[EulerOrder["RZYZ"] = 29] = "RZYZ";
+})(EulerOrder || (EulerOrder = {}));
+export var RayIntersectionKind;
+(function (RayIntersectionKind) {
+    RayIntersectionKind[RayIntersectionKind["NONE"] = 0] = "NONE";
+    RayIntersectionKind[RayIntersectionKind["ENTER"] = 1] = "ENTER";
+    RayIntersectionKind[RayIntersectionKind["LEAVE"] = 2] = "LEAVE";
+})(RayIntersectionKind || (RayIntersectionKind = {}));

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

@@ -0,0 +1,26 @@
+export declare const boxEmpty: () => unknown;
+export declare const boxInfinite: () => unknown;
+export declare const boxMinusOne: () => unknown;
+export declare const boxOne: () => unknown;
+export declare const boxOneMinusOne: () => unknown;
+export declare const boxZero: () => unknown;
+export declare const point3dZero: () => unknown;
+export declare const pointZero: () => unknown;
+export declare const rectAlloc: () => unknown;
+export declare const rectZero: () => unknown;
+export declare const sizeZero: () => unknown;
+export declare const vec2One: () => unknown;
+export declare const vec2XAxis: () => unknown;
+export declare const vec2YAxis: () => unknown;
+export declare const vec2Zero: () => unknown;
+export declare const vec3One: () => unknown;
+export declare const vec3XAxis: () => unknown;
+export declare const vec3YAxis: () => unknown;
+export declare const vec3ZAxis: () => unknown;
+export declare const vec3Zero: () => unknown;
+export declare const vec4One: () => unknown;
+export declare const vec4WAxis: () => unknown;
+export declare const vec4XAxis: () => unknown;
+export declare const vec4YAxis: () => unknown;
+export declare const vec4ZAxis: () => unknown;
+export declare const vec4Zero: () => unknown;

package/dist/generated/graphene/functions.js

@@ -0,0 +1,157 @@
+import { call } from "@gtkx/native";
+export const boxEmpty = () => {
+    return call("libgraphene-1.0.so.0", "graphene_box_empty", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const boxInfinite = () => {
+    return call("libgraphene-1.0.so.0", "graphene_box_infinite", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const boxMinusOne = () => {
+    return call("libgraphene-1.0.so.0", "graphene_box_minus_one", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const boxOne = () => {
+    return call("libgraphene-1.0.so.0", "graphene_box_one", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const boxOneMinusOne = () => {
+    return call("libgraphene-1.0.so.0", "graphene_box_one_minus_one", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const boxZero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_box_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const point3dZero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_point3d_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const pointZero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_point_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const rectAlloc = () => {
+    return call("libgraphene-1.0.so.0", "graphene_rect_alloc", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const rectZero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_rect_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const sizeZero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_size_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec2One = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec2_one", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec2XAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec2_x_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec2YAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec2_y_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec2Zero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec2_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec3One = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec3_one", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec3XAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec3_x_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec3YAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec3_y_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec3ZAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec3_z_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec3Zero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec3_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec4One = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec4_one", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec4WAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec4_w_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec4XAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec4_x_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec4YAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec4_y_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec4ZAxis = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec4_z_axis", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const vec4Zero = () => {
+    return call("libgraphene-1.0.so.0", "graphene_vec4_zero", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};

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

@@ -0,0 +1,2 @@
+export * from "./functions.js";
+export * from "./enums.js";

package/dist/generated/graphene/index.js

@@ -0,0 +1,2 @@
+export * from "./functions.js";
+export * from "./enums.js";

package/dist/generated/gsk/blend-node.d.ts

@@ -0,0 +1,8 @@
+import { BlendMode } from "./enums.js";
+import { RenderNode } from "./render-node.js";
+export declare class BlendNode extends RenderNode {
+    constructor(bottom?: unknown, top?: unknown, blendMode?: BlendMode);
+    getBlendMode(): BlendMode;
+    getBottomChild(): unknown;
+    getTopChild(): unknown;
+}