@gtkx/ffi 0.1.0

package/dist/generated/gtk/cell-renderer-text.d.ts

@@ -0,0 +1,96 @@
+import { WrapMode } from "./enums.js";
+import { CellRenderer } from "./cell-renderer.js";
+export declare class CellRendererText extends CellRenderer {
+    constructor(_skipCreate?: boolean);
+    setFixedHeightFromFont(numberOfRows: number): void;
+    get alignSet(): boolean;
+    set alignSet(_value: boolean);
+    get alignment(): unknown;
+    set alignment(_value: unknown);
+    get attributes(): unknown;
+    set attributes(_value: unknown);
+    set background(_value: string);
+    get backgroundRgba(): unknown;
+    set backgroundRgba(_value: unknown);
+    get backgroundSet(): boolean;
+    set backgroundSet(_value: boolean);
+    get editable(): boolean;
+    set editable(_value: boolean);
+    get editableSet(): boolean;
+    set editableSet(_value: boolean);
+    get ellipsize(): unknown;
+    set ellipsize(_value: unknown);
+    get ellipsizeSet(): boolean;
+    set ellipsizeSet(_value: boolean);
+    get family(): string;
+    set family(_value: string);
+    get familySet(): boolean;
+    set familySet(_value: boolean);
+    get font(): string;
+    set font(_value: string);
+    get fontDesc(): unknown;
+    set fontDesc(_value: unknown);
+    set foreground(_value: string);
+    get foregroundRgba(): unknown;
+    set foregroundRgba(_value: unknown);
+    get foregroundSet(): boolean;
+    set foregroundSet(_value: boolean);
+    get language(): string;
+    set language(_value: string);
+    get languageSet(): boolean;
+    set languageSet(_value: boolean);
+    set markup(_value: string);
+    get maxWidthChars(): number;
+    set maxWidthChars(_value: number);
+    get placeholderText(): string;
+    set placeholderText(_value: string);
+    get rise(): number;
+    set rise(_value: number);
+    get riseSet(): boolean;
+    set riseSet(_value: boolean);
+    get scale(): number;
+    set scale(_value: number);
+    get scaleSet(): boolean;
+    set scaleSet(_value: boolean);
+    get singleParagraphMode(): boolean;
+    set singleParagraphMode(_value: boolean);
+    get size(): number;
+    set size(_value: number);
+    get sizePoints(): number;
+    set sizePoints(_value: number);
+    get sizeSet(): boolean;
+    set sizeSet(_value: boolean);
+    get stretch(): unknown;
+    set stretch(_value: unknown);
+    get stretchSet(): boolean;
+    set stretchSet(_value: boolean);
+    get strikethrough(): boolean;
+    set strikethrough(_value: boolean);
+    get strikethroughSet(): boolean;
+    set strikethroughSet(_value: boolean);
+    get style(): unknown;
+    set style(_value: unknown);
+    get styleSet(): boolean;
+    set styleSet(_value: boolean);
+    get text(): string;
+    set text(_value: string);
+    get underline(): unknown;
+    set underline(_value: unknown);
+    get underlineSet(): boolean;
+    set underlineSet(_value: boolean);
+    get variant(): unknown;
+    set variant(_value: unknown);
+    get variantSet(): boolean;
+    set variantSet(_value: boolean);
+    get weight(): number;
+    set weight(_value: number);
+    get weightSet(): boolean;
+    set weightSet(_value: boolean);
+    get widthChars(): number;
+    set widthChars(_value: number);
+    get wrapMode(): WrapMode;
+    set wrapMode(_value: WrapMode);
+    get wrapWidth(): number;
+    set wrapWidth(_value: number);
+    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+}

package/dist/generated/gtk/cell-renderer-text.js

