@gtkx/ffi 0.1.5 → 0.1.7

package/dist/generated/pango/glyph-item-iter.d.ts

@@ -0,0 +1,34 @@
+import { GlyphItem } from "./glyph-item.js";
+export interface GlyphItemIterInit {
+    startGlyph?: number;
+    startIndex?: number;
+    startChar?: number;
+    endGlyph?: number;
+    endIndex?: number;
+    endChar?: number;
+}
+export declare class GlyphItemIter {
+    ptr: unknown;
+    constructor(init?: GlyphItemIterInit);
+    protected createPtr(init: GlyphItemIterInit): unknown;
+    copy(): GlyphItemIter;
+    free(): void;
+    initEnd(glyphItem: GlyphItem, text: string): boolean;
+    initStart(glyphItem: GlyphItem, text: string): boolean;
+    nextCluster(): boolean;
+    prevCluster(): boolean;
+    get glyphItem(): GlyphItem;
+    get text(): string;
+    get startGlyph(): number;
+    set startGlyph(value: number);
+    get startIndex(): number;
+    set startIndex(value: number);
+    get startChar(): number;
+    set startChar(value: number);
+    get endGlyph(): number;
+    set endGlyph(value: number);
+    get endIndex(): number;
+    set endIndex(value: number);
+    get endChar(): number;
+    set endChar(value: number);
+}

package/dist/generated/pango/glyph-item-iter.js

@@ -0,0 +1,147 @@
+import { alloc, call, read, write } from "@gtkx/native";
+export class GlyphItemIter {
+    ptr;
+    constructor(init = {}) {
+        this.ptr = this.createPtr(init);
+    }
+    createPtr(init) {
+        const ptr = alloc(40, "PangoGlyphItemIter", "libpango-1.0.so.0");
+        if (init.startGlyph !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 16, init.startGlyph);
+        if (init.startIndex !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 20, init.startIndex);
+        if (init.startChar !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 24, init.startChar);
+        if (init.endGlyph !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 28, init.endGlyph);
+        if (init.endIndex !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 32, init.endIndex);
+        if (init.endChar !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 36, init.endChar);
+        return ptr;
+    }
+    copy() {
+        const ptr = call("libpango-1.0.so.0", "pango_glyph_item_iter_copy", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "PangoGlyphItemIter",
+            lib: "libpango-1.0.so.0",
+        });
+        if (ptr === null)
+            return null;
+        const instance = Object.create(GlyphItemIter.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    free() {
+        call("libpango-1.0.so.0", "pango_glyph_item_iter_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    initEnd(glyphItem, text) {
+        return call("libpango-1.0.so.0", "pango_glyph_item_iter_init_end", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "PangoGlyphItem",
+                    lib: "libpango-1.0.so.0",
+                },
+                value: glyphItem?.ptr ?? glyphItem,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+        ], { type: "boolean" });
+    }
+    initStart(glyphItem, text) {
+        return call("libpango-1.0.so.0", "pango_glyph_item_iter_init_start", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "PangoGlyphItem",
+                    lib: "libpango-1.0.so.0",
+                },
+                value: glyphItem?.ptr ?? glyphItem,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+        ], { type: "boolean" });
+    }
+    nextCluster() {
+        return call("libpango-1.0.so.0", "pango_glyph_item_iter_next_cluster", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    prevCluster() {
+        return call("libpango-1.0.so.0", "pango_glyph_item_iter_prev_cluster", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    get glyphItem() {
+        return read(this.ptr, { type: "boxed", innerType: "PangoGlyphItem", lib: "libpango-1.0.so.0" }, 0);
+    }
+    get text() {
+        return read(this.ptr, { type: "string" }, 8);
+    }
+    get startGlyph() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 16);
+    }
+    set startGlyph(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 16, value);
+    }
+    get startIndex() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 20);
+    }
+    set startIndex(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 20, value);
+    }
+    get startChar() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 24);
+    }
+    set startChar(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 24, value);
+    }
+    get endGlyph() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 28);
+    }
+    set endGlyph(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 28, value);
+    }
+    get endIndex() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 32);
+    }
+    set endIndex(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 32, value);
+    }
+    get endChar() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 36);
+    }
+    set endChar(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 36, value);
+    }
+}

package/dist/generated/pango/glyph-item.d.ts

