@gtkx/ffi 0.1.4 → 0.1.6

package/dist/generated/gsk/path-measure.js

@@ -0,0 +1,105 @@
+import { call } from "@gtkx/native";
+export class PathMeasure {
+    ptr;
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        this.ptr = this.createPtr(_args);
+    }
+    static measureNewWithTolerance(path, tolerance) {
+        const ptr = call("libgtk-4.so.1", "gsk_path_measure_new_with_tolerance", [
+            {
+                type: { type: "boxed", innerType: "GskPath", lib: "libgtk-4.so.1" },
+                value: path,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: tolerance,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "PathMeasure" });
+        const instance = Object.create(PathMeasure.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    createPtr(_args) {
+        const [path] = _args;
+        return call("libgtk-4.so.1", "gsk_path_measure_new", [
+            {
+                type: { type: "boxed", innerType: "GskPath", lib: "libgtk-4.so.1" },
+                value: path,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "GskPathMeasure" });
+    }
+    getLength() {
+        return call("libgtk-4.so.1", "gsk_path_measure_get_length", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getPath() {
+        return call("libgtk-4.so.1", "gsk_path_measure_get_path", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GskPath",
+            lib: "libgtk-4.so.1",
+        });
+    }
+    getPoint(distance, result) {
+        return call("libgtk-4.so.1", "gsk_path_measure_get_point", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: distance,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GskPathPoint",
+                        lib: "libgtk-4.so.1",
+                    },
+                },
+                value: result,
+            },
+        ], { type: "boolean" });
+    }
+    getTolerance() {
+        return call("libgtk-4.so.1", "gsk_path_measure_get_tolerance", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "float", size: 32 });
+    }
+    ref() {
+        return call("libgtk-4.so.1", "gsk_path_measure_ref", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GskPathMeasure",
+            lib: "libgtk-4.so.1",
+        });
+    }
+    unref() {
+        call("libgtk-4.so.1", "gsk_path_measure_unref", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+}

package/dist/generated/gsk/path-point.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from "@gtkx/native";
+import { PathDirection } from "./enums.js";
+import type { Path } from "./path.js";
+import type { PathMeasure } from "./path-measure.js";
+export declare class PathPoint {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_init: Record<string, unknown>): unknown;
+    compare(point2: PathPoint): number;
+    copy(): PathPoint;
+    equal(point2: PathPoint): boolean;
+    free(): void;
+    getCurvature(path: Path, direction: PathDirection, center?: Ref<unknown>): number;
+    getDistance(measure: PathMeasure): number;
+    getPosition(path: Path, position: Ref<unknown>): void;
+    getRotation(path: Path, direction: PathDirection): number;
+    getTangent(path: Path, direction: PathDirection, tangent: Ref<unknown>): void;
+}

package/dist/generated/gsk/path-point.js

@@ -0,0 +1,151 @@
+import { call } from "@gtkx/native";
+export class PathPoint {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr({});
+    }
+    createPtr(_init) {
+        return null;
+    }
+    compare(point2) {
+        return call("libgtk-4.so.1", "gsk_path_point_compare", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GskPathPoint",
+                    lib: "libgtk-4.so.1",
+                },
+                value: point2,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    copy() {
+        return call("libgtk-4.so.1", "gsk_path_point_copy", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GskPathPoint",
+            lib: "libgtk-4.so.1",
+        });
+    }
+    equal(point2) {
+        return call("libgtk-4.so.1", "gsk_path_point_equal", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GskPathPoint",
+                    lib: "libgtk-4.so.1",
+                },
+                value: point2,
+            },
+        ], { type: "boolean" });
+    }
+    free() {
+        call("libgtk-4.so.1", "gsk_path_point_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getCurvature(path, direction, center) {
+        return call("libgtk-4.so.1", "gsk_path_point_get_curvature", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boxed", innerType: "GskPath", lib: "libgtk-4.so.1" },
+                value: path,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: direction,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: center,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getDistance(measure) {
+        return call("libgtk-4.so.1", "gsk_path_point_get_distance", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GskPathMeasure",
+                    lib: "libgtk-4.so.1",
+                },
+                value: measure,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getPosition(path, position) {
+        call("libgtk-4.so.1", "gsk_path_point_get_position", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boxed", innerType: "GskPath", lib: "libgtk-4.so.1" },
+                value: path,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: position,
+            },
+        ], { type: "undefined" });
+    }
+    getRotation(path, direction) {
+        return call("libgtk-4.so.1", "gsk_path_point_get_rotation", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boxed", innerType: "GskPath", lib: "libgtk-4.so.1" },
+                value: path,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: direction,
+            },
+        ], { type: "float", size: 32 });
+    }
+    getTangent(path, direction, tangent) {
+        call("libgtk-4.so.1", "gsk_path_point_get_tangent", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boxed", innerType: "GskPath", lib: "libgtk-4.so.1" },
+                value: path,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: direction,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: tangent,
+            },
+        ], { type: "undefined" });
+    }
+}

