@gtkx/ffi 0.1.0

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

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

package/dist/generated/glib/index.js

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

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

@@ -0,0 +1,9 @@
+export declare enum ModuleError {
+    FAILED = 0,
+    CHECK_FAILED = 1
+}
+export declare enum ModuleFlags {
+    LAZY = 1,
+    LOCAL = 2,
+    MASK = 3
+}

package/dist/generated/gmodule/enums.js

@@ -0,0 +1,11 @@
+export var ModuleError;
+(function (ModuleError) {
+    ModuleError[ModuleError["FAILED"] = 0] = "FAILED";
+    ModuleError[ModuleError["CHECK_FAILED"] = 1] = "CHECK_FAILED";
+})(ModuleError || (ModuleError = {}));
+export var ModuleFlags;
+(function (ModuleFlags) {
+    ModuleFlags[ModuleFlags["LAZY"] = 1] = "LAZY";
+    ModuleFlags[ModuleFlags["LOCAL"] = 2] = "LOCAL";
+    ModuleFlags[ModuleFlags["MASK"] = 3] = "MASK";
+})(ModuleFlags || (ModuleFlags = {}));

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

@@ -0,0 +1,4 @@
+export declare const moduleBuildPath: (moduleName: string, directory?: string) => string;
+export declare const moduleError: () => string;
+export declare const moduleErrorQuark: () => unknown;
+export declare const moduleSupported: () => boolean;

package/dist/generated/gmodule/functions.js

@@ -0,0 +1,29 @@
+import { call } from "@gtkx/native";
+export const moduleBuildPath = (moduleName, directory) => {
+    return call("libgmodule-2.0.so.0", "g_module_build_path", [
+        {
+            type: { type: "string" },
+            value: directory,
+        },
+        {
+            type: { type: "string" },
+            value: moduleName,
+        },
+    ], { type: "string" });
+};
+export const moduleError = () => {
+    return call("libgmodule-2.0.so.0", "g_module_error", [], {
+        type: "string",
+    });
+};
+export const moduleErrorQuark = () => {
+    return call("libgmodule-2.0.so.0", "g_module_error_quark", [], {
+        type: "gobject",
+        borrowed: true,
+    });
+};
+export const moduleSupported = () => {
+    return call("libgmodule-2.0.so.0", "g_module_supported", [], {
+        type: "boolean",
+    });
+};

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

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

package/dist/generated/gmodule/index.js

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

package/dist/generated/gobject/binding-group.d.ts

@@ -0,0 +1,12 @@
+import { BindingFlags } from "./enums.js";
+import { GObject } from "./object.js";
+export declare class BindingGroup extends GObject {
+    constructor();
+    bind(sourceProperty: string, target: unknown, targetProperty: string, flags: BindingFlags): void;
+    bindFull(sourceProperty: string, target: unknown, targetProperty: string, flags: BindingFlags, userDataDestroy: unknown, transformTo?: (...args: unknown[]) => unknown, transformFrom?: (...args: unknown[]) => unknown, userData?: unknown): void;
+    bindWithClosures(sourceProperty: string, target: unknown, targetProperty: string, flags: BindingFlags, transformTo?: unknown, transformFrom?: unknown): void;
+    dupSource(): unknown;
+    setSource(source?: unknown): void;
+    get source(): unknown;
+    set source(_value: unknown);
+}

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