@@ -0,0 +1,28 @@
+import { Ref } from "@gtkx/native";
+import { AttrList } from "./attr-list.js";
+import { GlyphString } from "./glyph-string.js";
+import { Item } from "./item.js";
+export interface GlyphItemInit {
+    yOffset?: number;
+    startXOffset?: number;
+    endXOffset?: number;
+}
+export declare class GlyphItem {
+    ptr: unknown;
+    constructor(init?: GlyphItemInit);
+    protected createPtr(init: GlyphItemInit): unknown;
+    applyAttrs(text: string, list: AttrList): unknown;
+    copy(): GlyphItem;
+    free(): void;
+    getLogicalWidths(text: string, logicalWidths: Ref<number[]>): void;
+    letterSpace(text: string, logAttrs: unknown[], letterSpacing: number): void;
+    split(text: string, splitIndex: number): GlyphItem;
+    get item(): Item;
+    get glyphs(): GlyphString;
+    get yOffset(): number;
+    set yOffset(value: number);
+    get startXOffset(): number;
+    set startXOffset(value: number);
+    get endXOffset(): number;
+    set endXOffset(value: number);
+}

package/dist/generated/pango/glyph-item.js

@@ -0,0 +1,159 @@
+import { alloc, call, read, write } from "@gtkx/native";
+export class GlyphItem {
+    ptr;
+    constructor(init = {}) {
+        this.ptr = this.createPtr(init);
+    }
+    createPtr(init) {
+        const ptr = alloc(32, "PangoGlyphItem", "libpango-1.0.so.0");
+        if (init.yOffset !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 16, init.yOffset);
+        if (init.startXOffset !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 20, init.startXOffset);
+        if (init.endXOffset !== undefined)
+            write(ptr, { type: "int", size: 32, unsigned: false }, 24, init.endXOffset);
+        return ptr;
+    }
+    applyAttrs(text, list) {
+        return call("libpango-1.0.so.0", "pango_glyph_item_apply_attrs", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "PangoAttrList",
+                    lib: "libpango-1.0.so.0",
+                },
+                value: list?.ptr ?? list,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    copy() {
+        const ptr = call("libpango-1.0.so.0", "pango_glyph_item_copy", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "PangoGlyphItem",
+            lib: "libpango-1.0.so.0",
+        });
+        if (ptr === null)
+            return null;
+        const instance = Object.create(GlyphItem.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    free() {
+        call("libpango-1.0.so.0", "pango_glyph_item_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getLogicalWidths(text, logicalWidths) {
+        call("libpango-1.0.so.0", "pango_glyph_item_get_logical_widths", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: { type: "int", size: 32, unsigned: false },
+                    },
+                },
+                value: logicalWidths,
+            },
+        ], { type: "undefined" });
+    }
+    letterSpace(text, logAttrs, letterSpacing) {
+        call("libpango-1.0.so.0", "pango_glyph_item_letter_space", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: { type: "array", itemType: { type: "gobject" } },
+                value: logAttrs,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: letterSpacing,
+            },
+        ], { type: "undefined" });
+    }
+    split(text, splitIndex) {
+        const ptr = call("libpango-1.0.so.0", "pango_glyph_item_split", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: splitIndex,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "PangoGlyphItem",
+            lib: "libpango-1.0.so.0",
+        });
+        if (ptr === null)
+            return null;
+        const instance = Object.create(GlyphItem.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    get item() {
+        return read(this.ptr, { type: "boxed", innerType: "PangoItem", lib: "libpango-1.0.so.0" }, 0);
+    }
+    get glyphs() {
+        return read(this.ptr, {
+            type: "boxed",
+            innerType: "PangoGlyphString",
+            lib: "libpango-1.0.so.0",
+        }, 8);
+    }
+    get yOffset() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 16);
+    }
+    set yOffset(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 16, value);
+    }
+    get startXOffset() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 20);
+    }
+    set startXOffset(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 20, value);
+    }
+    get endXOffset() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 24);
+    }
+    set endXOffset(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 24, value);
+    }
+}

package/dist/generated/pango/glyph-string.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from "@gtkx/native";
+import { Font } from "./font.js";
+export declare class GlyphString {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_args: unknown[]): unknown;
+    copy(): GlyphString;
+    extents(font: Font, inkRect?: Ref<unknown>, logicalRect?: Ref<unknown>): void;
+    extentsRange(start: number, end: number, font: Font, inkRect?: Ref<unknown>, logicalRect?: Ref<unknown>): void;
+    free(): void;
+    getLogicalWidths(text: string, length: number, embeddingLevel: number, logicalWidths: Ref<number[]>): void;
+    getWidth(): number;
+    indexToX(text: string, length: number, analysis: unknown, index_: number, trailing: boolean, xPos?: Ref<number>): void;
+    indexToXFull(text: string, length: number, analysis: unknown, index_: number, trailing: boolean, attrs?: unknown, xPos?: Ref<number>): void;
+    setSize(newLen: number): void;
+    xToIndex(text: string, length: number, analysis: unknown, xPos: number, index_?: Ref<number>, trailing?: Ref<number>): void;
+    get numGlyphs(): number;
+    set numGlyphs(value: number);
+    get glyphs(): unknown[];
+    get logClusters(): number;
+    set logClusters(value: number);
+}