package/dist/generated/gsk/path.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from "@gtkx/native";
+import { FillRule, PathForeachFlags } from "./enums.js";
+import type { PathPoint } from "./path-point.js";
+import type { Stroke } from "./stroke.js";
+export declare class Path {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_init: Record<string, unknown>): unknown;
+    static parse(string: string): Path;
+    foreach(flags: PathForeachFlags, func: (...args: unknown[]) => unknown, userData?: unknown): boolean;
+    foreachIntersection(func: (...args: unknown[]) => unknown, path2?: Path, userData?: unknown): boolean;
+    getBounds(bounds: Ref<unknown>): boolean;
+    getClosestPoint(point: unknown, threshold: number, result: Ref<PathPoint>, distance?: Ref<number>): boolean;
+    getEndPoint(result: Ref<PathPoint>): boolean;
+    getStartPoint(result: Ref<PathPoint>): boolean;
+    getStrokeBounds(stroke: Stroke, bounds: Ref<unknown>): boolean;
+    inFill(point: unknown, fillRule: FillRule): boolean;
+    isClosed(): boolean;
+    isEmpty(): boolean;
+    print(string: unknown): void;
+    ref(): Path;
+    toCairo(cr: unknown): void;
+    toString(): string;
+    unref(): void;
+}

package/dist/generated/gsk/path.js