@@ -0,0 +1,133 @@
+import { call } from "@gtkx/native";
+import { GObject } from "./object.js";
+export class BindingGroup extends GObject {
+    constructor() {
+        super(true);
+        this.ptr = call("libgobject-2.0.so.0", "g_binding_group_new", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+    }
+    bind(sourceProperty, target, targetProperty, flags) {
+        call("libgobject-2.0.so.0", "g_binding_group_bind", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: sourceProperty,
+            },
+            {
+                type: { type: "gobject" },
+                value: target,
+            },
+            {
+                type: { type: "string" },
+                value: targetProperty,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: flags,
+            },
+        ], { type: "undefined" });
+    }
+    bindFull(sourceProperty, target, targetProperty, flags, userDataDestroy, transformTo, transformFrom, userData) {
+        call("libgobject-2.0.so.0", "g_binding_group_bind_full", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: sourceProperty,
+            },
+            {
+                type: { type: "gobject" },
+                value: target,
+            },
+            {
+                type: { type: "string" },
+                value: targetProperty,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: flags,
+            },
+            {
+                type: { type: "callback" },
+                value: transformTo,
+            },
+            {
+                type: { type: "callback" },
+                value: transformFrom,
+            },
+            {
+                type: { type: "gobject" },
+                value: userData,
+            },
+            {
+                type: { type: "gobject" },
+                value: userDataDestroy,
+            },
+        ], { type: "undefined" });
+    }
+    bindWithClosures(sourceProperty, target, targetProperty, flags, transformTo, transformFrom) {
+        call("libgobject-2.0.so.0", "g_binding_group_bind_with_closures", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: sourceProperty,
+            },
+            {
+                type: { type: "gobject" },
+                value: target,
+            },
+            {
+                type: { type: "string" },
+                value: targetProperty,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: flags,
+            },
+            {
+                type: { type: "gobject" },
+                value: transformTo,
+            },
+            {
+                type: { type: "gobject" },
+                value: transformFrom,
+            },
+        ], { type: "undefined" });
+    }
+    dupSource() {
+        return call("libgobject-2.0.so.0", "g_binding_group_dup_source", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    setSource(source) {
+        call("libgobject-2.0.so.0", "g_binding_group_set_source", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: source,
+            },
+        ], { type: "undefined" });
+    }
+    get source() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set source(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+}

package/dist/generated/gobject/binding.d.ts

@@ -0,0 +1,19 @@
+import { BindingFlags } from "./enums.js";
+import { GObject } from "./object.js";
+export declare class Binding extends GObject {
+    ptr: unknown;
+    constructor();
+    dupSource(): unknown;
+    dupTarget(): unknown;
+    getFlags(): BindingFlags;
+    getSource(): unknown;
+    getSourceProperty(): string;
+    getTarget(): unknown;
+    getTargetProperty(): string;
+    unbind(): void;
+    get flags(): BindingFlags;
+    get source(): unknown;
+    get sourceProperty(): string;
+    get target(): unknown;
+    get targetProperty(): string;
+}

package/dist/generated/gobject/binding.js