@@ -0,0 +1,317 @@
+import { call } from "@gtkx/native";
+import { CellRenderer } from "./cell-renderer.js";
+export class CellRendererText extends CellRenderer {
+    constructor(_skipCreate) {
+        super(true);
+        if (!_skipCreate)
+            this.ptr = call("libgtk-4.so.1", "gtk_cell_renderer_text_new", [], {
+                type: "gobject",
+                borrowed: true,
+            });
+    }
+    setFixedHeightFromFont(numberOfRows) {
+        call("libgtk-4.so.1", "gtk_cell_renderer_text_set_fixed_height_from_font", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: numberOfRows,
+            },
+        ], { type: "undefined" });
+    }
+    get alignSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set alignSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get alignment() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set alignment(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get attributes() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set attributes(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    set background(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get backgroundRgba() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set backgroundRgba(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get backgroundSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set backgroundSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get editable() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set editable(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get editableSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set editableSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get ellipsize() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set ellipsize(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get ellipsizeSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set ellipsizeSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get family() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set family(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get familySet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set familySet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get font() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set font(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get fontDesc() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set fontDesc(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    set foreground(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get foregroundRgba() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set foregroundRgba(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get foregroundSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set foregroundSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get language() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set language(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get languageSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set languageSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    set markup(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get maxWidthChars() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set maxWidthChars(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get placeholderText() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set placeholderText(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get rise() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set rise(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get riseSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set riseSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get scale() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set scale(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get scaleSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set scaleSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get singleParagraphMode() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set singleParagraphMode(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get size() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set size(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get sizePoints() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set sizePoints(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get sizeSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set sizeSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get stretch() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set stretch(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get stretchSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set stretchSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get strikethrough() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set strikethrough(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get strikethroughSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set strikethroughSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get style() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set style(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get styleSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set styleSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get text() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set text(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get underline() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set underline(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get underlineSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set underlineSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get variant() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set variant(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get variantSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set variantSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get weight() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set weight(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get weightSet() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set weightSet(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get widthChars() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set widthChars(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get wrapMode() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set wrapMode(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get wrapWidth() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set wrapWidth(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    connect(signal, handler, after = false) {
+        const signalMeta = {
+            edited: [{ type: { type: "string" } }, { type: { type: "string" } }],
+        };
+        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/gtk/cell-renderer-toggle.d.ts

@@ -0,0 +1,19 @@
+import { CellRenderer } from "./cell-renderer.js";
+export declare class CellRendererToggle extends CellRenderer {
+    constructor();
+    getActivatable(): boolean;
+    getActive(): boolean;
+    getRadio(): boolean;
+    setActivatable(setting: boolean): void;
+    setActive(setting: boolean): void;
+    setRadio(radio: boolean): void;
+    get activatable(): boolean;
+    set activatable(_value: boolean);
+    get active(): boolean;
+    set active(_value: boolean);
+    get inconsistent(): boolean;
+    set inconsistent(_value: boolean);
+    get radio(): boolean;
+    set radio(_value: boolean);
+    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+}

package/dist/generated/gtk/cell-renderer-toggle.js

@@ -0,0 +1,121 @@
+import { call } from "@gtkx/native";
+import { CellRenderer } from "./cell-renderer.js";
+export class CellRendererToggle extends CellRenderer {
+    constructor() {
+        super(true);
+        this.ptr = call("libgtk-4.so.1", "gtk_cell_renderer_toggle_new", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+    }
+    getActivatable() {
+        return call("libgtk-4.so.1", "gtk_cell_renderer_toggle_get_activatable", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    getActive() {
+        return call("libgtk-4.so.1", "gtk_cell_renderer_toggle_get_active", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    getRadio() {
+        return call("libgtk-4.so.1", "gtk_cell_renderer_toggle_get_radio", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    setActivatable(setting) {
+        call("libgtk-4.so.1", "gtk_cell_renderer_toggle_set_activatable", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boolean" },
+                value: setting,
+            },
+        ], { type: "undefined" });
+    }
+    setActive(setting) {
+        call("libgtk-4.so.1", "gtk_cell_renderer_toggle_set_active", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boolean" },
+                value: setting,
+            },
+        ], { type: "undefined" });
+    }
+    setRadio(radio) {
+        call("libgtk-4.so.1", "gtk_cell_renderer_toggle_set_radio", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "boolean" },
+                value: radio,
+            },
+        ], { type: "undefined" });
+    }
+    get activatable() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set activatable(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get active() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set active(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get inconsistent() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set inconsistent(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    get radio() {
+        throw new Error("Property getters not yet implemented");
+    }
+    set radio(_value) {
+        throw new Error("Property setters not yet implemented");
+    }
+    connect(signal, handler, after = false) {
+        const signalMeta = {
+            toggled: [{ type: { type: "string" } }],
+        };
+        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/gtk/cell-renderer.d.ts

@@ -0,0 +1,62 @@
+import { Ref } from "@gtkx/native";
+import { CellRendererMode, CellRendererState, SizeRequestMode, StateFlags } from "./enums.js";
+export declare class CellRenderer {
+    ptr: unknown;
+    constructor(_skipCreate?: boolean);
+    activate(event: unknown, widget: unknown, path: string, backgroundArea: unknown, cellArea: unknown, flags: CellRendererState): boolean;
+    getAlignedArea(widget: unknown, flags: CellRendererState, cellArea: unknown, alignedArea: Ref<unknown>): void;
+    getAlignment(xalign?: Ref<number>, yalign?: Ref<number>): void;
+    getFixedSize(width?: Ref<number>, height?: Ref<number>): void;
+    getIsExpanded(): boolean;
+    getIsExpander(): boolean;
+    getPadding(xpad?: Ref<number>, ypad?: Ref<number>): void;
+    getPreferredHeight(widget: unknown, minimumSize?: Ref<number>, naturalSize?: Ref<number>): void;
+    getPreferredHeightForWidth(widget: unknown, width: number, minimumHeight?: Ref<number>, naturalHeight?: Ref<number>): void;
+    getPreferredSize(widget: unknown, minimumSize?: Ref<unknown>, naturalSize?: Ref<unknown>): void;
+    getPreferredWidth(widget: unknown, minimumSize?: Ref<number>, naturalSize?: Ref<number>): void;
+    getPreferredWidthForHeight(widget: unknown, height: number, minimumWidth?: Ref<number>, naturalWidth?: Ref<number>): void;
+    getRequestMode(): SizeRequestMode;
+    getSensitive(): boolean;
+    getState(cellState: CellRendererState, widget?: unknown): StateFlags;
+    getVisible(): boolean;
+    isActivatable(): boolean;
+    setAlignment(xalign: number, yalign: number): void;
+    setFixedSize(width: number, height: number): void;
+    setIsExpanded(isExpanded: boolean): void;
+    setIsExpander(isExpander: boolean): void;
+    setPadding(xpad: number, ypad: number): void;
+    setSensitive(sensitive: boolean): void;
+    setVisible(visible: boolean): void;
+    snapshot(snapshot: unknown, widget: unknown, backgroundArea: unknown, cellArea: unknown, flags: CellRendererState): void;
+    startEditing(widget: unknown, path: string, backgroundArea: unknown, cellArea: unknown, flags: CellRendererState, event?: unknown): unknown;
+    stopEditing(canceled: boolean): void;
+    set cellBackground(_value: string);
+    get cellBackgroundRgba(): unknown;
+    set cellBackgroundRgba(_value: unknown);
+    get cellBackgroundSet(): boolean;
+    set cellBackgroundSet(_value: boolean);
+    get editing(): boolean;
+    get height(): number;
+    set height(_value: number);
+    get isExpanded(): boolean;
+    set isExpanded(_value: boolean);
+    get isExpander(): boolean;
+    set isExpander(_value: boolean);
+    get mode(): CellRendererMode;
+    set mode(_value: CellRendererMode);
+    get sensitive(): boolean;
+    set sensitive(_value: boolean);
+    get visible(): boolean;
+    set visible(_value: boolean);
+    get width(): number;
+    set width(_value: number);
+    get xalign(): number;
+    set xalign(_value: number);
+    get xpad(): number;
+    set xpad(_value: number);
+    get yalign(): number;
+    set yalign(_value: number);
+    get ypad(): number;
+    set ypad(_value: number);
+    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
+}