@gtkx/ffi 0.1.4 → 0.1.6

package/dist/generated/gtk/tree-path.js

@@ -0,0 +1,228 @@
+import { call } from "@gtkx/native";
+export class TreePath {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr([]);
+    }
+    static pathNewFirst() {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_path_new_first", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "TreePath",
+        });
+        const instance = Object.create(TreePath.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static pathNewFromIndices(firstIndex) {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_path_new_from_indices", [
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: firstIndex,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "TreePath" });
+        const instance = Object.create(TreePath.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static pathNewFromIndicesv(indices, length) {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_path_new_from_indicesv", [
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 32, unsigned: false },
+                },
+                value: indices,
+            },
+            {
+                type: { type: "gobject" },
+                value: length,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "TreePath" });
+        const instance = Object.create(TreePath.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static pathNewFromString(path) {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_path_new_from_string", [
+            {
+                type: { type: "string" },
+                value: path,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "TreePath" });
+        const instance = Object.create(TreePath.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gtk_tree_path_new", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GtkTreePath",
+        });
+    }
+    appendIndex(index_) {
+        call("libgtk-4.so.1", "gtk_tree_path_append_index", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: index_,
+            },
+        ], { type: "undefined" });
+    }
+    compare(b) {
+        return call("libgtk-4.so.1", "gtk_tree_path_compare", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: b,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    copy() {
+        return call("libgtk-4.so.1", "gtk_tree_path_copy", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GtkTreePath",
+            lib: "libgtk-4.so.1",
+        });
+    }
+    down() {
+        call("libgtk-4.so.1", "gtk_tree_path_down", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    free() {
+        call("libgtk-4.so.1", "gtk_tree_path_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getDepth() {
+        return call("libgtk-4.so.1", "gtk_tree_path_get_depth", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    getIndices() {
+        return call("libgtk-4.so.1", "gtk_tree_path_get_indices", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    getIndicesWithDepth(depth) {
+        return call("libgtk-4.so.1", "gtk_tree_path_get_indices_with_depth", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: depth,
+            },
+        ], { type: "array", itemType: { type: "int", size: 32, unsigned: false } });
+    }
+    isAncestor(descendant) {
+        return call("libgtk-4.so.1", "gtk_tree_path_is_ancestor", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: descendant,
+            },
+        ], { type: "boolean" });
+    }
+    isDescendant(ancestor) {
+        return call("libgtk-4.so.1", "gtk_tree_path_is_descendant", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: ancestor,
+            },
+        ], { type: "boolean" });
+    }
+    next() {
+        call("libgtk-4.so.1", "gtk_tree_path_next", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    prependIndex(index_) {
+        call("libgtk-4.so.1", "gtk_tree_path_prepend_index", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: index_,
+            },
+        ], { type: "undefined" });
+    }
+    prev() {
+        return call("libgtk-4.so.1", "gtk_tree_path_prev", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    toString() {
+        return call("libgtk-4.so.1", "gtk_tree_path_to_string", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "string" });
+    }
+    up() {
+        return call("libgtk-4.so.1", "gtk_tree_path_up", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+}

package/dist/generated/gtk/tree-row-reference.d.ts

@@ -0,0 +1,17 @@
+import type { TreeIter } from "./tree-iter.js";
+import type { TreePath } from "./tree-path.js";
+export declare class TreeRowReference {
+    ptr: unknown;
+    constructor(model: unknown, path: TreePath);
+    constructor(_args: unknown[]);
+    static rowReferenceNewProxy(proxy: unknown, model: unknown, path: TreePath): TreeRowReference;
+    protected createPtr(_args: unknown[]): unknown;
+    static deleted(proxy: unknown, path: TreePath): void;
+    static inserted(proxy: unknown, path: TreePath): void;
+    static reordered(proxy: unknown, path: TreePath, iter: TreeIter, newOrder: number[]): void;
+    copy(): TreeRowReference;
+    free(): void;
+    getModel(): unknown;
+    getPath(): TreePath;
+    valid(): boolean;
+}

package/dist/generated/gtk/tree-row-reference.js

@@ -0,0 +1,161 @@
+import { call } from "@gtkx/native";
+export class TreeRowReference {
+    ptr;
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        this.ptr = this.createPtr(_args);
+    }
+    static rowReferenceNewProxy(proxy, model, path) {
+        const ptr = call("libgtk-4.so.1", "gtk_tree_row_reference_new_proxy", [
+            {
+                type: { type: "gobject" },
+                value: proxy,
+            },
+            {
+                type: { type: "gobject" },
+                value: model,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: path,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "TreeRowReference" });
+        const instance = Object.create(TreeRowReference.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    createPtr(_args) {
+        const [model, path] = _args;
+        return call("libgtk-4.so.1", "gtk_tree_row_reference_new", [
+            {
+                type: { type: "gobject" },
+                value: model,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: path,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "GtkTreeRowReference" });
+    }
+    static deleted(proxy, path) {
+        call("libgtk-4.so.1", "gtk_tree_row_reference_deleted", [
+            {
+                type: { type: "gobject" },
+                value: proxy,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: path,
+            },
+        ], { type: "undefined" });
+    }
+    static inserted(proxy, path) {
+        call("libgtk-4.so.1", "gtk_tree_row_reference_inserted", [
+            {
+                type: { type: "gobject" },
+                value: proxy,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: path,
+            },
+        ], { type: "undefined" });
+    }
+    static reordered(proxy, path, iter, newOrder) {
+        call("libgtk-4.so.1", "gtk_tree_row_reference_reordered", [
+            {
+                type: { type: "gobject" },
+                value: proxy,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
+                value: path,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreeIter",
+                    lib: "libgtk-4.so.1",
+                },
+                value: iter,
+            },
+            {
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 32, unsigned: false },
+                },
+                value: newOrder,
+            },
+        ], { type: "undefined" });
+    }
+    copy() {
+        return call("libgtk-4.so.1", "gtk_tree_row_reference_copy", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GtkTreeRowReference",
+            lib: "libgtk-4.so.1",
+        });
+    }
+    free() {
+        call("libgtk-4.so.1", "gtk_tree_row_reference_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getModel() {
+        return call("libgtk-4.so.1", "gtk_tree_row_reference_get_model", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    getPath() {
+        return call("libgtk-4.so.1", "gtk_tree_row_reference_get_path", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GtkTreePath",
+            lib: "libgtk-4.so.1",
+        });
+    }
+    valid() {
+        return call("libgtk-4.so.1", "gtk_tree_row_reference_valid", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+}

package/dist/generated/gtk/tree-selection.d.ts

@@ -1,5 +1,7 @@
 import { Ref } from "@gtkx/native";
 import { SelectionMode } from "./enums.js";
+import type { TreeIter } from "./tree-iter.js";
+import type { TreePath } from "./tree-path.js";
 export declare class TreeSelection {
     ptr: unknown;
     constructor(_args?: unknown[]);
@@ -7,23 +9,23 @@ export declare class TreeSelection {
     countSelectedRows(): number;
     getMode(): SelectionMode;
     getSelectFunction(): unknown;
-    getSelected(model?: Ref<unknown>, iter?: Ref<unknown>): boolean;
+    getSelected(model?: Ref<unknown>, iter?: Ref<TreeIter>): boolean;
     getSelectedRows(model?: Ref<unknown>): unknown;
     getTreeView(): unknown;
     getUserData(): unknown;
-    iterIsSelected(iter: unknown): boolean;
-    pathIsSelected(path: unknown): boolean;
+    iterIsSelected(iter: TreeIter): boolean;
+    pathIsSelected(path: TreePath): boolean;
     selectAll(): void;
-    selectIter(iter: unknown): void;
-    selectPath(path: unknown): void;
-    selectRange(startPath: unknown, endPath: unknown): void;
+    selectIter(iter: TreeIter): void;
+    selectPath(path: TreePath): void;
+    selectRange(startPath: TreePath, endPath: TreePath): void;
     selectedForeach(func: (...args: unknown[]) => unknown, data?: unknown): void;
     setMode(type: SelectionMode): void;
     setSelectFunction(destroy: unknown, func?: (...args: unknown[]) => unknown, data?: unknown): void;
     unselectAll(): void;
-    unselectIter(iter: unknown): void;
-    unselectPath(path: unknown): void;
-    unselectRange(startPath: unknown, endPath: unknown): void;
+    unselectIter(iter: TreeIter): void;
+    unselectPath(path: TreePath): void;
+    unselectRange(startPath: TreePath, endPath: TreePath): void;
     get mode(): SelectionMode;
     set mode(_value: SelectionMode);
     connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;

package/dist/generated/gtk/tree-selection.js

@@ -42,7 +42,14 @@ export class TreeSelection {
                 value: model,
             },
             {
-                type: { type: "ref", innerType: { type: "gobject" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        innerType: "GtkTreeIter",
+                        lib: "libgtk-4.so.1",
+                    },
+                },
                 value: iter,
             },
         ], { type: "boolean" });
@@ -82,7 +89,11 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreeIter",
+                    lib: "libgtk-4.so.1",
+                },
                 value: iter,
             },
         ], { type: "boolean" });
@@ -94,7 +105,11 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
                 value: path,
             },
         ], { type: "boolean" });