@@ -0,0 +1,248 @@
+import { call } from "@gtkx/native";
+export class Path {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr({});
+    }
+    createPtr(_init) {
+        return null;
+    }
+    static parse(string) {
+        const ptr = call("libgtk-4.so.1", "gsk_path_parse", [
+            {
+                type: { type: "string" },
+                value: string,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GskPath",
+            lib: "libgtk-4.so.1",
+        });
+        const instance = Object.create(Path.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    foreach(flags, func, userData) {
+        return call("libgtk-4.so.1", "gsk_path_foreach", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: flags,
+            },
+            {
+                type: { type: "callback" },
+                value: func,
+            },
+            {
+                type: { type: "gobject" },
+                value: userData,
+            },
+        ], { type: "boolean" });
+    }
+    foreachIntersection(func, path2, userData) {
+        return call("libgtk-4.so.1", "gsk_path_foreach_intersection", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boxed", innerType: "GskPath", lib: "libgtk-4.so.1" },
+                value: path2,
+            },
+            {
+                type: { type: "callback" },
+                value: func,
+            },
+            {
+                type: { type: "gobject" },
+                value: userData,
+            },
+        ], { type: "boolean" });
+    }
+    getBounds(bounds) {
+        return call("libgtk-4.so.1", "gsk_path_get_bounds", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: bounds,
+            },
+        ], { type: "boolean" });
+    }
+    getClosestPoint(point, threshold, result, distance) {
+        return call("libgtk-4.so.1", "gsk_path_get_closest_point", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: point,
+            },
+            {
+                type: { type: "float", size: 32 },
+                value: threshold,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GskPathPoint",
+                        lib: "libgtk-4.so.1",
+                    },
+                },
+                value: result,
+            },
+            {
+                type: { type: "ref", innerType: { type: "float", size: 32 } },
+                value: distance,
+            },
+        ], { type: "boolean" });
+    }
+    getEndPoint(result) {
+        return call("libgtk-4.so.1", "gsk_path_get_end_point", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GskPathPoint",
+                        lib: "libgtk-4.so.1",
+                    },
+                },
+                value: result,
+            },
+        ], { type: "boolean" });
+    }
+    getStartPoint(result) {
+        return call("libgtk-4.so.1", "gsk_path_get_start_point", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GskPathPoint",
+                        lib: "libgtk-4.so.1",
+                    },
+                },
+                value: result,
+            },
+        ], { type: "boolean" });
+    }
+    getStrokeBounds(stroke, bounds) {
+        return call("libgtk-4.so.1", "gsk_path_get_stroke_bounds", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boxed", innerType: "GskStroke", lib: "libgtk-4.so.1" },
+                value: stroke,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: bounds,
+            },
+        ], { type: "boolean" });
+    }
+    inFill(point, fillRule) {
+        return call("libgtk-4.so.1", "gsk_path_in_fill", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: point,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: fillRule,
+            },
+        ], { type: "boolean" });
+    }
+    isClosed() {
+        return call("libgtk-4.so.1", "gsk_path_is_closed", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isEmpty() {
+        return call("libgtk-4.so.1", "gsk_path_is_empty", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    print(string) {
+        call("libgtk-4.so.1", "gsk_path_print", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: string,
+            },
+        ], { type: "undefined" });
+    }
+    ref() {
+        return call("libgtk-4.so.1", "gsk_path_ref", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GskPath",
+            lib: "libgtk-4.so.1",
+        });
+    }
+    toCairo(cr) {
+        call("libgtk-4.so.1", "gsk_path_to_cairo", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: cr,
+            },
+        ], { type: "undefined" });
+    }
+    toString() {
+        return call("libgtk-4.so.1", "gsk_path_to_string", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "string" });
+    }
+    unref() {
+        call("libgtk-4.so.1", "gsk_path_unref", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+}

package/dist/generated/gsk/render-node.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { NativeError } from "@gtkx/ffi";
 export class RenderNode {
     ptr;
     constructor(_args = []) {
@@ -106,14 +107,19 @@ export class RenderNode {
                 value: filename,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
                 value: error,
             },
         ], { type: "boolean" });
         if (error.value !== null) {
-            const jsError = new Error("GLib Error occurred");
-            jsError.gError = error.value;
-            throw jsError;
+            throw new NativeError(error.value);
         }
         return result;
     }

package/dist/generated/gsk/renderer.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { NativeError } from "@gtkx/ffi";
 export class Renderer {
     ptr;
     constructor(...args) {
@@ -42,14 +43,19 @@ export class Renderer {
                 value: surface,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
                 value: error,
             },
         ], { type: "boolean" });
         if (error.value !== null) {
-            const jsError = new Error("GLib Error occurred");
-            jsError.gError = error.value;
-            throw jsError;
+            throw new NativeError(error.value);
         }
         return result;
     }
@@ -65,14 +71,19 @@ export class Renderer {
                 value: display,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GError",
+                        lib: "libglib-2.0.so.0",
+                    },
+                },
                 value: error,
             },
         ], { type: "boolean" });
         if (error.value !== null) {
-            const jsError = new Error("GLib Error occurred");
-            jsError.gError = error.value;
-            throw jsError;
+            throw new NativeError(error.value);
         }
         return result;
     }

package/dist/generated/gsk/shader-args-builder.d.ts

@@ -0,0 +1,17 @@
+export declare class ShaderArgsBuilder {
+    ptr: unknown;
+    constructor(shader: unknown, initialValues?: unknown);
+    constructor(_args: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
+    freeToArgs(): unknown;
+    ref(): ShaderArgsBuilder;
+    setBool(idx: number, value: boolean): void;
+    setFloat(idx: number, value: number): void;
+    setInt(idx: number, value: number): void;
+    setUint(idx: number, value: number): void;
+    setVec2(idx: number, value: unknown): void;
+    setVec3(idx: number, value: unknown): void;
+    setVec4(idx: number, value: unknown): void;
+    toArgs(): unknown;
+    unref(): void;
+}