@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/pango/renderer.js

@@ -5,6 +5,14 @@ import { LayoutLine } from "./layout-line.js";
 import { Matrix } from "./matrix.js";
 import { Layout } from "./layout.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `PangoRenderer` is a base class for objects that can render text
+ * provided as `PangoGlyphString` or `PangoLayout`.
+ *
+ * By subclassing `PangoRenderer` and overriding operations such as
+ * `draw_glyphs` and @draw_rectangle, renderers for particular font
+ * backends and destinations can be created.
+ */
 export class Renderer extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -20,6 +28,17 @@ export class Renderer extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Does initial setup before rendering operations on @renderer.
+     *
+     * [method@Pango.Renderer.deactivate] should be called when done drawing.
+     * Calls such as [method@Pango.Renderer.draw_layout] automatically
+     * activate the layout before drawing on it.
+     *
+     * Calls to [method@Pango.Renderer.activate] and
+     * [method@Pango.Renderer.deactivate] can be nested and the
+     * renderer will only be initialized and deinitialized once.
+     */
     activate() {
         call("libpango-1.0.so.0", "pango_renderer_activate", [
             {
@@ -28,6 +47,11 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Cleans up after rendering operations on @renderer.
+     *
+     * See docs for [method@Pango.Renderer.activate].
+     */
     deactivate() {
         call("libpango-1.0.so.0", "pango_renderer_deactivate", [
             {
@@ -36,6 +60,21 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draw a squiggly line that approximately covers the given rectangle
+     * in the style of an underline used to indicate a spelling error.
+     *
+     * The width of the underline is rounded to an integer number
+     * of up/down segments and the resulting rectangle is centered
+     * in the original rectangle.
+     *
+     * This should be called while `renderer` is already active.
+     * Use [method@Pango.Renderer.activate] to activate a renderer.
+     * @param x - X coordinate of underline, in Pango units in user coordinate system
+     * @param y - Y coordinate of underline, in Pango units in user coordinate system
+     * @param width - width of underline, in Pango units in user coordinate system
+     * @param height - height of underline, in Pango units in user coordinate system
+     */
     drawErrorUnderline(x, y, width, height) {
         call("libpango-1.0.so.0", "pango_renderer_draw_error_underline", [
             {
@@ -60,6 +99,13 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draws a single glyph with coordinates in device space.
+     * @param font - a `PangoFont`
+     * @param glyph - the glyph index of a single glyph
+     * @param x - X coordinate of left edge of baseline of glyph
+     * @param y - Y coordinate of left edge of baseline of glyph
+     */
     drawGlyph(font, glyph, x, y) {
         call("libpango-1.0.so.0", "pango_renderer_draw_glyph", [
             {
@@ -84,6 +130,30 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draws the glyphs in `glyph_item` with the specified `PangoRenderer`,
+     * embedding the text associated with the glyphs in the output if the
+     * output format supports it.
+     *
+     * This is useful for rendering text in PDF.
+     *
+     * Note that this method does not handle attributes in @glyph_item.
+     * If you want colors, shapes and lines handled automatically according
+     * to those attributes, you need to use pango_renderer_draw_layout_line()
+     * or pango_renderer_draw_layout().
+     *
+     * Note that `text` is the start of the text for layout, which is then
+     * indexed by `glyph_item->item->offset`.
+     *
+     * If `text` is %NULL, this simply calls [method@Pango.Renderer.draw_glyphs].
+     *
+     * The default implementation of this method simply falls back to
+     * [method@Pango.Renderer.draw_glyphs].
+     * @param text - the UTF-8 text that `glyph_item` refers to
+     * @param glyphItem - a `PangoGlyphItem`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawGlyphItem(glyphItem, x, y, text) {
         call("libpango-1.0.so.0", "pango_renderer_draw_glyph_item", [
             {
@@ -114,6 +184,13 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draws the glyphs in `glyphs` with the specified `PangoRenderer`.
+     * @param font - a `PangoFont`
+     * @param glyphs - a `PangoGlyphString`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawGlyphs(font, glyphs, x, y) {
         call("libpango-1.0.so.0", "pango_renderer_draw_glyphs", [
             {
@@ -143,6 +220,15 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draws `layout` with the specified `PangoRenderer`.
+     *
+     * This is equivalent to drawing the lines of the layout, at their
+     * respective positions relative to @x, @y.
+     * @param layout - a `PangoLayout`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawLayout(layout, x, y) {
         call("libpango-1.0.so.0", "pango_renderer_draw_layout", [
             {
@@ -163,6 +249,16 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draws `line` with the specified `PangoRenderer`.
+     *
+     * This draws the glyph items that make up the line, as well as
+     * shapes, backgrounds and lines that are specified by the attributes
+     * of those items.
+     * @param line - a `PangoLayoutLine`
+     * @param x - X position of left edge of baseline, in user space coordinates
+     * @param y - Y position of left edge of baseline, in user space coordinates
+     */
     drawLayoutLine(line, x, y) {
         call("libpango-1.0.so.0", "pango_renderer_draw_layout_line", [
             {
@@ -188,6 +284,18 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draws an axis-aligned rectangle in user space coordinates with the
+     * specified `PangoRenderer`.
+     *
+     * This should be called while `renderer` is already active.
+     * Use [method@Pango.Renderer.activate] to activate a renderer.
+     * @param part - type of object this rectangle is part of
+     * @param x - X position at which to draw rectangle, in user space coordinates
+     * @param y - Y position at which to draw rectangle, in user space coordinates
+     * @param width - width of rectangle in Pango units
+     * @param height - height of rectangle in Pango units
+     */
     drawRectangle(part, x, y, width, height) {
         call("libpango-1.0.so.0", "pango_renderer_draw_rectangle", [
             {
@@ -216,6 +324,17 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Draws a trapezoid with the parallel sides aligned with the X axis
+     * using the given `PangoRenderer`; coordinates are in device space.
+     * @param part - type of object this trapezoid is part of
+     * @param y1_ - Y coordinate of top of trapezoid
+     * @param x11 - X coordinate of left end of top of trapezoid
+     * @param x21 - X coordinate of right end of top of trapezoid
+     * @param y2 - Y coordinate of bottom of trapezoid
+     * @param x12 - X coordinate of left end of bottom of trapezoid
+     * @param x22 - X coordinate of right end of bottom of trapezoid
+     */
     drawTrapezoid(part, y1_, x11, x21, y2, x12, x22) {
         call("libpango-1.0.so.0", "pango_renderer_draw_trapezoid", [
             {
@@ -252,6 +371,10 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the current alpha for the specified part.
+     * @param part - the part to get the alpha for
+     */
     getAlpha(part) {
         return call("libpango-1.0.so.0", "pango_renderer_get_alpha", [
             {
@@ -264,6 +387,10 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the current rendering color for the specified part.
+     * @param part - the part to get the color for
+     */
     getColor(part) {
         const ptr = call("libpango-1.0.so.0", "pango_renderer_get_color", [
             {
@@ -284,6 +411,15 @@ export class Renderer extends GObject.GObject {
             return null;
         return getObject(ptr, Color);
     }
+    /**
+     * Gets the layout currently being rendered using @renderer.
+     *
+     * Calling this function only makes sense from inside a subclass's
+     * methods, like in its draw_shape vfunc, for example.
+     *
+     * The returned layout should not be modified while still being
+     * rendered.
+     */
     getLayout() {
         const ptr = call("libpango-1.0.so.0", "pango_renderer_get_layout", [
             {
@@ -295,6 +431,15 @@ export class Renderer extends GObject.GObject {
             return null;
         return getObject(ptr, Layout);
     }
+    /**
+     * Gets the layout line currently being rendered using @renderer.
+     *
+     * Calling this function only makes sense from inside a subclass's
+     * methods, like in its draw_shape vfunc, for example.
+     *
+     * The returned layout line should not be modified while still being
+     * rendered.
+     */
     getLayoutLine() {
         const ptr = call("libpango-1.0.so.0", "pango_renderer_get_layout_line", [
             {
@@ -311,6 +456,12 @@ export class Renderer extends GObject.GObject {
             return null;
         return getObject(ptr, LayoutLine);
     }
+    /**
+     * Gets the transformation matrix that will be applied when
+     * rendering.
+     *
+     * See [method@Pango.Renderer.set_matrix].
+     */
     getMatrix() {
         const ptr = call("libpango-1.0.so.0", "pango_renderer_get_matrix", [
             {
@@ -327,6 +478,24 @@ export class Renderer extends GObject.GObject {
             return null;
         return getObject(ptr, Matrix);
     }
+    /**
+     * Informs Pango that the way that the rendering is done
+     * for `part` has changed.
+     *
+     * This should be called if the rendering changes in a way that would
+     * prevent multiple pieces being joined together into one drawing call.
+     * For instance, if a subclass of `PangoRenderer` was to add a stipple
+     * option for drawing underlines, it needs to call
+     *
+     * ```
+     * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
+     * ```
+     *
+     * When the stipple changes or underlines with different stipples
+     * might be joined together. Pango automatically calls this for
+     * changes to colors. (See [method@Pango.Renderer.set_color])
+     * @param part - the part for which rendering has changed.
+     */
     partChanged(part) {
         call("libpango-1.0.so.0", "pango_renderer_part_changed", [
             {
@@ -339,6 +508,14 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the alpha for part of the rendering.
+     *
+     * Note that the alpha may only be used if a color is
+     * specified for `part` as well.
+     * @param part - the part to set the alpha for
+     * @param alpha - an alpha value between 1 and 65536, or 0 to unset the alpha
+     */
     setAlpha(part, alpha) {
         call("libpango-1.0.so.0", "pango_renderer_set_alpha", [
             {
@@ -355,6 +532,13 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the color for part of the rendering.
+     *
+     * Also see [method@Pango.Renderer.set_alpha].
+     * @param part - the part to change the color of
+     * @param color - the new color or %NULL to unset the current color
+     */
     setColor(part, color) {
         call("libpango-1.0.so.0", "pango_renderer_set_color", [
             {
@@ -377,6 +561,10 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the transformation matrix that will be applied when rendering.
+     * @param matrix - a `PangoMatrix`, or %NULL to unset any existing matrix
+     */
     setMatrix(matrix) {
         call("libpango-1.0.so.0", "pango_renderer_set_matrix", [
             {

package/dist/generated/pango/script-iter.d.ts

@@ -1,11 +1,48 @@
 import { Ref } from "@gtkx/native";
 import { Script } from "./enums.js";
+/**
+ * A `PangoScriptIter` is used to iterate through a string
+ * and identify ranges in different scripts.
+ */
 export declare class ScriptIter {
     ptr: unknown;
+    /**
+     * Create a new `PangoScriptIter`, used to break a string of
+     * Unicode text into runs by Unicode script.
+     *
+     * No copy is made of @text, so the caller needs to make
+     * sure it remains valid until the iterator is freed with
+     * [method@Pango.ScriptIter.free].
+     * @param text - a UTF-8 string
+     * @param length - length of @text, or -1 if `text` is nul-terminated
+     */
     constructor(text: string, length: number);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Frees a `PangoScriptIter`.
+     */
     free(): void;
+    /**
+     * Gets information about the range to which `iter` currently points.
+     *
+     * The range is the set of locations p where *start <= p < *end.
+     * (That is, it doesn't include the character stored at *end)
+     *
+     * Note that while the type of the `script` argument is declared
+     * as `PangoScript`, as of Pango 1.18, this function simply returns
+     * `GUnicodeScript` values. Callers must be prepared to handle unknown
+     * values.
+     * @param start - location to store start
+     * @param end - location to store end position
+     * @param script - location to store script for range
+     */
     getRange(start?: Ref<string> | null, end?: Ref<string> | null, script?: Ref<Script> | null): void;
+    /**
+     * Advances a `PangoScriptIter` to the next range.
+     *
+     * If `iter` is already at the end, it is left unchanged
+     * and %FALSE is returned.
+     */
     next(): boolean;
 }

package/dist/generated/pango/script-iter.js

@@ -1,4 +1,8 @@
 import { call } from "@gtkx/native";
+/**
+ * A `PangoScriptIter` is used to iterate through a string
+ * and identify ranges in different scripts.
+ */
 export class ScriptIter {
     ptr;
     constructor(...args) {
@@ -18,6 +22,9 @@ export class ScriptIter {
             },
         ], { type: "boxed", borrowed: true, innerType: "PangoScriptIter" });
     }
+    /**
+     * Frees a `PangoScriptIter`.
+     */
     free() {
         call("libpango-1.0.so.0", "pango_script_iter_free", [
             {
@@ -26,6 +33,20 @@ export class ScriptIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets information about the range to which `iter` currently points.
+     *
+     * The range is the set of locations p where *start <= p < *end.
+     * (That is, it doesn't include the character stored at *end)
+     *
+     * Note that while the type of the `script` argument is declared
+     * as `PangoScript`, as of Pango 1.18, this function simply returns
+     * `GUnicodeScript` values. Callers must be prepared to handle unknown
+     * values.
+     * @param start - location to store start
+     * @param end - location to store end position
+     * @param script - location to store script for range
+     */
     getRange(start, end, script) {
         call("libpango-1.0.so.0", "pango_script_iter_get_range", [
             {
@@ -52,6 +73,12 @@ export class ScriptIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Advances a `PangoScriptIter` to the next range.
+     *
+     * If `iter` is already at the end, it is left unchanged
+     * and %FALSE is returned.
+     */
     next() {
         return call("libpango-1.0.so.0", "pango_script_iter_next", [
             {

package/dist/generated/pango/tab-array.d.ts

@@ -1,22 +1,136 @@
 import { Ref } from "@gtkx/native";
 import { TabAlign } from "./enums.js";
+/**
+ * A `PangoTabArray` contains an array of tab stops.
+ *
+ * `PangoTabArray` can be used to set tab stops in a `PangoLayout`.
+ * Each tab stop has an alignment, a position, and optionally
+ * a character to use as decimal point.
+ */
 export declare class TabArray {
     ptr: unknown;
+    /**
+     * Creates an array of `initial_size` tab stops.
+     *
+     * Tab stops are specified in pixel units if `positions_in_pixels` is %TRUE,
+     * otherwise in Pango units. All stops are initially at position 0.
+     * @param initialSize - Initial number of tab stops to allocate, can be 0
+     * @param positionsInPixels - whether positions are in pixel units
+     */
     constructor(initialSize: number, positionsInPixels: boolean);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Deserializes a `PangoTabArray` from a string.
+     *
+     * This is the counterpart to [method@Pango.TabArray.to_string].
+     * See that functions for details about the format.
+     * @param text - a string
+     */
     static fromString(text: string): TabArray;
+    /**
+     * Copies a `PangoTabArray`.
+     */
     copy(): TabArray;
+    /**
+     * Frees a tab array and associated resources.
+     */
     free(): void;
+    /**
+     * Gets the Unicode character to use as decimal point.
+     *
+     * This is only relevant for tabs with %PANGO_TAB_DECIMAL alignment,
+     * which align content at the first occurrence of the decimal point
+     * character.
+     *
+     * The default value of 0 means that Pango will use the
+     * decimal point according to the current locale.
+     * @param tabIndex - the index of a tab stop
+     */
     getDecimalPoint(tabIndex: number): number;
+    /**
+     * Returns %TRUE if the tab positions are in pixels,
+     * %FALSE if they are in Pango units.
+     */
     getPositionsInPixels(): boolean;
+    /**
+     * Gets the number of tab stops in @tab_array.
+     */
     getSize(): number;
+    /**
+     * Gets the alignment and position of a tab stop.
+     * @param tabIndex - tab stop index
+     * @param alignment - location to store alignment
+     * @param location - location to store tab position
+     */
     getTab(tabIndex: number, alignment?: Ref<TabAlign> | null, location?: Ref<number> | null): void;
+    /**
+     * If non-%NULL, `alignments` and `locations` are filled with allocated
+     * arrays.
+     *
+     * The arrays are of length [method@Pango.TabArray.get_size].
+     * You must free the returned array.
+     * @param alignments - location to store an array of tab
+     * @param locations - location to store an array
+     */
     getTabs(alignments?: Ref<TabAlign> | null, locations?: Ref<number[]> | null): void;
+    /**
+     * Resizes a tab array.
+     *
+     * You must subsequently initialize any tabs
+     * that were added as a result of growing the array.
+     * @param newSize - new size of the array
+     */
     resize(newSize: number): void;
+    /**
+     * Sets the Unicode character to use as decimal point.
+     *
+     * This is only relevant for tabs with %PANGO_TAB_DECIMAL alignment,
+     * which align content at the first occurrence of the decimal point
+     * character.
+     *
+     * By default, Pango uses the decimal point according
+     * to the current locale.
+     * @param tabIndex - the index of a tab stop
+     * @param decimalPoint - the decimal point to use
+     */
     setDecimalPoint(tabIndex: number, decimalPoint: number): void;
+    /**
+     * Sets whether positions in this array are specified in
+     * pixels.
+     * @param positionsInPixels - whether positions are in pixels
+     */
     setPositionsInPixels(positionsInPixels: boolean): void;
+    /**
+     * Sets the alignment and location of a tab stop.
+     * @param tabIndex - the index of a tab stop
+     * @param alignment - tab alignment
+     * @param location - tab location in Pango units
+     */
     setTab(tabIndex: number, alignment: TabAlign, location: number): void;
+    /**
+     * Utility function to ensure that the tab stops are in increasing order.
+     */
     sort(): void;
+    /**
+     * Serializes a `PangoTabArray` to a string.
+     *
+     * In the resulting string, serialized tabs are separated by newlines or commas.
+     *
+     * Individual tabs are serialized to a string of the form
+     *
+     * [ALIGNMENT:]POSITION[:DECIMAL_POINT]
+     *
+     * Where ALIGNMENT is one of _left_, _right_, _center_ or _decimal_, and
+     * POSITION is the position of the tab, optionally followed by the unit _px_.
+     * If ALIGNMENT is omitted, it defaults to _left_. If ALIGNMENT is _decimal_,
+     * the DECIMAL_POINT character may be specified as a Unicode codepoint.
+     *
+     * Note that all tabs in the array must use the same unit.
+     *
+     * A typical example:
+     *
+     * 100px 200px center:300px right:400px
+     */
     toString(): string;
 }