@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/pango/language.js

@@ -1,5 +1,12 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * The `PangoLanguage` structure is used to
+ * represent a language.
+ *
+ * `PangoLanguage` pointers can be efficiently
+ * copied and compared with each other.
+ */
 export class Language {
     ptr;
     constructor() {
@@ -8,6 +15,21 @@ export class Language {
     createPtr(_init) {
         return null;
     }
+    /**
+     * Convert a language tag to a `PangoLanguage`.
+     *
+     * The language tag must be in a RFC-3066 format. `PangoLanguage` pointers
+     * can be efficiently copied (copy the pointer) and compared with other
+     * language tags (compare the pointer.)
+     *
+     * This function first canonicalizes the string by converting it to
+     * lowercase, mapping '_' to '-', and stripping all characters other
+     * than letters and '-'.
+     *
+     * Use [func@Pango.Language.get_default] if you want to get the
+     * `PangoLanguage` for the current locale of the process.
+     * @param language - a string representing a language tag
+     */
     static fromString(language) {
         const ptr = call("libpango-1.0.so.0", "pango_language_from_string", [
             {
@@ -23,6 +45,39 @@ export class Language {
         });
         return getObject(ptr, Language);
     }
+    /**
+     * Returns the `PangoLanguage` for the current locale of the process.
+     *
+     * On Unix systems, this is the return value is derived from
+     * `setlocale (LC_CTYPE, NULL)`, and the user can
+     * affect this through the environment variables LC_ALL, LC_CTYPE or
+     * LANG (checked in that order). The locale string typically is in
+     * the form lang_COUNTRY, where lang is an ISO-639 language code, and
+     * COUNTRY is an ISO-3166 country code. For instance, sv_FI for
+     * Swedish as written in Finland or pt_BR for Portuguese as written in
+     * Brazil.
+     *
+     * On Windows, the C library does not use any such environment
+     * variables, and setting them won't affect the behavior of functions
+     * like ctime(). The user sets the locale through the Regional Options
+     * in the Control Panel. The C library (in the setlocale() function)
+     * does not use country and language codes, but country and language
+     * names spelled out in English.
+     * However, this function does check the above environment
+     * variables, and does return a Unix-style locale string based on
+     * either said environment variables or the thread's current locale.
+     *
+     * Your application should call `setlocale(LC_ALL, "")` for the user
+     * settings to take effect. GTK does this in its initialization
+     * functions automatically (by calling gtk_set_locale()).
+     * See the setlocale() manpage for more details.
+     *
+     * Note that the default language can change over the life of an application.
+     *
+     * Also note that this function will not do the right thing if you
+     * use per-thread locales with uselocale(). In that case, you should
+     * just call pango_language_from_string() yourself.
+     */
     static getDefault() {
         const ptr = call("libpango-1.0.so.0", "pango_language_get_default", [], {
             type: "boxed",
@@ -32,6 +87,19 @@ export class Language {
         });
         return getObject(ptr, Language);
     }
+    /**
+     * Returns the list of languages that the user prefers.
+     *
+     * The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
+     * environment variables, in order of preference. Note that this
+     * list does not necessarily include the language returned by
+     * [func@Pango.Language.get_default].
+     *
+     * When choosing language-specific resources, such as the sample
+     * text returned by [method@Pango.Language.get_sample_string],
+     * you should first try the default language, followed by the
+     * languages returned by this function.
+     */
     static getPreferred() {
         return call("libpango-1.0.so.0", "pango_language_get_preferred", [], {
             type: "array",
@@ -42,6 +110,27 @@ export class Language {
             },
         });
     }
+    /**
+     * Get a string that is representative of the characters needed to
+     * render a particular language.
+     *
+     * The sample text may be a pangram, but is not necessarily. It is chosen
+     * to be demonstrative of normal text in the language, as well as exposing
+     * font feature requirements unique to the language. It is suitable for use
+     * as sample text in a font selection dialog.
+     *
+     * If `language` is %NULL, the default language as found by
+     * [func@Pango.Language.get_default] is used.
+     *
+     * If Pango does not have a sample string for @language, the classic
+     * "The quick brown fox..." is returned.  This can be detected by
+     * comparing the returned pointer value to that returned for (non-existent)
+     * language code "xx".  That is, compare to:
+     *
+     * ```
+     * pango_language_get_sample_string (pango_language_from_string ("xx"))
+     * ```
+     */
     getSampleString() {
         return call("libpango-1.0.so.0", "pango_language_get_sample_string", [
             {
@@ -50,6 +139,32 @@ export class Language {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Determines the scripts used to to write @language.
+     *
+     * If nothing is known about the language tag @language,
+     * or if `language` is %NULL, then %NULL is returned.
+     * The list of scripts returned starts with the script that the
+     * language uses most and continues to the one it uses least.
+     *
+     * The value `num_script` points at will be set to the number
+     * of scripts in the returned array (or zero if %NULL is returned).
+     *
+     * Most languages use only one script for writing, but there are
+     * some that use two (Latin and Cyrillic for example), and a few
+     * use three (Japanese for example). Applications should not make
+     * any assumptions on the maximum number of scripts returned
+     * though, except that it is positive if the return value is not
+     * %NULL, and it is a small number.
+     *
+     * The [method@Pango.Language.includes_script] function uses this
+     * function internally.
+     *
+     * Note: while the return value is declared as `PangoScript`, the
+     * returned values are from the `GUnicodeScript` enumeration, which
+     * may have more values. Callers need to handle unknown values.
+     * @param numScripts - location to return number of scripts
+     */
     getScripts(numScripts) {
         return call("libpango-1.0.so.0", "pango_language_get_scripts", [
             {
@@ -66,6 +181,22 @@ export class Language {
             },
         ], { type: "array", itemType: { type: "int", size: 32, unsigned: false } });
     }
+    /**
+     * Determines if `script` is one of the scripts used to
+     * write @language.
+     *
+     * The returned value is conservative; if nothing is known about
+     * the language tag @language, %TRUE will be returned, since, as
+     * far as Pango knows, `script` might be used to write @language.
+     *
+     * This routine is used in Pango's itemization process when
+     * determining if a supplied language tag is relevant to
+     * a particular section of text. It probably is not useful
+     * for applications in most circumstances.
+     *
+     * This function uses [method@Pango.Language.get_scripts] internally.
+     * @param script - a `PangoScript`
+     */
     includesScript(script) {
         return call("libpango-1.0.so.0", "pango_language_includes_script", [
             {
@@ -78,6 +209,15 @@ export class Language {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if a language tag matches one of the elements in a list of
+     * language ranges.
+     *
+     * A language tag is considered to match a range in the list if the
+     * range is '*', the range is exactly the tag, or the range is a prefix
+     * of the tag, and the character after it in the tag is '-'.
+     * @param rangeList - a list of language ranges, separated by ';', ':',
+     */
     matches(rangeList) {
         return call("libpango-1.0.so.0", "pango_language_matches", [
             {
@@ -90,6 +230,11 @@ export class Language {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the RFC-3066 format string representing the given language tag.
+     *
+     * Returns (transfer none): a string representing the language tag
+     */
     toString() {
         return call("libpango-1.0.so.0", "pango_language_to_string", [
             {

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

@@ -1,29 +1,182 @@
 import { Ref } from "@gtkx/native";
 import { LayoutLine } from "./layout-line.js";
 import { Layout } from "./layout.js";
+/**
+ * A `PangoLayoutIter` can be used to iterate over the visual
+ * extents of a `PangoLayout`.
+ *
+ * To obtain a `PangoLayoutIter`, use [method@Pango.Layout.get_iter].
+ *
+ * The `PangoLayoutIter` structure is opaque, and has no user-visible fields.
+ */
 export declare class LayoutIter {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /**
+     * Determines whether `iter` is on the last line of the layout.
+     */
     atLastLine(): boolean;
+    /**
+     * Copies a `PangoLayoutIter`.
+     */
     copy(): LayoutIter | null;
+    /**
+     * Frees an iterator that's no longer in use.
+     */
     free(): void;
+    /**
+     * Gets the Y position of the current line's baseline, in layout
+     * coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     */
     getBaseline(): number;
+    /**
+     * Gets the extents of the current character, in layout coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     *
+     * Only logical extents can sensibly be obtained for characters;
+     * ink extents make sense only down to the level of clusters.
+     * @param logicalRect - rectangle to fill with
+     */
     getCharExtents(logicalRect: Ref<number>): void;
+    /**
+     * Gets the extents of the current cluster, in layout coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getClusterExtents(inkRect?: Ref<number> | null, logicalRect?: Ref<number> | null): void;
+    /**
+     * Gets the current byte index.
+     *
+     * Note that iterating forward by char moves in visual order,
+     * not logical order, so indexes may not be sequential. Also,
+     * the index may be equal to the length of the text in the
+     * layout, if on the %NULL run (see [method@Pango.LayoutIter.get_run]).
+     */
     getIndex(): number;
+    /**
+     * Gets the layout associated with a `PangoLayoutIter`.
+     */
     getLayout(): Layout | null;
+    /**
+     * Obtains the extents of the `PangoLayout` being iterated over.
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getLayoutExtents(inkRect?: Ref<number> | null, logicalRect?: Ref<number> | null): void;
+    /**
+     * Gets the current line.
+     *
+     * Use the faster [method@Pango.LayoutIter.get_line_readonly] if
+     * you do not plan to modify the contents of the line (glyphs,
+     * glyph widths, etc.).
+     */
     getLine(): LayoutLine | null;
+    /**
+     * Obtains the extents of the current line.
+     *
+     * Extents are in layout coordinates (origin is the top-left corner
+     * of the entire `PangoLayout`). Thus the extents returned by this
+     * function will be the same width/height but not at the same x/y
+     * as the extents returned from [method@Pango.LayoutLine.get_extents].
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getLineExtents(inkRect?: Ref<number> | null, logicalRect?: Ref<number> | null): void;
+    /**
+     * Gets the current line for read-only access.
+     *
+     * This is a faster alternative to [method@Pango.LayoutIter.get_line],
+     * but the user is not expected to modify the contents of the line
+     * (glyphs, glyph widths, etc.).
+     */
     getLineReadonly(): LayoutLine | null;
+    /**
+     * Divides the vertical space in the `PangoLayout` being iterated over
+     * between the lines in the layout, and returns the space belonging to
+     * the current line.
+     *
+     * A line's range includes the line's logical extents. plus half of the
+     * spacing above and below the line, if [method@Pango.Layout.set_spacing]
+     * has been called to set layout spacing. The Y positions are in layout
+     * coordinates (origin at top left of the entire layout).
+     *
+     * Note: Since 1.44, Pango uses line heights for placing lines, and there
+     * may be gaps between the ranges returned by this function.
+     * @param y0_ - start of line
+     * @param y1_ - end of line
+     */
     getLineYrange(y0_?: Ref<number> | null, y1_?: Ref<number> | null): void;
+    /**
+     * Gets the current run.
+     *
+     * When iterating by run, at the end of each line, there's a position
+     * with a %NULL run, so this function can return %NULL. The %NULL run
+     * at the end of each line ensures that all lines have at least one run,
+     * even lines consisting of only a newline.
+     *
+     * Use the faster [method@Pango.LayoutIter.get_run_readonly] if you do not
+     * plan to modify the contents of the run (glyphs, glyph widths, etc.).
+     */
     getRun(): number | null;
+    /**
+     * Gets the Y position of the current run's baseline, in layout
+     * coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     *
+     * The run baseline can be different from the line baseline, for
+     * example due to superscript or subscript positioning.
+     */
     getRunBaseline(): number;
+    /**
+     * Gets the extents of the current run in layout coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getRunExtents(inkRect?: Ref<number> | null, logicalRect?: Ref<number> | null): void;
+    /**
+     * Gets the current run for read-only access.
+     *
+     * When iterating by run, at the end of each line, there's a position
+     * with a %NULL run, so this function can return %NULL. The %NULL run
+     * at the end of each line ensures that all lines have at least one run,
+     * even lines consisting of only a newline.
+     *
+     * This is a faster alternative to [method@Pango.LayoutIter.get_run],
+     * but the user is not expected to modify the contents of the run (glyphs,
+     * glyph widths, etc.).
+     */
     getRunReadonly(): number | null;
+    /**
+     * Moves `iter` forward to the next character in visual order.
+     *
+     * If `iter` was already at the end of the layout, returns %FALSE.
+     */
     nextChar(): boolean;
+    /**
+     * Moves `iter` forward to the next cluster in visual order.
+     *
+     * If `iter` was already at the end of the layout, returns %FALSE.
+     */
     nextCluster(): boolean;
+    /**
+     * Moves `iter` forward to the start of the next line.
+     *
+     * If `iter` is already on the last line, returns %FALSE.
+     */
     nextLine(): boolean;
+    /**
+     * Moves `iter` forward to the next run in visual order.
+     *
+     * If `iter` was already at the end of the layout, returns %FALSE.
+     */
     nextRun(): boolean;
 }

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

@@ -2,6 +2,14 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { LayoutLine } from "./layout-line.js";
 import { Layout } from "./layout.js";
+/**
+ * A `PangoLayoutIter` can be used to iterate over the visual
+ * extents of a `PangoLayout`.
+ *
+ * To obtain a `PangoLayoutIter`, use [method@Pango.Layout.get_iter].
+ *
+ * The `PangoLayoutIter` structure is opaque, and has no user-visible fields.
+ */
 export class LayoutIter {
     ptr;
     constructor() {
@@ -10,6 +18,9 @@ export class LayoutIter {
     createPtr(_init) {
         return null;
     }
+    /**
+     * Determines whether `iter` is on the last line of the layout.
+     */
     atLastLine() {
         return call("libpango-1.0.so.0", "pango_layout_iter_at_last_line", [
             {
@@ -18,6 +29,9 @@ export class LayoutIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Copies a `PangoLayoutIter`.
+     */
     copy() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_iter_copy", [
             {
@@ -34,6 +48,9 @@ export class LayoutIter {
             return null;
         return getObject(ptr, LayoutIter);
     }
+    /**
+     * Frees an iterator that's no longer in use.
+     */
     free() {
         call("libpango-1.0.so.0", "pango_layout_iter_free", [
             {
@@ -42,6 +59,12 @@ export class LayoutIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the Y position of the current line's baseline, in layout
+     * coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     */
     getBaseline() {
         return call("libpango-1.0.so.0", "pango_layout_iter_get_baseline", [
             {
@@ -50,6 +73,15 @@ export class LayoutIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the extents of the current character, in layout coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     *
+     * Only logical extents can sensibly be obtained for characters;
+     * ink extents make sense only down to the level of clusters.
+     * @param logicalRect - rectangle to fill with
+     */
     getCharExtents(logicalRect) {
         call("libpango-1.0.so.0", "pango_layout_iter_get_char_extents", [
             {
@@ -65,6 +97,13 @@ export class LayoutIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the extents of the current cluster, in layout coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getClusterExtents(inkRect, logicalRect) {
         call("libpango-1.0.so.0", "pango_layout_iter_get_cluster_extents", [
             {
@@ -89,6 +128,14 @@ export class LayoutIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the current byte index.
+     *
+     * Note that iterating forward by char moves in visual order,
+     * not logical order, so indexes may not be sequential. Also,
+     * the index may be equal to the length of the text in the
+     * layout, if on the %NULL run (see [method@Pango.LayoutIter.get_run]).
+     */
     getIndex() {
         return call("libpango-1.0.so.0", "pango_layout_iter_get_index", [
             {
@@ -97,6 +144,9 @@ export class LayoutIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the layout associated with a `PangoLayoutIter`.
+     */
     getLayout() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_iter_get_layout", [
             {
@@ -108,6 +158,11 @@ export class LayoutIter {
             return null;
         return getObject(ptr, Layout);
     }
+    /**
+     * Obtains the extents of the `PangoLayout` being iterated over.
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getLayoutExtents(inkRect, logicalRect) {
         call("libpango-1.0.so.0", "pango_layout_iter_get_layout_extents", [
             {
@@ -132,6 +187,13 @@ export class LayoutIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the current line.
+     *
+     * Use the faster [method@Pango.LayoutIter.get_line_readonly] if
+     * you do not plan to modify the contents of the line (glyphs,
+     * glyph widths, etc.).
+     */
     getLine() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_iter_get_line", [
             {
@@ -148,6 +210,16 @@ export class LayoutIter {
             return null;
         return getObject(ptr, LayoutLine);
     }
+    /**
+     * Obtains the extents of the current line.
+     *
+     * Extents are in layout coordinates (origin is the top-left corner
+     * of the entire `PangoLayout`). Thus the extents returned by this
+     * function will be the same width/height but not at the same x/y
+     * as the extents returned from [method@Pango.LayoutLine.get_extents].
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getLineExtents(inkRect, logicalRect) {
         call("libpango-1.0.so.0", "pango_layout_iter_get_line_extents", [
             {
@@ -172,6 +244,13 @@ export class LayoutIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the current line for read-only access.
+     *
+     * This is a faster alternative to [method@Pango.LayoutIter.get_line],
+     * but the user is not expected to modify the contents of the line
+     * (glyphs, glyph widths, etc.).
+     */
     getLineReadonly() {
         const ptr = call("libpango-1.0.so.0", "pango_layout_iter_get_line_readonly", [
             {
@@ -188,6 +267,21 @@ export class LayoutIter {
             return null;
         return getObject(ptr, LayoutLine);
     }
+    /**
+     * Divides the vertical space in the `PangoLayout` being iterated over
+     * between the lines in the layout, and returns the space belonging to
+     * the current line.
+     *
+     * A line's range includes the line's logical extents. plus half of the
+     * spacing above and below the line, if [method@Pango.Layout.set_spacing]
+     * has been called to set layout spacing. The Y positions are in layout
+     * coordinates (origin at top left of the entire layout).
+     *
+     * Note: Since 1.44, Pango uses line heights for placing lines, and there
+     * may be gaps between the ranges returned by this function.
+     * @param y0_ - start of line
+     * @param y1_ - end of line
+     */
     getLineYrange(y0_, y1_) {
         call("libpango-1.0.so.0", "pango_layout_iter_get_line_yrange", [
             {
@@ -212,6 +306,17 @@ export class LayoutIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the current run.
+     *
+     * When iterating by run, at the end of each line, there's a position
+     * with a %NULL run, so this function can return %NULL. The %NULL run
+     * at the end of each line ensures that all lines have at least one run,
+     * even lines consisting of only a newline.
+     *
+     * Use the faster [method@Pango.LayoutIter.get_run_readonly] if you do not
+     * plan to modify the contents of the run (glyphs, glyph widths, etc.).
+     */
     getRun() {
         return call("libpango-1.0.so.0", "pango_layout_iter_get_run", [
             {
@@ -220,6 +325,15 @@ export class LayoutIter {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the Y position of the current run's baseline, in layout
+     * coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     *
+     * The run baseline can be different from the line baseline, for
+     * example due to superscript or subscript positioning.
+     */
     getRunBaseline() {
         return call("libpango-1.0.so.0", "pango_layout_iter_get_run_baseline", [
             {
@@ -228,6 +342,13 @@ export class LayoutIter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the extents of the current run in layout coordinates.
+     *
+     * Layout coordinates have the origin at the top left of the entire layout.
+     * @param inkRect - rectangle to fill with ink extents
+     * @param logicalRect - rectangle to fill with logical extents
+     */
     getRunExtents(inkRect, logicalRect) {
         call("libpango-1.0.so.0", "pango_layout_iter_get_run_extents", [
             {
@@ -252,6 +373,18 @@ export class LayoutIter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the current run for read-only access.
+     *
+     * When iterating by run, at the end of each line, there's a position
+     * with a %NULL run, so this function can return %NULL. The %NULL run
+     * at the end of each line ensures that all lines have at least one run,
+     * even lines consisting of only a newline.
+     *
+     * This is a faster alternative to [method@Pango.LayoutIter.get_run],
+     * but the user is not expected to modify the contents of the run (glyphs,
+     * glyph widths, etc.).
+     */
     getRunReadonly() {
         return call("libpango-1.0.so.0", "pango_layout_iter_get_run_readonly", [
             {
@@ -260,6 +393,11 @@ export class LayoutIter {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Moves `iter` forward to the next character in visual order.
+     *
+     * If `iter` was already at the end of the layout, returns %FALSE.
+     */
     nextChar() {
         return call("libpango-1.0.so.0", "pango_layout_iter_next_char", [
             {
@@ -268,6 +406,11 @@ export class LayoutIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` forward to the next cluster in visual order.
+     *
+     * If `iter` was already at the end of the layout, returns %FALSE.
+     */
     nextCluster() {
         return call("libpango-1.0.so.0", "pango_layout_iter_next_cluster", [
             {
@@ -276,6 +419,11 @@ export class LayoutIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` forward to the start of the next line.
+     *
+     * If `iter` is already on the last line, returns %FALSE.
+     */
     nextLine() {
         return call("libpango-1.0.so.0", "pango_layout_iter_next_line", [
             {
@@ -284,6 +432,11 @@ export class LayoutIter {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Moves `iter` forward to the next run in visual order.
+     *
+     * If `iter` was already at the end of the layout, returns %FALSE.
+     */
     nextRun() {
         return call("libpango-1.0.so.0", "pango_layout_iter_next_run", [
             {