package/dist/generated/pango/glyph-string.js

@@ -0,0 +1,265 @@
+import { call, read, write } from "@gtkx/native";
+export class GlyphString {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr([]);
+    }
+    createPtr(_args) {
+        return call("libpango-1.0.so.0", "pango_glyph_string_new", [], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "PangoGlyphString",
+        });
+    }
+    copy() {
+        const ptr = call("libpango-1.0.so.0", "pango_glyph_string_copy", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "PangoGlyphString",
+            lib: "libpango-1.0.so.0",
+        });
+        if (ptr === null)
+            return null;
+        const instance = Object.create(GlyphString.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    extents(font, inkRect, logicalRect) {
+        call("libpango-1.0.so.0", "pango_glyph_string_extents", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "gobject" },
+                value: font?.ptr ?? font,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: inkRect,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: logicalRect,
+            },
+        ], { type: "undefined" });
+    }
+    extentsRange(start, end, font, inkRect, logicalRect) {
+        call("libpango-1.0.so.0", "pango_glyph_string_extents_range", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: start,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: end,
+            },
+            {
+                type: { type: "gobject" },
+                value: font?.ptr ?? font,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: inkRect,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: logicalRect,
+            },
+        ], { type: "undefined" });
+    }
+    free() {
+        call("libpango-1.0.so.0", "pango_glyph_string_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getLogicalWidths(text, length, embeddingLevel, logicalWidths) {
+        call("libpango-1.0.so.0", "pango_glyph_string_get_logical_widths", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: length,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: embeddingLevel,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "array",
+                        itemType: { type: "int", size: 32, unsigned: false },
+                    },
+                },
+                value: logicalWidths,
+            },
+        ], { type: "undefined" });
+    }
+    getWidth() {
+        return call("libpango-1.0.so.0", "pango_glyph_string_get_width", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    indexToX(text, length, analysis, index_, trailing, xPos) {
+        call("libpango-1.0.so.0", "pango_glyph_string_index_to_x", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: length,
+            },
+            {
+                type: { type: "gobject" },
+                value: analysis?.ptr ?? analysis,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: index_,
+            },
+            {
+                type: { type: "boolean" },
+                value: trailing,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: xPos,
+            },
+        ], { type: "undefined" });
+    }
+    indexToXFull(text, length, analysis, index_, trailing, attrs, xPos) {
+        call("libpango-1.0.so.0", "pango_glyph_string_index_to_x_full", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: length,
+            },
+            {
+                type: { type: "gobject" },
+                value: analysis?.ptr ?? analysis,
+            },
+            {
+                type: { type: "gobject" },
+                value: attrs?.ptr ?? attrs,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: index_,
+            },
+            {
+                type: { type: "boolean" },
+                value: trailing,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: xPos,
+            },
+        ], { type: "undefined" });
+    }
+    setSize(newLen) {
+        call("libpango-1.0.so.0", "pango_glyph_string_set_size", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: newLen,
+            },
+        ], { type: "undefined" });
+    }
+    xToIndex(text, length, analysis, xPos, index_, trailing) {
+        call("libpango-1.0.so.0", "pango_glyph_string_x_to_index", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: { type: "string" },
+                value: text,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: length,
+            },
+            {
+                type: { type: "gobject" },
+                value: analysis?.ptr ?? analysis,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: xPos,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: index_,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: trailing,
+            },
+        ], { type: "undefined" });
+    }
+    get numGlyphs() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 0);
+    }
+    set numGlyphs(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 0, value);
+    }
+    get glyphs() {
+        return read(this.ptr, { type: "array", itemType: { type: "gobject" } }, 8);
+    }
+    get logClusters() {
+        return read(this.ptr, { type: "int", size: 32, unsigned: false }, 16);
+    }
+    set logClusters(value) {
+        write(this.ptr, { type: "int", size: 32, unsigned: false }, 16, value);
+    }
+}

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

@@ -1,3 +1,20 @@
+export * from "./enums.js";
+export * from "./attr-iterator.js";
+export * from "./attr-list.js";
+export * from "./attribute.js";
+export * from "./color.js";
+export * from "./font-description.js";
+export * from "./font-metrics.js";
+export * from "./glyph-item.js";
+export * from "./glyph-item-iter.js";
+export * from "./glyph-string.js";
+export * from "./item.js";
+export * from "./language.js";
+export * from "./layout-iter.js";
+export * from "./layout-line.js";
+export * from "./matrix.js";
+export * from "./script-iter.js";
+export * from "./tab-array.js";
 export * from "./context.js";
 export * from "./coverage.js";
 export * from "./font.js";
@@ -9,4 +26,3 @@ export * from "./fontset-simple.js";
 export * from "./layout.js";
 export * from "./renderer.js";
 export * from "./functions.js";
-export * from "./enums.js";