@@ -114,7 +129,11 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreeIter",
+                    lib: "libgtk-4.so.1",
+                },
                 value: iter,
             },
         ], { type: "undefined" });
@@ -126,7 +145,11 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
                 value: path,
             },
         ], { type: "undefined" });
@@ -138,11 +161,19 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
                 value: startPath,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
                 value: endPath,
             },
         ], { type: "undefined" });
@@ -210,7 +241,11 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreeIter",
+                    lib: "libgtk-4.so.1",
+                },
                 value: iter,
             },
         ], { type: "undefined" });
@@ -222,7 +257,11 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
                 value: path,
             },
         ], { type: "undefined" });
@@ -234,11 +273,19 @@ export class TreeSelection {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
                 value: startPath,
             },
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "boxed",
+                    innerType: "GtkTreePath",
+                    lib: "libgtk-4.so.1",
+                },
                 value: endPath,
             },
         ], { type: "undefined" });

package/dist/generated/gtk/tree-store.d.ts

@@ -1,29 +1,30 @@
 import { Ref } from "@gtkx/native";
+import type { TreeIter } from "./tree-iter.js";
 export declare class TreeStore {
     ptr: unknown;
     constructor(nColumns: number, types: number[]);
     constructor(_args: unknown[]);
     static storeNew(nColumns: number): TreeStore;
     protected createPtr(_args: unknown[]): unknown;
-    append(iter: Ref<unknown>, parent?: unknown): void;
+    append(iter: Ref<TreeIter>, parent?: TreeIter): void;
     clear(): void;
-    insert(iter: Ref<unknown>, position: number, parent?: unknown): void;
-    insertAfter(iter: Ref<unknown>, parent?: unknown, sibling?: unknown): void;
-    insertBefore(iter: Ref<unknown>, parent?: unknown, sibling?: unknown): void;
-    insertWithValues(position: number, iter?: Ref<unknown>, parent?: unknown): void;
-    insertWithValuesv(position: number, columns: number[], values: unknown[], nValues: number, iter?: Ref<unknown>, parent?: unknown): void;
-    isAncestor(iter: unknown, descendant: unknown): boolean;
-    iterDepth(iter: unknown): number;
-    iterIsValid(iter: unknown): boolean;
-    moveAfter(iter: unknown, position?: unknown): void;
-    moveBefore(iter: unknown, position?: unknown): void;
-    prepend(iter: Ref<unknown>, parent?: unknown): void;
-    remove(iter: unknown): boolean;
-    reorder(newOrder: number[], parent?: unknown): void;
-    set(iter: unknown): void;
+    insert(iter: Ref<TreeIter>, position: number, parent?: TreeIter): void;
+    insertAfter(iter: Ref<TreeIter>, parent?: TreeIter, sibling?: TreeIter): void;
+    insertBefore(iter: Ref<TreeIter>, parent?: TreeIter, sibling?: TreeIter): void;
+    insertWithValues(position: number, iter?: Ref<TreeIter>, parent?: TreeIter): void;
+    insertWithValuesv(position: number, columns: number[], values: unknown[], nValues: number, iter?: Ref<TreeIter>, parent?: TreeIter): void;
+    isAncestor(iter: TreeIter, descendant: TreeIter): boolean;
+    iterDepth(iter: TreeIter): number;
+    iterIsValid(iter: TreeIter): boolean;
+    moveAfter(iter: TreeIter, position?: TreeIter): void;
+    moveBefore(iter: TreeIter, position?: TreeIter): void;
+    prepend(iter: Ref<TreeIter>, parent?: TreeIter): void;
+    remove(iter: TreeIter): boolean;
+    reorder(newOrder: number[], parent?: TreeIter): void;
+    set(iter: TreeIter): void;
     setColumnTypes(nColumns: number, types: number[]): void;
-    setValist(iter: unknown, varArgs: unknown): void;
-    setValue(iter: unknown, column: number, value: unknown): void;
-    setValuesv(iter: unknown, columns: number[], values: unknown[], nValues: number): void;
-    swap(a: unknown, b: unknown): void;
+    setValist(iter: TreeIter, varArgs: unknown): void;
+    setValue(iter: TreeIter, column: number, value: unknown): void;
+    setValuesv(iter: TreeIter, columns: number[], values: unknown[], nValues: number): void;
+    swap(a: TreeIter, b: TreeIter): void;
 }