@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gsk/enums.js

@@ -1,148 +1,461 @@
+/**
+ * The blend modes available for render nodes.
+ *
+ * The implementation of each blend mode is deferred to the
+ * rendering pipeline.
+ *
+ * See <https://www.w3.org/TR/compositing-1/#blending> for more information
+ * on blending and blend modes.
+ */
 export var BlendMode;
 (function (BlendMode) {
+    /** The default blend mode, which specifies no blending */
     BlendMode[BlendMode["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * The source color is multiplied by the destination
+     * and replaces the destination
+     */
     BlendMode[BlendMode["MULTIPLY"] = 1] = "MULTIPLY";
+    /**
+     * Multiplies the complements of the destination and source
+     * color values, then complements the result.
+     */
     BlendMode[BlendMode["SCREEN"] = 2] = "SCREEN";
+    /**
+     * Multiplies or screens the colors, depending on the
+     * destination color value. This is the inverse of hard-list
+     */
     BlendMode[BlendMode["OVERLAY"] = 3] = "OVERLAY";
+    /** Selects the darker of the destination and source colors */
     BlendMode[BlendMode["DARKEN"] = 4] = "DARKEN";
+    /** Selects the lighter of the destination and source colors */
     BlendMode[BlendMode["LIGHTEN"] = 5] = "LIGHTEN";
+    /** Brightens the destination color to reflect the source color */
     BlendMode[BlendMode["COLOR_DODGE"] = 6] = "COLOR_DODGE";
+    /** Darkens the destination color to reflect the source color */
     BlendMode[BlendMode["COLOR_BURN"] = 7] = "COLOR_BURN";
+    /** Multiplies or screens the colors, depending on the source color value */
     BlendMode[BlendMode["HARD_LIGHT"] = 8] = "HARD_LIGHT";
+    /** Darkens or lightens the colors, depending on the source color value */
     BlendMode[BlendMode["SOFT_LIGHT"] = 9] = "SOFT_LIGHT";
+    /** Subtracts the darker of the two constituent colors from the lighter color */
     BlendMode[BlendMode["DIFFERENCE"] = 10] = "DIFFERENCE";
+    /** Produces an effect similar to that of the difference mode but lower in contrast */
     BlendMode[BlendMode["EXCLUSION"] = 11] = "EXCLUSION";
+    /**
+     * Creates a color with the hue and saturation of the source color and the luminosity of the destination color
+     */
     BlendMode[BlendMode["COLOR"] = 12] = "COLOR";
+    /**
+     * Creates a color with the hue of the source color and the saturation and luminosity of the destination color
+     */
     BlendMode[BlendMode["HUE"] = 13] = "HUE";
+    /**
+     * Creates a color with the saturation of the source color and the hue and luminosity of the destination color
+     */
     BlendMode[BlendMode["SATURATION"] = 14] = "SATURATION";
+    /**
+     * Creates a color with the luminosity of the source color and the hue and saturation of the destination color
+     */
     BlendMode[BlendMode["LUMINOSITY"] = 15] = "LUMINOSITY";
 })(BlendMode || (BlendMode = {}));
+/** The corner indices used by `GskRoundedRect`. */
 export var Corner;
 (function (Corner) {
+    /** The top left corner */
     Corner[Corner["TOP_LEFT"] = 0] = "TOP_LEFT";
+    /** The top right corner */
     Corner[Corner["TOP_RIGHT"] = 1] = "TOP_RIGHT";
+    /** The bottom right corner */
     Corner[Corner["BOTTOM_RIGHT"] = 2] = "BOTTOM_RIGHT";
+    /** The bottom left corner */
     Corner[Corner["BOTTOM_LEFT"] = 3] = "BOTTOM_LEFT";
 })(Corner || (Corner = {}));
+/**
+ * Specifies how paths are filled.
+ *
+ * Whether or not a point is included in the fill is determined by taking
+ * a ray from that point to infinity and looking at intersections with the
+ * path. The ray can be in any direction, as long as it doesn't pass through
+ * the end point of a segment or have a tricky intersection such as
+ * intersecting tangent to the path.
+ *
+ * (Note that filling is not actually implemented in this way. This
+ * is just a description of the rule that is applied.)
+ *
+ * New entries may be added in future versions.
+ */
 export var FillRule;
 (function (FillRule) {
+    /**
+     * If the path crosses the ray from
+     * left-to-right, counts +1. If the path crosses the ray
+     * from right to left, counts -1. (Left and right are determined
+     * from the perspective of looking along the ray from the starting
+     * point.) If the total count is non-zero, the point will be filled.
+     */
     FillRule[FillRule["WINDING"] = 0] = "WINDING";
+    /**
+     * Counts the total number of
+     * intersections, without regard to the orientation of the contour. If
+     * the total number of intersections is odd, the point will be
+     * filled.
+     */
     FillRule[FillRule["EVEN_ODD"] = 1] = "EVEN_ODD";
 })(FillRule || (FillRule = {}));
+/**
+ * Defines the types of the uniforms that `GskGLShaders` declare.
+ *
+ * It defines both what the type is called in the GLSL shader
+ * code, and what the corresponding C type is on the Gtk side.
+ */
 export var GLUniformType;
 (function (GLUniformType) {
+    /** No type, used for uninitialized or unspecified values. */
     GLUniformType[GLUniformType["NONE"] = 0] = "NONE";
+    /** A float uniform */
     GLUniformType[GLUniformType["FLOAT"] = 1] = "FLOAT";
+    /** A GLSL int / gint32 uniform */
     GLUniformType[GLUniformType["INT"] = 2] = "INT";
+    /** A GLSL uint / guint32 uniform */
     GLUniformType[GLUniformType["UINT"] = 3] = "UINT";
+    /** A GLSL bool / gboolean uniform */
     GLUniformType[GLUniformType["BOOL"] = 4] = "BOOL";
+    /** A GLSL vec2 / graphene_vec2_t uniform */
     GLUniformType[GLUniformType["VEC2"] = 5] = "VEC2";
+    /** A GLSL vec3 / graphene_vec3_t uniform */
     GLUniformType[GLUniformType["VEC3"] = 6] = "VEC3";
+    /** A GLSL vec4 / graphene_vec4_t uniform */
     GLUniformType[GLUniformType["VEC4"] = 7] = "VEC4";
 })(GLUniformType || (GLUniformType = {}));
+/**
+ * Specifies how to render the start and end points of contours or
+ * dashes when stroking.
+ *
+ * The default line cap style is `GSK_LINE_CAP_BUTT`.
+ *
+ * New entries may be added in future versions.
+ *
+ * <figure>
+ *
+ * <figcaption>GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE</figcaption>
+ * </figure>
+ */
 export var LineCap;
 (function (LineCap) {
+    /**
+     * Start and stop the line exactly at the start
+     * and end point
+     */
     LineCap[LineCap["BUTT"] = 0] = "BUTT";
+    /**
+     * Use a round ending, the center of the circle
+     * is the start or end point
+     */
     LineCap[LineCap["ROUND"] = 1] = "ROUND";
+    /**
+     * use squared ending, the center of the square
+     * is the start or end point
+     */
     LineCap[LineCap["SQUARE"] = 2] = "SQUARE";
 })(LineCap || (LineCap = {}));
+/**
+ * Specifies how to render the junction of two lines when stroking.
+ *
+ * The default line join style is `GSK_LINE_JOIN_MITER`.
+ *
+ * New entries may be added in future versions.
+ *
+ * <figure>
+ *
+ * <figcaption>GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL</figcaption>
+ * </figure>
+ */
 export var LineJoin;
 (function (LineJoin) {
+    /** Use a sharp angled corner */
     LineJoin[LineJoin["MITER"] = 0] = "MITER";
+    /**
+     * Use a round join, the center of the circle is
+     * the join point
+     */
     LineJoin[LineJoin["ROUND"] = 1] = "ROUND";
+    /**
+     * use a cut-off join, the join is cut off at half
+     * the line width from the joint point
+     */
     LineJoin[LineJoin["BEVEL"] = 2] = "BEVEL";
 })(LineJoin || (LineJoin = {}));
+/** The mask modes available for mask nodes. */
 export var MaskMode;
 (function (MaskMode) {
+    /** Use the alpha channel of the mask */
     MaskMode[MaskMode["ALPHA"] = 0] = "ALPHA";
+    /** Use the inverted alpha channel of the mask */
     MaskMode[MaskMode["INVERTED_ALPHA"] = 1] = "INVERTED_ALPHA";
+    /**
+     * Use the luminance of the mask,
+     * multiplied by mask alpha
+     */
     MaskMode[MaskMode["LUMINANCE"] = 2] = "LUMINANCE";
+    /**
+     * Use the inverted luminance of the mask,
+     * multiplied by mask alpha
+     */
     MaskMode[MaskMode["INVERTED_LUMINANCE"] = 3] = "INVERTED_LUMINANCE";
 })(MaskMode || (MaskMode = {}));
+/**
+ * Used to pick one of the four tangents at a given point on the path.
+ *
+ * Note that the directions for @GSK_PATH_FROM_START/`GSK_PATH_TO_END` and
+ * @GSK_PATH_TO_START/`GSK_PATH_FROM_END` will coincide for smooth points.
+ * Only sharp turns will exhibit four different directions.
+ */
 export var PathDirection;
 (function (PathDirection) {
+    /**
+     * The tangent in path direction of the incoming side
+     * of the path
+     */
     PathDirection[PathDirection["FROM_START"] = 0] = "FROM_START";
+    /**
+     * The tangent against path direction of the incoming side
+     * of the path
+     */
     PathDirection[PathDirection["TO_START"] = 1] = "TO_START";
+    /**
+     * The tangent in path direction of the outgoing side
+     * of the path
+     */
     PathDirection[PathDirection["TO_END"] = 2] = "TO_END";
+    /**
+     * The tangent against path direction of the outgoing
+     * side of the path
+     */
     PathDirection[PathDirection["FROM_END"] = 3] = "FROM_END";
 })(PathDirection || (PathDirection = {}));
+/**
+ * The values of this enumeration classify intersections
+ * between paths.
+ */
 export var PathIntersection;
 (function (PathIntersection) {
+    /** No intersection */
     PathIntersection[PathIntersection["NONE"] = 0] = "NONE";
+    /**
+     * A normal intersection, where the two paths
+     * cross each other
+     */
     PathIntersection[PathIntersection["NORMAL"] = 1] = "NORMAL";
+    /** The start of a segment where the two paths coincide */
     PathIntersection[PathIntersection["START"] = 2] = "START";
+    /** The end of a segment where the two paths coincide */
     PathIntersection[PathIntersection["END"] = 3] = "END";
 })(PathIntersection || (PathIntersection = {}));
+/**
+ * Describes the segments of a `GskPath`.
+ *
+ * More values may be added in the future.
+ */
 export var PathOperation;
 (function (PathOperation) {
+    /** A move-to operation, with 1 point describing the target point. */
     PathOperation[PathOperation["MOVE"] = 0] = "MOVE";
+    /**
+     * A close operation ending the current contour with a line back
+     * to the starting point. Two points describe the start and end of the line.
+     */
     PathOperation[PathOperation["CLOSE"] = 1] = "CLOSE";
+    /**
+     * A line-to operation, with 2 points describing the start and
+     * end point of a straight line.
+     */
     PathOperation[PathOperation["LINE"] = 2] = "LINE";
+    /**
+     * A curve-to operation describing a quadratic Bézier curve
+     * with 3 points describing the start point, the control point and the end
+     * point of the curve.
+     */
     PathOperation[PathOperation["QUAD"] = 3] = "QUAD";
+    /**
+     * A curve-to operation describing a cubic Bézier curve with 4
+     * points describing the start point, the two control points and the end point
+     * of the curve.
+     */
     PathOperation[PathOperation["CUBIC"] = 4] = "CUBIC";
+    /**
+     * A rational quadratic Bézier curve with 3 points describing
+     * the start point, control point and end point of the curve. A weight for the
+     * curve will be passed, too.
+     */
     PathOperation[PathOperation["CONIC"] = 5] = "CONIC";
 })(PathOperation || (PathOperation = {}));
+/** The type of a node determines what the node is rendering. */
 export var RenderNodeType;
 (function (RenderNodeType) {
+    /** Error type. No node will ever have this type. */
     RenderNodeType[RenderNodeType["NOT_A_RENDER_NODE"] = 0] = "NOT_A_RENDER_NODE";
+    /** A node containing a stack of children */
     RenderNodeType[RenderNodeType["CONTAINER_NODE"] = 1] = "CONTAINER_NODE";
+    /** A node drawing a `cairo_surface_t` */
     RenderNodeType[RenderNodeType["CAIRO_NODE"] = 2] = "CAIRO_NODE";
+    /** A node drawing a single color rectangle */
     RenderNodeType[RenderNodeType["COLOR_NODE"] = 3] = "COLOR_NODE";
+    /** A node drawing a linear gradient */
     RenderNodeType[RenderNodeType["LINEAR_GRADIENT_NODE"] = 4] = "LINEAR_GRADIENT_NODE";
+    /** A node drawing a repeating linear gradient */
     RenderNodeType[RenderNodeType["REPEATING_LINEAR_GRADIENT_NODE"] = 5] = "REPEATING_LINEAR_GRADIENT_NODE";
+    /** A node drawing a radial gradient */
     RenderNodeType[RenderNodeType["RADIAL_GRADIENT_NODE"] = 6] = "RADIAL_GRADIENT_NODE";
+    /** A node drawing a repeating radial gradient */
     RenderNodeType[RenderNodeType["REPEATING_RADIAL_GRADIENT_NODE"] = 7] = "REPEATING_RADIAL_GRADIENT_NODE";
+    /** A node drawing a conic gradient */
     RenderNodeType[RenderNodeType["CONIC_GRADIENT_NODE"] = 8] = "CONIC_GRADIENT_NODE";
+    /** A node stroking a border around an area */
     RenderNodeType[RenderNodeType["BORDER_NODE"] = 9] = "BORDER_NODE";
+    /** A node drawing a `GdkTexture` */
     RenderNodeType[RenderNodeType["TEXTURE_NODE"] = 10] = "TEXTURE_NODE";
+    /** A node drawing an inset shadow */
     RenderNodeType[RenderNodeType["INSET_SHADOW_NODE"] = 11] = "INSET_SHADOW_NODE";
+    /** A node drawing an outset shadow */
     RenderNodeType[RenderNodeType["OUTSET_SHADOW_NODE"] = 12] = "OUTSET_SHADOW_NODE";
+    /** A node that renders its child after applying a matrix transform */
     RenderNodeType[RenderNodeType["TRANSFORM_NODE"] = 13] = "TRANSFORM_NODE";
+    /** A node that changes the opacity of its child */
     RenderNodeType[RenderNodeType["OPACITY_NODE"] = 14] = "OPACITY_NODE";
+    /** A node that applies a color matrix to every pixel */
     RenderNodeType[RenderNodeType["COLOR_MATRIX_NODE"] = 15] = "COLOR_MATRIX_NODE";
+    /** A node that repeats the child's contents */
     RenderNodeType[RenderNodeType["REPEAT_NODE"] = 16] = "REPEAT_NODE";
+    /** A node that clips its child to a rectangular area */
     RenderNodeType[RenderNodeType["CLIP_NODE"] = 17] = "CLIP_NODE";
+    /** A node that clips its child to a rounded rectangle */
     RenderNodeType[RenderNodeType["ROUNDED_CLIP_NODE"] = 18] = "ROUNDED_CLIP_NODE";
+    /** A node that draws a shadow below its child */
     RenderNodeType[RenderNodeType["SHADOW_NODE"] = 19] = "SHADOW_NODE";
+    /** A node that blends two children together */
     RenderNodeType[RenderNodeType["BLEND_NODE"] = 20] = "BLEND_NODE";
+    /** A node that cross-fades between two children */
     RenderNodeType[RenderNodeType["CROSS_FADE_NODE"] = 21] = "CROSS_FADE_NODE";
+    /** A node containing a glyph string */
     RenderNodeType[RenderNodeType["TEXT_NODE"] = 22] = "TEXT_NODE";
+    /** A node that applies a blur */
     RenderNodeType[RenderNodeType["BLUR_NODE"] = 23] = "BLUR_NODE";
+    /** Debug information that does not affect the rendering */
     RenderNodeType[RenderNodeType["DEBUG_NODE"] = 24] = "DEBUG_NODE";
+    /** A node that uses OpenGL fragment shaders to render */
     RenderNodeType[RenderNodeType["GL_SHADER_NODE"] = 25] = "GL_SHADER_NODE";
+    /** A node drawing a `GdkTexture` scaled and filtered. */
     RenderNodeType[RenderNodeType["TEXTURE_SCALE_NODE"] = 26] = "TEXTURE_SCALE_NODE";
+    /** A node that masks one child with another. */
     RenderNodeType[RenderNodeType["MASK_NODE"] = 27] = "MASK_NODE";
+    /** A node that fills a path. */
     RenderNodeType[RenderNodeType["FILL_NODE"] = 28] = "FILL_NODE";
+    /** A node that strokes a path. */
     RenderNodeType[RenderNodeType["STROKE_NODE"] = 29] = "STROKE_NODE";
+    /** A node that possibly redirects part of the scene graph to a subsurface. */
     RenderNodeType[RenderNodeType["SUBSURFACE_NODE"] = 30] = "SUBSURFACE_NODE";
+    /** A node that applies some function to each color component. */
     RenderNodeType[RenderNodeType["COMPONENT_TRANSFER_NODE"] = 31] = "COMPONENT_TRANSFER_NODE";
 })(RenderNodeType || (RenderNodeType = {}));
+/**
+ * The filters used when scaling texture data.
+ *
+ * The actual implementation of each filter is deferred to the
+ * rendering pipeline.
+ */
 export var ScalingFilter;
 (function (ScalingFilter) {
+    /** linear interpolation filter */
     ScalingFilter[ScalingFilter["LINEAR"] = 0] = "LINEAR";
+    /** nearest neighbor interpolation filter */
     ScalingFilter[ScalingFilter["NEAREST"] = 1] = "NEAREST";
+    /**
+     * linear interpolation along each axis,
+     * plus mipmap generation, with linear interpolation along the mipmap
+     * levels
+     */
     ScalingFilter[ScalingFilter["TRILINEAR"] = 2] = "TRILINEAR";
 })(ScalingFilter || (ScalingFilter = {}));
+/** Errors that can happen during (de)serialization. */
 export var SerializationError;
 (function (SerializationError) {
+    /** The format can not be identified */
     SerializationError[SerializationError["UNSUPPORTED_FORMAT"] = 0] = "UNSUPPORTED_FORMAT";
+    /**
+     * The version of the data is not
+     * understood
+     */
     SerializationError[SerializationError["UNSUPPORTED_VERSION"] = 1] = "UNSUPPORTED_VERSION";
+    /**
+     * The given data may not exist in
+     * a proper serialization
+     */
     SerializationError[SerializationError["INVALID_DATA"] = 2] = "INVALID_DATA";
 })(SerializationError || (SerializationError = {}));
+/**
+ * The categories of matrices relevant for GSK and GTK.
+ *
+ * Note that any category includes matrices of all later categories.
+ * So if you want to for example check if a matrix is a 2D matrix,
+ * `category >= GSK_TRANSFORM_CATEGORY_2D` is the way to do this.
+ *
+ * Also keep in mind that rounding errors may cause matrices to not
+ * conform to their categories. Otherwise, matrix operations done via
+ * multiplication will not worsen categories. So for the matrix
+ * multiplication `C = A * B`, `category(C) = MIN (category(A), category(B))`.
+ */
 export var TransformCategory;
 (function (TransformCategory) {
+    /**
+     * The category of the matrix has not been
+     * determined.
+     */
     TransformCategory[TransformCategory["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * Analyzing the matrix concluded that it does
+     * not fit in any other category.
+     */
     TransformCategory[TransformCategory["ANY"] = 1] = "ANY";
+    /**
+     * The matrix is a 3D matrix. This means that
+     * the w column (the last column) has the values (0, 0, 0, 1).
+     */
     TransformCategory[TransformCategory["_3D"] = 2] = "_3D";
+    /**
+     * The matrix is a 2D matrix. This is equivalent
+     * to graphene_matrix_is_2d() returning %TRUE. In particular, this
+     * means that Cairo can deal with the matrix.
+     */
     TransformCategory[TransformCategory["_2D"] = 3] = "_2D";
+    /**
+     * The matrix is a combination of 2D scale
+     * and 2D translation operations. In particular, this means that any
+     * rectangle can be transformed exactly using this matrix.
+     */
     TransformCategory[TransformCategory["_2D_AFFINE"] = 4] = "_2D_AFFINE";
+    /** The matrix is a 2D translation. */
     TransformCategory[TransformCategory["_2D_TRANSLATE"] = 5] = "_2D_TRANSLATE";
+    /** The matrix is the identity matrix. */
     TransformCategory[TransformCategory["IDENTITY"] = 6] = "IDENTITY";
 })(TransformCategory || (TransformCategory = {}));
+/**
+ * Flags that can be passed to gsk_path_foreach() to influence what
+ * kinds of operations the path is decomposed into.
+ *
+ * By default, [method@Gsk.Path.foreach] will only emit a path with all
+ * operations flattened to straight lines to allow for maximum compatibility.
+ * The only operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and
+ * `GSK_PATH_CLOSE`.
+ */
 export var PathForeachFlags;
 (function (PathForeachFlags) {
+    /** The default behavior, only allow lines. */
     PathForeachFlags[PathForeachFlags["ONLY_LINES"] = 0] = "ONLY_LINES";
+    /** Allow emission of `GSK_PATH_QUAD` operations */
     PathForeachFlags[PathForeachFlags["QUAD"] = 1] = "QUAD";
+    /** Allow emission of `GSK_PATH_CUBIC` operations. */
     PathForeachFlags[PathForeachFlags["CUBIC"] = 2] = "CUBIC";
+    /** Allow emission of `GSK_PATH_CONIC` operations. */
     PathForeachFlags[PathForeachFlags["CONIC"] = 4] = "CONIC";
 })(PathForeachFlags || (PathForeachFlags = {}));

package/dist/generated/gsk/fill-node.d.ts

@@ -1,11 +1,32 @@
 import { FillRule } from "./enums.js";
 import { Path } from "./path.js";
 import { RenderNode } from "./render-node.js";
+/**
+ * A render node filling the area given by [struct@Gsk.Path]
+ * and [enum@Gsk.FillRule] with the child node.
+ */
 export declare class FillNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will fill the `child` in the area
+     * given by `path` and @fill_rule.
+     * @param child - The node to fill the area with
+     * @param path - The path describing the area to fill
+     * @param fillRule - The fill rule to use
+     */
     constructor(child: RenderNode, path: Path, fillRule: FillRule);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the child node that is getting drawn by the given @node.
+     */
     getChild(): RenderNode;
+    /**
+     * Retrieves the fill rule used to determine how the path is filled.
+     */
     getFillRule(): FillRule;
+    /**
+     * Retrieves the path used to describe the area filled with the contents of
+     * the @node.
+     */
     getPath(): Path;
 }

package/dist/generated/gsk/fill-node.js

@@ -2,6 +2,10 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Path } from "./path.js";
 import { RenderNode } from "./render-node.js";
+/**
+ * A render node filling the area given by [struct@Gsk.Path]
+ * and [enum@Gsk.FillRule] with the child node.
+ */
 export class FillNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -28,6 +32,9 @@ export class FillNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the child node that is getting drawn by the given @node.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gsk_fill_node_get_child", [
             {
@@ -37,6 +44,9 @@ export class FillNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the fill rule used to determine how the path is filled.
+     */
     getFillRule() {
         return call("libgtk-4.so.1", "gsk_fill_node_get_fill_rule", [
             {
@@ -45,6 +55,10 @@ export class FillNode extends RenderNode {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the path used to describe the area filled with the contents of
+     * the @node.
+     */
     getPath() {
         const ptr = call("libgtk-4.so.1", "gsk_fill_node_get_path", [
             {

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

@@ -3,12 +3,88 @@ import { Path } from "./path.js";
 import { Transform } from "./transform.js";
 import { RenderNode } from "./render-node.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Compares two component transfers for equality.
+ * @param self - a component transfer
+ * @param other - another component transfer
+ */
 export declare const componentTransferEqual: (self: number, other: number) => boolean;
+/**
+ * Constructs a path from a serialized form.
+ *
+ * The string is expected to be in (a superset of)
+ * SVG path syntax,
+ * as e.g. produced by [method@Gsk.Path.to_string].
+ *
+ * A high-level summary of the syntax:
+ *
+ * - `M x y` Move to `(x, y)`
+ * - `L x y` Add a line from the current point to `(x, y)`
+ * - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)`
+ * - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)`
+ * - `Z` Close the contour by drawing a line back to the start point
+ * - `H x` Add a horizontal line from the current point to the given x value
+ * - `V y` Add a vertical line from the current point to the given y value
+ * - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point
+ * - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point
+ * - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc.
+ * - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`.
+ *
+ * All the commands have lowercase variants that interpret coordinates
+ * relative to the current point.
+ *
+ * The `O` command is an extension that is not supported in SVG.
+ * @param string - a string
+ */
 export declare const pathParse: (string: string) => Path | null;
+/**
+ * Registers an error quark for [class@Gsk.RenderNode] errors.
+ */
 export declare const serializationErrorQuark: () => number;
+/**
+ * Checks if two strokes are identical.
+ * @param stroke1 - the first stroke
+ * @param stroke2 - the second stroke
+ */
 export declare const strokeEqual: (stroke1?: number | null, stroke2?: number | null) => boolean;
+/**
+ * Parses a given into a transform.
+ *
+ * Strings printed via [method@Gsk.Transform.to_string]
+ * can be read in again successfully using this function.
+ *
+ * If `string` does not describe a valid transform, false
+ * is returned and `NULL` is put in @out_transform.
+ * @param string - the string to parse
+ * @param outTransform - return location for the transform
+ */
 export declare const transformParse: (string: string, outTransform: Ref<Transform>) => boolean;
+/**
+ * Retrieves the render node stored inside a `GValue`,
+ * and acquires a reference to it.
+ * @param value - a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
+ */
 export declare const valueDupRenderNode: (value: GObject.Value) => RenderNode | null;
+/**
+ * Retrieves the render node stored inside a `GValue`.
+ * @param value - a `GValue` initialized with type `GSK_TYPE_RENDER_NODE`
+ */
 export declare const valueGetRenderNode: (value: GObject.Value) => RenderNode | null;
+/**
+ * Stores the given render node inside a `GValue`.
+ *
+ * The [struct@GObject.Value] will acquire a reference
+ * to the render node.
+ * @param value - a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
+ * @param node - a render node
+ */
 export declare const valueSetRenderNode: (value: GObject.Value, node: RenderNode) => void;
+/**
+ * Stores the given render node inside a `GValue`.
+ *
+ * This function transfers the ownership of the
+ * render node to the `GValue`.
+ * @param value - a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
+ * @param node - a render node
+ */
 export declare const valueTakeRenderNode: (value: GObject.Value, node?: RenderNode | null) => void;