@gtkx/ffi 0.10.5 → 0.11.1

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

@@ -16,22 +16,25 @@ export class GlyphItem extends NativeObject {
     static objectType = "boxed";
     constructor(init = {}) {
         super();
-        this.id = this.createPtr(init);
-    }
-    createPtr(init) {
-        const ptr = alloc(32, "PangoGlyphItem", "libpango-1.0.so.0");
+        this.id = alloc(32, "PangoGlyphItem", "libpango-1.0.so.0");
         if (init.yOffset !== undefined)
-            write(ptr, { type: "int", size: 32, unsigned: false }, 16, init.yOffset);
+            write(this.id, {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            }, 16, init.yOffset);
         if (init.startXOffset !== undefined)
-            write(ptr, { type: "int", size: 32, unsigned: false }, 20, init.startXOffset);
+            write(this.id, {
+                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;
-    }
-    static fromPtr(ptr) {
-        const instance = Object.create(GlyphItem.prototype);
-        instance.id = ptr;
-        return instance;
+            write(this.id, {
+                type: "int",
+                size: 32,
+                unsigned: false,
+            }, 24, init.endXOffset);
     }
     /**
      * Splits a shaped item (`PangoGlyphItem`) into multiple items based
@@ -51,56 +54,56 @@ export class GlyphItem extends NativeObject {
      *
      * This function takes ownership of `glyph_item`; it will be reused
      * as one of the elements in the list.
-     * @param text - text that `list` applies to
-     * @param list - a `PangoAttrList`
      */
     applyAttrs(text, list) {
-        return call("libpango-1.0.so.0", "pango_glyph_item_apply_attrs", [
+        const arr = call("libpango-1.0.so.0", "pango_glyph_item_apply_attrs", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "PangoGlyphItem",
                     lib: "libpango-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: text,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "PangoAttrList",
                     lib: "libpango-1.0.so.0",
                     getTypeFn: "pango_attr_list_get_type",
                 },
-                value: list?.id ?? list,
+                value: list.id,
             },
         ], {
             type: "array",
             itemType: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "full",
                 innerType: "PangoGlyphItem",
                 lib: "libpango-1.0.so.0",
                 getTypeFn: "pango_glyph_item_get_type",
             },
             listType: "gslist",
-            borrowed: true,
+            ownership: "full",
         });
+        return arr.map((item) => getNativeObject(item));
     }
-    /**
-     * Make a deep copy of an existing `PangoGlyphItem` structure.
-     */
+    /** Make a deep copy of an existing `PangoGlyphItem` structure. */
     copy() {
         const ptr = call("libpango-1.0.so.0", "pango_glyph_item_copy", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "PangoGlyphItem",
                     lib: "libpango-1.0.so.0",
                 },
@@ -108,7 +111,7 @@ export class GlyphItem extends NativeObject {
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "PangoGlyphItem",
             lib: "libpango-1.0.so.0",
             getTypeFn: "pango_glyph_item_get_type",
@@ -117,21 +120,21 @@ export class GlyphItem extends NativeObject {
             return null;
         return getNativeObject(ptr, GlyphItem);
     }
-    /**
-     * Frees a `PangoGlyphItem` and resources to which it points.
-     */
+    /** Frees a `PangoGlyphItem` and resources to which it points. */
     free() {
         call("libpango-1.0.so.0", "pango_glyph_item_free", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "PangoGlyphItem",
                     lib: "libpango-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Given a `PangoGlyphItem` and the corresponding text, determine the
@@ -141,22 +144,23 @@ export class GlyphItem extends NativeObject {
      * entire cluster is divided equally among the characters.
      *
      * See also {@link Pango.GlyphString.get_logical_widths}.
-     * @param text - text that `glyph_item` corresponds to
-     * @param logicalWidths - an array whose length
      */
     getLogicalWidths(text, logicalWidths) {
         call("libpango-1.0.so.0", "pango_glyph_item_get_logical_widths", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "PangoGlyphItem",
                     lib: "libpango-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: text,
             },
             {
@@ -164,47 +168,67 @@ export class GlyphItem extends NativeObject {
                     type: "ref",
                     innerType: {
                         type: "array",
-                        itemType: { type: "int", size: 32, unsigned: false },
+                        itemType: {
+                            type: "int",
+                            size: 32,
+                            unsigned: false,
+                        },
+                        listType: "array",
+                        ownership: "none",
                     },
                 },
                 value: logicalWidths,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds spacing between the graphemes of `glyph_item` to
      * give the effect of typographic letter spacing.
-     * @param text - text that `glyph_item` corresponds to
-     * @param logAttrs - logical attributes for the item
-     * @param letterSpacing - amount of letter spacing to add
      */
     letterSpace(text, logAttrs, letterSpacing) {
         call("libpango-1.0.so.0", "pango_glyph_item_letter_space", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "PangoGlyphItem",
                     lib: "libpango-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: text,
             },
             {
                 type: {
                     type: "array",
-                    itemType: { type: "struct", innerType: "LogAttr" },
+                    itemType: {
+                        type: "struct",
+                        ownership: "none",
+                        innerType: "LogAttr",
+                    },
+                    listType: "array",
+                    ownership: "none",
                 },
                 value: logAttrs,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: letterSpacing,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Modifies `orig` to cover only the text after `split_index`, and
@@ -218,31 +242,36 @@ export class GlyphItem extends NativeObject {
      *
      * This function is similar in function to pango_item_split() (and uses
      * it internally.)
-     * @param text - text to which positions in `orig` apply
-     * @param splitIndex - byte index of position to split item, relative to the
      */
     split(text, splitIndex) {
         const ptr = call("libpango-1.0.so.0", "pango_glyph_item_split", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "PangoGlyphItem",
                     lib: "libpango-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: text,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: splitIndex,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "PangoGlyphItem",
             lib: "libpango-1.0.so.0",
             getTypeFn: "pango_glyph_item_get_type",
@@ -255,6 +284,7 @@ export class GlyphItem extends NativeObject {
     get item() {
         return read(this.id, {
             type: "boxed",
+            ownership: "full",
             innerType: "PangoItem",
             lib: "libpango-1.0.so.0",
             getTypeFn: "pango_item_get_type",
@@ -264,6 +294,7 @@ export class GlyphItem extends NativeObject {
     get glyphs() {
         return read(this.id, {
             type: "boxed",
+            ownership: "full",
             innerType: "PangoGlyphString",
             lib: "libpango-1.0.so.0",
             getTypeFn: "pango_glyph_string_get_type",
@@ -271,33 +302,57 @@ export class GlyphItem extends NativeObject {
     }
     /**
      * shift of the baseline, relative to the baseline
-     * of the containing line. Positive values shift upwards
+     *   of the containing line. Positive values shift upwards
      */
     get yOffset() {
-        return read(this.id, { type: "int", size: 32, unsigned: false }, 16);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        }, 16);
     }
     set yOffset(value) {
-        write(this.id, { type: "int", size: 32, unsigned: false }, 16, value);
+        write(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        }, 16, value);
     }
     /**
      * horizontal displacement to apply before the
-     * glyph item. Positive values shift right
+     *   glyph item. Positive values shift right
      */
     get startXOffset() {
-        return read(this.id, { type: "int", size: 32, unsigned: false }, 20);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        }, 20);
     }
     set startXOffset(value) {
-        write(this.id, { type: "int", size: 32, unsigned: false }, 20, value);
+        write(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        }, 20, value);
     }
     /**
      * horizontal displacement to apply after th
-     * glyph item. Positive values shift right
+     *   glyph item. Positive values shift right
      */
     get endXOffset() {
-        return read(this.id, { type: "int", size: 32, unsigned: false }, 24);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        }, 24);
     }
     set endXOffset(value) {
-        write(this.id, { type: "int", size: 32, unsigned: false }, 24, value);
+        write(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        }, 24, value);
     }
 }
 registerNativeClass(GlyphItem);

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

@@ -1,5 +1,7 @@
 import { Ref } from "@gtkx/native";
 import { NativeObject } from "../../native/base.js";
+import { Analysis } from "./analysis.js";
+import { GlyphInfo } from "./glyph-info.js";
 import { LogAttr } from "./log-attr.js";
 import { Rectangle } from "./rectangle.js";
 import { Font } from "./font.js";
@@ -13,15 +15,9 @@ import { Font } from "./font.js";
 export declare class GlyphString extends NativeObject {
     static readonly glibTypeName: string;
     static readonly objectType: "boxed";
-    /**
-     * Create a new `PangoGlyphString`.
-     */
+    /** Create a new `PangoGlyphString`. */
     constructor();
-    protected createPtr(_args: unknown[]): unknown;
-    static fromPtr(ptr: unknown): GlyphString;
-    /**
-     * Copy a glyph string and associated storage.
-     */
+    /** Copy a glyph string and associated storage. */
     copy(): GlyphString | null;
     /**
      * Compute the logical and ink extents of a glyph string.
@@ -32,27 +28,17 @@ export declare class GlyphString extends NativeObject {
      * Examples of logical (red) and ink (green) rects:
      *
      * ![](https://docs.gtk.org/Pango/rects1.png) ![](https://docs.gtk.org/Pango/rects2.png)
-     * @param font - a `PangoFont`
-     * @param inkRect - rectangle used to store the extents of the glyph string as drawn
-     * @param logicalRect - rectangle used to store the logical extents of the glyph string
      */
-    extents(font: Font, inkRect?: Rectangle, logicalRect?: Rectangle): void;
+    extents(font: Font, inkRect?: Rectangle | null, logicalRect?: Rectangle | null): void;
     /**
      * Computes the extents of a sub-portion of a glyph string.
      *
      * The extents are relative to the start of the glyph string range
      * (the origin of their coordinate system is at the start of the range,
      * not at the start of the entire glyph string).
-     * @param start - start index
-     * @param end - end index (the range is the set of bytes with
-     * @param font - a `PangoFont`
-     * @param inkRect - rectangle used to
-     * @param logicalRect - rectangle used to
-     */
-    extentsRange(start: number, end: number, font: Font, inkRect?: Rectangle, logicalRect?: Rectangle): void;
-    /**
-     * Free a glyph string and associated storage.
      */
+    extentsRange(start: number, end: number, font: Font, inkRect?: Rectangle | null, logicalRect?: Rectangle | null): void;
+    /** Free a glyph string and associated storage. */
     free(): void;
     /**
      * Given a `PangoGlyphString` and corresponding text, determine the width
@@ -62,10 +48,6 @@ export declare class GlyphString extends NativeObject {
      * entire cluster is divided equally among the characters.
      *
      * See also {@link Pango.GlyphItem.get_logical_widths}.
-     * @param text - the text corresponding to the glyphs
-     * @param length - the length of `text`, in bytes
-     * @param embeddingLevel - the embedding level of the string
-     * @param logicalWidths - an array whose length is
      */
     getLogicalWidths(text: string, length: number, embeddingLevel: number, logicalWidths: Ref<number[]>): void;
     /**
@@ -86,14 +68,8 @@ export declare class GlyphString extends NativeObject {
      * into equal portions, otherwise.
      *
      * ![Glyph positions](https://docs.gtk.org/Pango/glyphstring-positions-light.png)
-     * @param text - the text for the run
-     * @param length - the number of bytes (not characters) in `text`.
-     * @param analysis - the analysis information return from {@link itemize}
-     * @param index_ - the byte index within `text`
-     * @param trailing - whether we should compute the result for the beginning (%FALSE)
-     * @param xPos - location to store result
      */
-    indexToX(text: string, length: number, analysis: number, index_: number, trailing: boolean, xPos?: Ref<number>): void;
+    indexToX(text: string, length: number, analysis: Analysis, index_: number, trailing: boolean, xPos?: Ref<number> | null): void;
     /**
      * Converts from character position to x position.
      *
@@ -101,19 +77,9 @@ export declare class GlyphString extends NativeObject {
      * accepts a `PangoLogAttr` array. The grapheme boundary information
      * in it can be used to disambiguate positioning inside some complex
      * clusters.
-     * @param text - the text for the run
-     * @param length - the number of bytes (not characters) in `text`.
-     * @param analysis - the analysis information return from {@link itemize}
-     * @param attrs - `PangoLogAttr` array for `text`
-     * @param index_ - the byte index within `text`
-     * @param trailing - whether we should compute the result for the beginning (%FALSE)
-     * @param xPos - location to store result
-     */
-    indexToXFull(text: string, length: number, analysis: number, index_: number, trailing: boolean, attrs?: LogAttr, xPos?: Ref<number>): void;
-    /**
-     * Resize a glyph string to the given length.
-     * @param newLen - the new length of the string
      */
+    indexToXFull(text: string, length: number, analysis: Analysis, index_: number, trailing: boolean, attrs?: LogAttr | null, xPos?: Ref<number> | null): void;
+    /** Resize a glyph string to the given length. */
     setSize(newLen: number): void;
     /**
      * Convert from x offset to character position.
@@ -123,22 +89,16 @@ export declare class GlyphString extends NativeObject {
      * not allowed (such as Thai), the returned value may not be a valid
      * cursor position; the caller must combine the result with the logical
      * attributes for the text to compute the valid cursor position.
-     * @param text - the text for the run
-     * @param length - the number of bytes (not characters) in text.
-     * @param analysis - the analysis information return from {@link itemize}
-     * @param xPos - the x offset (in Pango units)
-     * @param index_ - location to store calculated byte index
-     * @param trailing - location to store a boolean indicating
      */
-    xToIndex(text: string, length: number, analysis: number, xPos: number, index_?: Ref<number>, trailing?: Ref<number>): void;
+    xToIndex(text: string, length: number, analysis: Analysis, xPos: number, index_?: Ref<number> | null, trailing?: Ref<number> | null): void;
     /** number of glyphs in this glyph string */
     get numGlyphs(): number;
     set numGlyphs(value: number);
     /** array of glyph information */
-    get glyphs(): number[];
+    get glyphs(): GlyphInfo[];
     /**
      * logical cluster info, indexed by the byte index
-     * within the text corresponding to the glyph string
+     *   within the text corresponding to the glyph string
      */
     get logClusters(): number;
     set logClusters(value: number);