@@ -0,0 +1,87 @@
+import { call } from "@gtkx/native";
+import { GObject } from "./object.js";
+export class Binding extends GObject {
+    ptr = undefined;
+    constructor() {
+        super(true);
+    }
+    dupSource() {
+        return call("libgobject-2.0.so.0", "g_binding_dup_source", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    dupTarget() {
+        return call("libgobject-2.0.so.0", "g_binding_dup_target", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getFlags() {
+        return call("libgobject-2.0.so.0", "g_binding_get_flags", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    getSource() {
+        return call("libgobject-2.0.so.0", "g_binding_get_source", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getSourceProperty() {
+        return call("libgobject-2.0.so.0", "g_binding_get_source_property", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "string" });
+    }
+    getTarget() {
+        return call("libgobject-2.0.so.0", "g_binding_get_target", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getTargetProperty() {
+        return call("libgobject-2.0.so.0", "g_binding_get_target_property", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "string" });
+    }
+    unbind() {
+        call("libgobject-2.0.so.0", "g_binding_unbind", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    get flags() {
+        throw new Error("Property getters not yet implemented");
+    }
+    get source() {
+        throw new Error("Property getters not yet implemented");
+    }
+    get sourceProperty() {
+        throw new Error("Property getters not yet implemented");
+    }
+    get target() {
+        throw new Error("Property getters not yet implemented");
+    }
+    get targetProperty() {
+        throw new Error("Property getters not yet implemented");
+    }
+}

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

@@ -0,0 +1,73 @@
+export declare enum BindingFlags {
+    DEFAULT = 0,
+    BIDIRECTIONAL = 1,
+    SYNC_CREATE = 2,
+    INVERT_BOOLEAN = 4
+}
+export declare enum ConnectFlags {
+    DEFAULT = 0,
+    AFTER = 1,
+    SWAPPED = 2
+}
+export declare enum IOCondition {
+    IN = 1,
+    OUT = 4,
+    PRI = 2,
+    ERR = 8,
+    HUP = 16,
+    NVAL = 32
+}
+export declare enum ParamFlags {
+    READABLE = 1,
+    WRITABLE = 2,
+    READWRITE = 3,
+    CONSTRUCT = 4,
+    CONSTRUCT_ONLY = 8,
+    LAX_VALIDATION = 16,
+    STATIC_NAME = 32,
+    PRIVATE = 32,
+    STATIC_NICK = 64,
+    STATIC_BLURB = 128,
+    EXPLICIT_NOTIFY = 1073741824,
+    DEPRECATED = 2147483648
+}
+export declare enum SignalFlags {
+    RUN_FIRST = 1,
+    RUN_LAST = 2,
+    RUN_CLEANUP = 4,
+    NO_RECURSE = 8,
+    DETAILED = 16,
+    ACTION = 32,
+    NO_HOOKS = 64,
+    MUST_COLLECT = 128,
+    DEPRECATED = 256,
+    ACCUMULATOR_FIRST_RUN = 131072
+}
+export declare enum SignalMatchType {
+    ID = 1,
+    DETAIL = 2,
+    CLOSURE = 4,
+    FUNC = 8,
+    DATA = 16,
+    UNBLOCKED = 32
+}
+export declare enum TypeDebugFlags {
+    NONE = 0,
+    OBJECTS = 1,
+    SIGNALS = 2,
+    INSTANCE_COUNT = 4,
+    MASK = 7
+}
+export declare enum TypeFlags {
+    NONE = 0,
+    ABSTRACT = 16,
+    VALUE_ABSTRACT = 32,
+    FINAL = 64,
+    DEPRECATED = 128
+}
+export declare enum TypeFundamentalFlags {
+    CLASSED = 1,
+    INSTANTIATABLE = 2,
+    DERIVABLE = 4,
+    DEEP_DERIVABLE = 8
+}

package/dist/generated/gobject/enums.js

@@ -0,0 +1,82 @@
+export var BindingFlags;
+(function (BindingFlags) {
+    BindingFlags[BindingFlags["DEFAULT"] = 0] = "DEFAULT";
+    BindingFlags[BindingFlags["BIDIRECTIONAL"] = 1] = "BIDIRECTIONAL";
+    BindingFlags[BindingFlags["SYNC_CREATE"] = 2] = "SYNC_CREATE";
+    BindingFlags[BindingFlags["INVERT_BOOLEAN"] = 4] = "INVERT_BOOLEAN";
+})(BindingFlags || (BindingFlags = {}));
+export var ConnectFlags;
+(function (ConnectFlags) {
+    ConnectFlags[ConnectFlags["DEFAULT"] = 0] = "DEFAULT";
+    ConnectFlags[ConnectFlags["AFTER"] = 1] = "AFTER";
+    ConnectFlags[ConnectFlags["SWAPPED"] = 2] = "SWAPPED";
+})(ConnectFlags || (ConnectFlags = {}));
+export var IOCondition;
+(function (IOCondition) {
+    IOCondition[IOCondition["IN"] = 1] = "IN";
+    IOCondition[IOCondition["OUT"] = 4] = "OUT";
+    IOCondition[IOCondition["PRI"] = 2] = "PRI";
+    IOCondition[IOCondition["ERR"] = 8] = "ERR";
+    IOCondition[IOCondition["HUP"] = 16] = "HUP";
+    IOCondition[IOCondition["NVAL"] = 32] = "NVAL";
+})(IOCondition || (IOCondition = {}));
+export var ParamFlags;
+(function (ParamFlags) {
+    ParamFlags[ParamFlags["READABLE"] = 1] = "READABLE";
+    ParamFlags[ParamFlags["WRITABLE"] = 2] = "WRITABLE";
+    ParamFlags[ParamFlags["READWRITE"] = 3] = "READWRITE";
+    ParamFlags[ParamFlags["CONSTRUCT"] = 4] = "CONSTRUCT";
+    ParamFlags[ParamFlags["CONSTRUCT_ONLY"] = 8] = "CONSTRUCT_ONLY";
+    ParamFlags[ParamFlags["LAX_VALIDATION"] = 16] = "LAX_VALIDATION";
+    ParamFlags[ParamFlags["STATIC_NAME"] = 32] = "STATIC_NAME";
+    ParamFlags[ParamFlags["PRIVATE"] = 32] = "PRIVATE";
+    ParamFlags[ParamFlags["STATIC_NICK"] = 64] = "STATIC_NICK";
+    ParamFlags[ParamFlags["STATIC_BLURB"] = 128] = "STATIC_BLURB";
+    ParamFlags[ParamFlags["EXPLICIT_NOTIFY"] = 1073741824] = "EXPLICIT_NOTIFY";
+    ParamFlags[ParamFlags["DEPRECATED"] = 2147483648] = "DEPRECATED";
+})(ParamFlags || (ParamFlags = {}));
+export var SignalFlags;
+(function (SignalFlags) {
+    SignalFlags[SignalFlags["RUN_FIRST"] = 1] = "RUN_FIRST";
+    SignalFlags[SignalFlags["RUN_LAST"] = 2] = "RUN_LAST";
+    SignalFlags[SignalFlags["RUN_CLEANUP"] = 4] = "RUN_CLEANUP";
+    SignalFlags[SignalFlags["NO_RECURSE"] = 8] = "NO_RECURSE";
+    SignalFlags[SignalFlags["DETAILED"] = 16] = "DETAILED";
+    SignalFlags[SignalFlags["ACTION"] = 32] = "ACTION";
+    SignalFlags[SignalFlags["NO_HOOKS"] = 64] = "NO_HOOKS";
+    SignalFlags[SignalFlags["MUST_COLLECT"] = 128] = "MUST_COLLECT";
+    SignalFlags[SignalFlags["DEPRECATED"] = 256] = "DEPRECATED";
+    SignalFlags[SignalFlags["ACCUMULATOR_FIRST_RUN"] = 131072] = "ACCUMULATOR_FIRST_RUN";
+})(SignalFlags || (SignalFlags = {}));
+export var SignalMatchType;
+(function (SignalMatchType) {
+    SignalMatchType[SignalMatchType["ID"] = 1] = "ID";
+    SignalMatchType[SignalMatchType["DETAIL"] = 2] = "DETAIL";
+    SignalMatchType[SignalMatchType["CLOSURE"] = 4] = "CLOSURE";
+    SignalMatchType[SignalMatchType["FUNC"] = 8] = "FUNC";
+    SignalMatchType[SignalMatchType["DATA"] = 16] = "DATA";
+    SignalMatchType[SignalMatchType["UNBLOCKED"] = 32] = "UNBLOCKED";
+})(SignalMatchType || (SignalMatchType = {}));
+export var TypeDebugFlags;
+(function (TypeDebugFlags) {
+    TypeDebugFlags[TypeDebugFlags["NONE"] = 0] = "NONE";
+    TypeDebugFlags[TypeDebugFlags["OBJECTS"] = 1] = "OBJECTS";
+    TypeDebugFlags[TypeDebugFlags["SIGNALS"] = 2] = "SIGNALS";
+    TypeDebugFlags[TypeDebugFlags["INSTANCE_COUNT"] = 4] = "INSTANCE_COUNT";
+    TypeDebugFlags[TypeDebugFlags["MASK"] = 7] = "MASK";
+})(TypeDebugFlags || (TypeDebugFlags = {}));
+export var TypeFlags;
+(function (TypeFlags) {
+    TypeFlags[TypeFlags["NONE"] = 0] = "NONE";
+    TypeFlags[TypeFlags["ABSTRACT"] = 16] = "ABSTRACT";
+    TypeFlags[TypeFlags["VALUE_ABSTRACT"] = 32] = "VALUE_ABSTRACT";
+    TypeFlags[TypeFlags["FINAL"] = 64] = "FINAL";
+    TypeFlags[TypeFlags["DEPRECATED"] = 128] = "DEPRECATED";
+})(TypeFlags || (TypeFlags = {}));
+export var TypeFundamentalFlags;
+(function (TypeFundamentalFlags) {
+    TypeFundamentalFlags[TypeFundamentalFlags["CLASSED"] = 1] = "CLASSED";
+    TypeFundamentalFlags[TypeFundamentalFlags["INSTANTIATABLE"] = 2] = "INSTANTIATABLE";
+    TypeFundamentalFlags[TypeFundamentalFlags["DERIVABLE"] = 4] = "DERIVABLE";
+    TypeFundamentalFlags[TypeFundamentalFlags["DEEP_DERIVABLE"] = 8] = "DEEP_DERIVABLE";
+})(TypeFundamentalFlags || (TypeFundamentalFlags = {}));