@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/pango/tab-array.js

@@ -1,5 +1,12 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * 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 class TabArray {
     ptr;
     constructor(...args) {
@@ -19,6 +26,13 @@ export class TabArray {
             },
         ], { type: "boxed", borrowed: true, innerType: "PangoTabArray" });
     }
+    /**
+     * 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) {
         const ptr = call("libpango-1.0.so.0", "pango_tab_array_from_string", [
             {
@@ -33,6 +47,9 @@ export class TabArray {
         });
         return getObject(ptr, TabArray);
     }
+    /**
+     * Copies a `PangoTabArray`.
+     */
     copy() {
         const ptr = call("libpango-1.0.so.0", "pango_tab_array_copy", [
             {
@@ -47,6 +64,9 @@ export class TabArray {
         });
         return getObject(ptr, TabArray);
     }
+    /**
+     * Frees a tab array and associated resources.
+     */
     free() {
         call("libpango-1.0.so.0", "pango_tab_array_free", [
             {
@@ -55,6 +75,17 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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) {
         return call("libpango-1.0.so.0", "pango_tab_array_get_decimal_point", [
             {
@@ -67,6 +98,10 @@ export class TabArray {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Returns %TRUE if the tab positions are in pixels,
+     * %FALSE if they are in Pango units.
+     */
     getPositionsInPixels() {
         return call("libpango-1.0.so.0", "pango_tab_array_get_positions_in_pixels", [
             {
@@ -75,6 +110,9 @@ export class TabArray {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the number of tab stops in @tab_array.
+     */
     getSize() {
         return call("libpango-1.0.so.0", "pango_tab_array_get_size", [
             {
@@ -83,6 +121,12 @@ export class TabArray {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * 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, alignment, location) {
         call("libpango-1.0.so.0", "pango_tab_array_get_tab", [
             {
@@ -111,6 +155,15 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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, locations) {
         call("libpango-1.0.so.0", "pango_tab_array_get_tabs", [
             {
@@ -138,6 +191,13 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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) {
         call("libpango-1.0.so.0", "pango_tab_array_resize", [
             {
@@ -150,6 +210,18 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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, decimalPoint) {
         call("libpango-1.0.so.0", "pango_tab_array_set_decimal_point", [
             {
@@ -166,6 +238,11 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether positions in this array are specified in
+     * pixels.
+     * @param positionsInPixels - whether positions are in pixels
+     */
     setPositionsInPixels(positionsInPixels) {
         call("libpango-1.0.so.0", "pango_tab_array_set_positions_in_pixels", [
             {
@@ -178,6 +255,12 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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, alignment, location) {
         call("libpango-1.0.so.0", "pango_tab_array_set_tab", [
             {
@@ -198,6 +281,9 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Utility function to ensure that the tab stops are in increasing order.
+     */
     sort() {
         call("libpango-1.0.so.0", "pango_tab_array_sort", [
             {
@@ -206,6 +292,26 @@ export class TabArray {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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() {
         return call("libpango-1.0.so.0", "pango_tab_array_to_string", [
             {

package/dist/generated/pangocairo/font-map.d.ts

@@ -1,10 +1,51 @@
 import * as cairo from "../cairo/index.js";
+/**
+ * `PangoCairoFontMap` is an interface exported by font maps for
+ * use with Cairo.
+ *
+ * The actual type of the font map will depend on the particular
+ * font technology Cairo was compiled to use.
+ */
 export declare class FontMap {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): FontMap;
+    /**
+     * Gets the type of Cairo font backend that `fontmap` uses.
+     */
     getFontType(): cairo.FontType;
+    /**
+     * Gets the resolution for the fontmap.
+     *
+     * See [method@PangoCairo.FontMap.set_resolution].
+     */
     getResolution(): number;
+    /**
+     * Sets a default `PangoCairoFontMap` to use with Cairo.
+     *
+     * This can be used to change the Cairo font backend that the
+     * default fontmap uses for example. The old default font map
+     * is unreffed and the new font map referenced.
+     *
+     * Note that since Pango 1.32.6, the default fontmap is per-thread.
+     * This function only changes the default fontmap for
+     * the current thread. Default fontmaps of existing threads
+     * are not changed. Default fontmaps of any new threads will
+     * still be created using [func@PangoCairo.FontMap.new].
+     *
+     * A value of %NULL for `fontmap` will cause the current default
+     * font map to be released and a new default font map to be created
+     * on demand, using [func@PangoCairo.FontMap.new].
+     */
     setDefault(): void;
+    /**
+     * Sets the resolution for the fontmap.
+     *
+     * This is a scale factor between
+     * points specified in a `PangoFontDescription` and Cairo units. The
+     * default value is 96, meaning that a 10 point font will be 13
+     * units high. (10 * 96. / 72. = 13.3).
+     * @param dpi - the resolution in "dots per inch". (Physical inches aren't actually
+     */
     setResolution(dpi: number): void;
 }

package/dist/generated/pangocairo/font-map.js

@@ -1,4 +1,11 @@
 import { call } from "@gtkx/native";
+/**
+ * `PangoCairoFontMap` is an interface exported by font maps for
+ * use with Cairo.
+ *
+ * The actual type of the font map will depend on the particular
+ * font technology Cairo was compiled to use.
+ */
 export class FontMap {
     ptr;
     constructor(ptr) {
@@ -7,6 +14,9 @@ export class FontMap {
     static fromPtr(ptr) {
         return new FontMap(ptr);
     }
+    /**
+     * Gets the type of Cairo font backend that `fontmap` uses.
+     */
     getFontType() {
         return call("libpangocairo-1.0.so.0", "pango_cairo_font_map_get_font_type", [
             {
@@ -15,6 +25,11 @@ export class FontMap {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the resolution for the fontmap.
+     *
+     * See [method@PangoCairo.FontMap.set_resolution].
+     */
     getResolution() {
         return call("libpangocairo-1.0.so.0", "pango_cairo_font_map_get_resolution", [
             {
@@ -23,6 +38,23 @@ export class FontMap {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Sets a default `PangoCairoFontMap` to use with Cairo.
+     *
+     * This can be used to change the Cairo font backend that the
+     * default fontmap uses for example. The old default font map
+     * is unreffed and the new font map referenced.
+     *
+     * Note that since Pango 1.32.6, the default fontmap is per-thread.
+     * This function only changes the default fontmap for
+     * the current thread. Default fontmaps of existing threads
+     * are not changed. Default fontmaps of any new threads will
+     * still be created using [func@PangoCairo.FontMap.new].
+     *
+     * A value of %NULL for `fontmap` will cause the current default
+     * font map to be released and a new default font map to be created
+     * on demand, using [func@PangoCairo.FontMap.new].
+     */
     setDefault() {
         call("libpangocairo-1.0.so.0", "pango_cairo_font_map_set_default", [
             {
@@ -31,6 +63,15 @@ export class FontMap {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the resolution for the fontmap.
+     *
+     * This is a scale factor between
+     * points specified in a `PangoFontDescription` and Cairo units. The
+     * default value is 96, meaning that a 10 point font will be 13
+     * units high. (10 * 96. / 72. = 13.3).
+     * @param dpi - the resolution in "dots per inch". (Physical inches aren't actually
+     */
     setResolution(dpi) {
         call("libpangocairo-1.0.so.0", "pango_cairo_font_map_set_resolution", [
             {

package/dist/generated/pangocairo/font.d.ts

@@ -1,7 +1,19 @@
 import * as cairo from "../cairo/index.js";
+/**
+ * `PangoCairoFont` is an interface exported by fonts for
+ * use with Cairo.
+ *
+ * The actual type of the font will depend on the particular
+ * font technology Cairo was compiled to use.
+ */
 export declare class Font {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Font;
+    /**
+     * Gets the `cairo_scaled_font_t` used by @font.
+     * The scaled font can be referenced and kept using
+     * cairo_scaled_font_reference().
+     */
     getScaledFont(): cairo.ScaledFont | null;
 }

package/dist/generated/pangocairo/font.js

@@ -1,6 +1,13 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as cairo from "../cairo/index.js";
+/**
+ * `PangoCairoFont` is an interface exported by fonts for
+ * use with Cairo.
+ *
+ * The actual type of the font will depend on the particular
+ * font technology Cairo was compiled to use.
+ */
 export class Font {
     ptr;
     constructor(ptr) {
@@ -9,6 +16,11 @@ export class Font {
     static fromPtr(ptr) {
         return new Font(ptr);
     }
+    /**
+     * Gets the `cairo_scaled_font_t` used by @font.
+     * The scaled font can be referenced and kept using
+     * cairo_scaled_font_reference().
+     */
     getScaledFont() {
         const ptr = call("libpangocairo-1.0.so.0", "pango_cairo_font_get_scaled_font", [
             {

package/dist/generated/pangocairo/functions.d.ts

@@ -1,23 +1,250 @@
 import * as Pango from "../pango/index.js";
 import * as cairo from "../cairo/index.js";
+/**
+ * Retrieves any font rendering options previously set with
+ * [func@PangoCairo.context_set_font_options].
+ *
+ * This function does not report options that are derived from
+ * the target surface by [func@update_context].
+ * @param context - a `PangoContext`, from a pangocairo font map
+ */
 export declare const contextGetFontOptions: (context: Pango.Context) => cairo.FontOptions | null;
+/**
+ * Gets the resolution for the context.
+ *
+ * See [func@PangoCairo.context_set_resolution]
+ * @param context - a `PangoContext`, from a pangocairo font map
+ */
 export declare const contextGetResolution: (context: Pango.Context) => number;
+/**
+ * Sets the font options used when rendering text with this context.
+ *
+ * These options override any options that [func@update_context]
+ * derives from the target surface.
+ * @param context - a `PangoContext`, from a pangocairo font map
+ * @param options - a `cairo_font_options_t`, or %NULL to unset
+ */
 export declare const contextSetFontOptions: (context: Pango.Context, options?: cairo.FontOptions | null) => void;
+/**
+ * Sets the resolution for the context.
+ *
+ * This is a scale factor between points specified in a `PangoFontDescription`
+ * and Cairo units. The default value is 96, meaning that a 10 point font will
+ * be 13 units high. (10 * 96. / 72. = 13.3).
+ * @param context - a `PangoContext`, from a pangocairo font map
+ * @param dpi - the resolution in "dots per inch". (Physical inches aren't actually
+ */
 export declare const contextSetResolution: (context: Pango.Context, dpi: number) => void;
+/**
+ * Sets callback function for context to use for rendering attributes
+ * of type %PANGO_ATTR_SHAPE.
+ *
+ * See `PangoCairoShapeRendererFunc` for details.
+ * @param context - a `PangoContext`, from a pangocairo font map
+ * @param func - Callback function for rendering attributes of
+ * @param data - User data that will be passed to @func.
+ * @param dnotify - Callback that will be called when the
+ */
 export declare const contextSetShapeRenderer: (context: Pango.Context, func?: (...args: unknown[]) => unknown | null, data?: number | null, dnotify?: () => void | null) => void;
+/**
+ * Creates a context object set up to match the current transformation
+ * and target surface of the Cairo context.
+ *
+ * This context can then be
+ * used to create a layout using [ctor@Pango.Layout.new].
+ *
+ * This function is a convenience function that creates a context using
+ * the default font map, then updates it to @cr. If you just need to
+ * create a layout for use with `cr` and do not need to access `PangoContext`
+ * directly, you can use [func@create_layout] instead.
+ * @param cr - a Cairo context
+ */
 export declare const createContext: (cr: cairo.Context) => Pango.Context;
+/**
+ * Creates a layout object set up to match the current transformation
+ * and target surface of the Cairo context.
+ *
+ * This layout can then be used for text measurement with functions
+ * like [method@Pango.Layout.get_size] or drawing with functions like
+ * [func@show_layout]. If you change the transformation or target
+ * surface for @cr, you need to call [func@update_layout].
+ *
+ * This function is the most convenient way to use Cairo with Pango,
+ * however it is slightly inefficient since it creates a separate
+ * `PangoContext` object for each layout. This might matter in an
+ * application that was laying out large amounts of text.
+ * @param cr - a Cairo context
+ */
 export declare const createLayout: (cr: cairo.Context) => Pango.Layout;
+/**
+ * Add a squiggly line to the current path in the specified cairo context 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.
+ * @param cr - a Cairo context
+ * @param x - The X coordinate of one corner of the rectangle
+ * @param y - The Y coordinate of one corner of the rectangle
+ * @param width - Non-negative width of the rectangle
+ * @param height - Non-negative height of the rectangle
+ */
 export declare const errorUnderlinePath: (cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Gets a default `PangoCairoFontMap` to use with Cairo.
+ *
+ * Note that the type of the returned object will depend on the
+ * particular font backend Cairo was compiled to use; you generally
+ * should only use the `PangoFontMap` and `PangoCairoFontMap`
+ * interfaces on the returned object.
+ *
+ * The default Cairo fontmap can be changed by using
+ * [method@PangoCairo.FontMap.set_default]. This can be used to
+ * change the Cairo font backend that the default fontmap uses
+ * for example.
+ *
+ * Note that since Pango 1.32.6, the default fontmap is per-thread.
+ * Each thread gets its own default fontmap. In this way, PangoCairo
+ * can be used safely from multiple threads.
+ */
 export declare const fontMapGetDefault: () => Pango.FontMap;
+/**
+ * Creates a new `PangoCairoFontMap` object.
+ *
+ * A fontmap is used to cache information about available fonts,
+ * and holds certain global parameters such as the resolution.
+ * In most cases, you can use `func@PangoCairo.font_map_get_default]
+ * instead.
+ *
+ * Note that the type of the returned object will depend
+ * on the particular font backend Cairo was compiled to use;
+ * You generally should only use the `PangoFontMap` and
+ * `PangoCairoFontMap` interfaces on the returned object.
+ *
+ * You can override the type of backend returned by using an
+ * environment variable %PANGOCAIRO_BACKEND. Supported types,
+ * based on your build, are fc (fontconfig), win32, and coretext.
+ * If requested type is not available, NULL is returned. Ie.
+ * this is only useful for testing, when at least two backends
+ * are compiled in.
+ */
 export declare const fontMapNew: () => Pango.FontMap;
+/**
+ * Creates a new `PangoCairoFontMap` object of the type suitable
+ * to be used with cairo font backend of type @fonttype.
+ *
+ * In most cases one should simply use [func@PangoCairo.FontMap.new], or
+ * in fact in most of those cases, just use [func@PangoCairo.FontMap.get_default].
+ * @param fonttype - desired #cairo_font_type_t
+ */
 export declare const fontMapNewForFontType: (fonttype: cairo.FontType) => Pango.FontMap | null;
+/**
+ * Adds the glyphs in `glyphs` to the current path in the specified
+ * cairo context.
+ *
+ * The origin of the glyphs (the left edge of the baseline)
+ * will be at the current point of the cairo context.
+ * @param cr - a Cairo context
+ * @param font - a `PangoFont` from a `PangoCairoFontMap`
+ * @param glyphs - a `PangoGlyphString`
+ */
 export declare const glyphStringPath: (cr: cairo.Context, font: Pango.Font, glyphs: Pango.GlyphString) => void;
+/**
+ * Adds the text in `PangoLayoutLine` to the current path in the
+ * specified cairo context.
+ *
+ * The origin of the glyphs (the left edge of the line) will be
+ * at the current point of the cairo context.
+ * @param cr - a Cairo context
+ * @param line - a `PangoLayoutLine`
+ */
 export declare const layoutLinePath: (cr: cairo.Context, line: Pango.LayoutLine) => void;
+/**
+ * Adds the text in a `PangoLayout` to the current path in the
+ * specified cairo context.
+ *
+ * The top-left corner of the `PangoLayout` will be at the
+ * current point of the cairo context.
+ * @param cr - a Cairo context
+ * @param layout - a Pango layout
+ */
 export declare const layoutPath: (cr: cairo.Context, layout: Pango.Layout) => void;
+/**
+ * Draw a squiggly line in the specified cairo context 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.
+ * @param cr - a Cairo context
+ * @param x - The X coordinate of one corner of the rectangle
+ * @param y - The Y coordinate of one corner of the rectangle
+ * @param width - Non-negative width of the rectangle
+ * @param height - Non-negative height of the rectangle
+ */
 export declare const showErrorUnderline: (cr: cairo.Context, x: number, y: number, width: number, height: number) => void;
+/**
+ * Draws the glyphs in `glyph_item` in the specified cairo context,
+ *
+ * embedding the text associated with the glyphs in the output if the
+ * output format supports it (PDF for example), otherwise it acts
+ * similar to [func@show_glyph_string].
+ *
+ * The origin of the glyphs (the left edge of the baseline) will
+ * be drawn at the current point of the cairo context.
+ *
+ * Note that `text` is the start of the text for layout, which is then
+ * indexed by `glyph_item->item->offset`.
+ * @param cr - a Cairo context
+ * @param text - the UTF-8 text that `glyph_item` refers to
+ * @param glyphItem - a `PangoGlyphItem`
+ */
 export declare const showGlyphItem: (cr: cairo.Context, text: string, glyphItem: Pango.GlyphItem) => void;
+/**
+ * Draws the glyphs in `glyphs` in the specified cairo context.
+ *
+ * The origin of the glyphs (the left edge of the baseline) will
+ * be drawn at the current point of the cairo context.
+ * @param cr - a Cairo context
+ * @param font - a `PangoFont` from a `PangoCairoFontMap`
+ * @param glyphs - a `PangoGlyphString`
+ */
 export declare const showGlyphString: (cr: cairo.Context, font: Pango.Font, glyphs: Pango.GlyphString) => void;
+/**
+ * Draws a `PangoLayout` in the specified cairo context.
+ *
+ * The top-left corner of the `PangoLayout` will be drawn
+ * at the current point of the cairo context.
+ * @param cr - a Cairo context
+ * @param layout - a Pango layout
+ */
 export declare const showLayout: (cr: cairo.Context, layout: Pango.Layout) => void;
+/**
+ * Draws a `PangoLayoutLine` in the specified cairo context.
+ *
+ * The origin of the glyphs (the left edge of the line) will
+ * be drawn at the current point of the cairo context.
+ * @param cr - a Cairo context
+ * @param line - a `PangoLayoutLine`
+ */
 export declare const showLayoutLine: (cr: cairo.Context, line: Pango.LayoutLine) => void;
+/**
+ * Updates a `PangoContext` previously created for use with Cairo to
+ * match the current transformation and target surface of a Cairo
+ * context.
+ *
+ * If any layouts have been created for the context, it's necessary
+ * to call [method@Pango.Layout.context_changed] on those layouts.
+ * @param cr - a Cairo context
+ * @param context - a `PangoContext`, from a pangocairo font map
+ */
 export declare const updateContext: (cr: cairo.Context, context: Pango.Context) => void;
+/**
+ * Updates the private `PangoContext` of a `PangoLayout` created with
+ * [func@create_layout] to match the current transformation and target
+ * surface of a Cairo context.
+ * @param cr - a Cairo context
+ * @param layout - a `PangoLayout`, from [func@create_layout]
+ */
 export declare const updateLayout: (cr: cairo.Context, layout: Pango.Layout) => void;