@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { RenderNode } from "./render-node.js";
+/** A render node that can contain other render nodes. */
 export class ContainerNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -18,6 +19,10 @@ export class ContainerNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets one of the children of @container.
+     * @param idx - the position of the child to get
+     */
     getChild(idx) {
         const ptr = call("libgtk-4.so.1", "gsk_container_node_get_child", [
             {
@@ -31,6 +36,9 @@ export class ContainerNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the number of direct children of @node.
+     */
     getNChildren() {
         return call("libgtk-4.so.1", "gsk_container_node_get_n_children", [
             {

package/dist/generated/gsk/cross-fade-node.d.ts

@@ -1,9 +1,25 @@
 import { RenderNode } from "./render-node.js";
+/** A render node cross fading between two child nodes. */
 export declare class CrossFadeNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will do a cross-fade between `start` and @end.
+     * @param start - The start node to be drawn
+     * @param end - The node to be cross_fadeed onto the `start` node
+     * @param progress - How far the fade has progressed from start to end. The value will
+     */
     constructor(start: RenderNode, end: RenderNode, progress: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the child `GskRenderNode` at the end of the cross-fade.
+     */
     getEndChild(): RenderNode;
+    /**
+     * Retrieves the progress value of the cross fade.
+     */
     getProgress(): number;
+    /**
+     * Retrieves the child `GskRenderNode` at the beginning of the cross-fade.
+     */
     getStartChild(): RenderNode;
 }

package/dist/generated/gsk/cross-fade-node.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { RenderNode } from "./render-node.js";
+/** A render node cross fading between two child nodes. */
 export class CrossFadeNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -22,6 +23,9 @@ export class CrossFadeNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the child `GskRenderNode` at the end of the cross-fade.
+     */
     getEndChild() {
         const ptr = call("libgtk-4.so.1", "gsk_cross_fade_node_get_end_child", [
             {
@@ -31,6 +35,9 @@ export class CrossFadeNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the progress value of the cross fade.
+     */
     getProgress() {
         return call("libgtk-4.so.1", "gsk_cross_fade_node_get_progress", [
             {
@@ -39,6 +46,9 @@ export class CrossFadeNode extends RenderNode {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the child `GskRenderNode` at the beginning of the cross-fade.
+     */
     getStartChild() {
         const ptr = call("libgtk-4.so.1", "gsk_cross_fade_node_get_start_child", [
             {

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

@@ -1,8 +1,26 @@
 import { RenderNode } from "./render-node.js";
+/**
+ * A render node that emits a debugging message when drawing its
+ * child node.
+ */
 export declare class DebugNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will add debug information about
+     * the given @child.
+     *
+     * Adding this node has no visual effect.
+     * @param child - The child to add debug info for
+     * @param message - The debug message
+     */
     constructor(child: RenderNode, message: string);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the child node that is getting drawn by the given @node.
+     */
     getChild(): RenderNode;
+    /**
+     * Gets the debug message that was set on this node
+     */
     getMessage(): string;
 }

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

@@ -1,6 +1,10 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { RenderNode } from "./render-node.js";
+/**
+ * A render node that emits a debugging message when drawing its
+ * child node.
+ */
 export class DebugNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -18,6 +22,9 @@ export class DebugNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the child node that is getting drawn by the given @node.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gsk_debug_node_get_child", [
             {
@@ -27,6 +34,9 @@ export class DebugNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Gets the debug message that was set on this node
+     */
     getMessage() {
         return call("libgtk-4.so.1", "gsk_debug_node_get_message", [
             {

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

@@ -1,133 +1,446 @@
+/**
+ * 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 declare enum BlendMode {
+    /** The default blend mode, which specifies no blending */
     DEFAULT = 0,
+    /**
+     * The source color is multiplied by the destination
+     * and replaces the destination
+     */
     MULTIPLY = 1,
+    /**
+     * Multiplies the complements of the destination and source
+     * color values, then complements the result.
+     */
     SCREEN = 2,
+    /**
+     * Multiplies or screens the colors, depending on the
+     * destination color value. This is the inverse of hard-list
+     */
     OVERLAY = 3,
+    /** Selects the darker of the destination and source colors */
     DARKEN = 4,
+    /** Selects the lighter of the destination and source colors */
     LIGHTEN = 5,
+    /** Brightens the destination color to reflect the source color */
     COLOR_DODGE = 6,
+    /** Darkens the destination color to reflect the source color */
     COLOR_BURN = 7,
+    /** Multiplies or screens the colors, depending on the source color value */
     HARD_LIGHT = 8,
+    /** Darkens or lightens the colors, depending on the source color value */
     SOFT_LIGHT = 9,
+    /** Subtracts the darker of the two constituent colors from the lighter color */
     DIFFERENCE = 10,
+    /** Produces an effect similar to that of the difference mode but lower in contrast */
     EXCLUSION = 11,
+    /**
+     * Creates a color with the hue and saturation of the source color and the luminosity of the destination color
+     */
     COLOR = 12,
+    /**
+     * Creates a color with the hue of the source color and the saturation and luminosity of the destination color
+     */
     HUE = 13,
+    /**
+     * Creates a color with the saturation of the source color and the hue and luminosity of the destination color
+     */
     SATURATION = 14,
+    /**
+     * Creates a color with the luminosity of the source color and the hue and saturation of the destination color
+     */
     LUMINOSITY = 15
 }
+/** The corner indices used by `GskRoundedRect`. */
 export declare enum Corner {
+    /** The top left corner */
     TOP_LEFT = 0,
+    /** The top right corner */
     TOP_RIGHT = 1,
+    /** The bottom right corner */
     BOTTOM_RIGHT = 2,
+    /** The bottom left corner */
     BOTTOM_LEFT = 3
 }
+/**
+ * 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 declare enum 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.
+     */
     WINDING = 0,
+    /**
+     * 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.
+     */
     EVEN_ODD = 1
 }
+/**
+ * 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 declare enum GLUniformType {
+    /** No type, used for uninitialized or unspecified values. */
     NONE = 0,
+    /** A float uniform */
     FLOAT = 1,
+    /** A GLSL int / gint32 uniform */
     INT = 2,
+    /** A GLSL uint / guint32 uniform */
     UINT = 3,
+    /** A GLSL bool / gboolean uniform */
     BOOL = 4,
+    /** A GLSL vec2 / graphene_vec2_t uniform */
     VEC2 = 5,
+    /** A GLSL vec3 / graphene_vec3_t uniform */
     VEC3 = 6,
+    /** A GLSL vec4 / graphene_vec4_t uniform */
     VEC4 = 7
 }
+/**
+ * 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 declare enum LineCap {
+    /**
+     * Start and stop the line exactly at the start
+     * and end point
+     */
     BUTT = 0,
+    /**
+     * Use a round ending, the center of the circle
+     * is the start or end point
+     */
     ROUND = 1,
+    /**
+     * use squared ending, the center of the square
+     * is the start or end point
+     */
     SQUARE = 2
 }
+/**
+ * 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 declare enum LineJoin {
+    /** Use a sharp angled corner */
     MITER = 0,
+    /**
+     * Use a round join, the center of the circle is
+     * the join point
+     */
     ROUND = 1,
+    /**
+     * use a cut-off join, the join is cut off at half
+     * the line width from the joint point
+     */
     BEVEL = 2
 }
+/** The mask modes available for mask nodes. */
 export declare enum MaskMode {
+    /** Use the alpha channel of the mask */
     ALPHA = 0,
+    /** Use the inverted alpha channel of the mask */
     INVERTED_ALPHA = 1,
+    /**
+     * Use the luminance of the mask,
+     * multiplied by mask alpha
+     */
     LUMINANCE = 2,
+    /**
+     * Use the inverted luminance of the mask,
+     * multiplied by mask alpha
+     */
     INVERTED_LUMINANCE = 3
 }
+/**
+ * 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 declare enum PathDirection {
+    /**
+     * The tangent in path direction of the incoming side
+     * of the path
+     */
     FROM_START = 0,
+    /**
+     * The tangent against path direction of the incoming side
+     * of the path
+     */
     TO_START = 1,
+    /**
+     * The tangent in path direction of the outgoing side
+     * of the path
+     */
     TO_END = 2,
+    /**
+     * The tangent against path direction of the outgoing
+     * side of the path
+     */
     FROM_END = 3
 }
+/**
+ * The values of this enumeration classify intersections
+ * between paths.
+ */
 export declare enum PathIntersection {
+    /** No intersection */
     NONE = 0,
+    /**
+     * A normal intersection, where the two paths
+     * cross each other
+     */
     NORMAL = 1,
+    /** The start of a segment where the two paths coincide */
     START = 2,
+    /** The end of a segment where the two paths coincide */
     END = 3
 }
+/**
+ * Describes the segments of a `GskPath`.
+ *
+ * More values may be added in the future.
+ */
 export declare enum PathOperation {
+    /** A move-to operation, with 1 point describing the target point. */
     MOVE = 0,
+    /**
+     * 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.
+     */
     CLOSE = 1,
+    /**
+     * A line-to operation, with 2 points describing the start and
+     * end point of a straight line.
+     */
     LINE = 2,
+    /**
+     * 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.
+     */
     QUAD = 3,
+    /**
+     * 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.
+     */
     CUBIC = 4,
+    /**
+     * 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.
+     */
     CONIC = 5
 }
+/** The type of a node determines what the node is rendering. */
 export declare enum RenderNodeType {
+    /** Error type. No node will ever have this type. */
     NOT_A_RENDER_NODE = 0,
+    /** A node containing a stack of children */
     CONTAINER_NODE = 1,
+    /** A node drawing a `cairo_surface_t` */
     CAIRO_NODE = 2,
+    /** A node drawing a single color rectangle */
     COLOR_NODE = 3,
+    /** A node drawing a linear gradient */
     LINEAR_GRADIENT_NODE = 4,
+    /** A node drawing a repeating linear gradient */
     REPEATING_LINEAR_GRADIENT_NODE = 5,
+    /** A node drawing a radial gradient */
     RADIAL_GRADIENT_NODE = 6,
+    /** A node drawing a repeating radial gradient */
     REPEATING_RADIAL_GRADIENT_NODE = 7,
+    /** A node drawing a conic gradient */
     CONIC_GRADIENT_NODE = 8,
+    /** A node stroking a border around an area */
     BORDER_NODE = 9,
+    /** A node drawing a `GdkTexture` */
     TEXTURE_NODE = 10,
+    /** A node drawing an inset shadow */
     INSET_SHADOW_NODE = 11,
+    /** A node drawing an outset shadow */
     OUTSET_SHADOW_NODE = 12,
+    /** A node that renders its child after applying a matrix transform */
     TRANSFORM_NODE = 13,
+    /** A node that changes the opacity of its child */
     OPACITY_NODE = 14,
+    /** A node that applies a color matrix to every pixel */
     COLOR_MATRIX_NODE = 15,
+    /** A node that repeats the child's contents */
     REPEAT_NODE = 16,
+    /** A node that clips its child to a rectangular area */
     CLIP_NODE = 17,
+    /** A node that clips its child to a rounded rectangle */
     ROUNDED_CLIP_NODE = 18,
+    /** A node that draws a shadow below its child */
     SHADOW_NODE = 19,
+    /** A node that blends two children together */
     BLEND_NODE = 20,
+    /** A node that cross-fades between two children */
     CROSS_FADE_NODE = 21,
+    /** A node containing a glyph string */
     TEXT_NODE = 22,
+    /** A node that applies a blur */
     BLUR_NODE = 23,
+    /** Debug information that does not affect the rendering */
     DEBUG_NODE = 24,
+    /** A node that uses OpenGL fragment shaders to render */
     GL_SHADER_NODE = 25,
+    /** A node drawing a `GdkTexture` scaled and filtered. */
     TEXTURE_SCALE_NODE = 26,
+    /** A node that masks one child with another. */
     MASK_NODE = 27,
+    /** A node that fills a path. */
     FILL_NODE = 28,
+    /** A node that strokes a path. */
     STROKE_NODE = 29,
+    /** A node that possibly redirects part of the scene graph to a subsurface. */
     SUBSURFACE_NODE = 30,
+    /** A node that applies some function to each color component. */
     COMPONENT_TRANSFER_NODE = 31
 }
+/**
+ * The filters used when scaling texture data.
+ *
+ * The actual implementation of each filter is deferred to the
+ * rendering pipeline.
+ */
 export declare enum ScalingFilter {
+    /** linear interpolation filter */
     LINEAR = 0,
+    /** nearest neighbor interpolation filter */
     NEAREST = 1,
+    /**
+     * linear interpolation along each axis,
+     * plus mipmap generation, with linear interpolation along the mipmap
+     * levels
+     */
     TRILINEAR = 2
 }
+/** Errors that can happen during (de)serialization. */
 export declare enum SerializationError {
+    /** The format can not be identified */
     UNSUPPORTED_FORMAT = 0,
+    /**
+     * The version of the data is not
+     * understood
+     */
     UNSUPPORTED_VERSION = 1,
+    /**
+     * The given data may not exist in
+     * a proper serialization
+     */
     INVALID_DATA = 2
 }
+/**
+ * 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 declare enum TransformCategory {
+    /**
+     * The category of the matrix has not been
+     * determined.
+     */
     UNKNOWN = 0,
+    /**
+     * Analyzing the matrix concluded that it does
+     * not fit in any other category.
+     */
     ANY = 1,
+    /**
+     * The matrix is a 3D matrix. This means that
+     * the w column (the last column) has the values (0, 0, 0, 1).
+     */
     _3D = 2,
+    /**
+     * 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.
+     */
     _2D = 3,
+    /**
+     * 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.
+     */
     _2D_AFFINE = 4,
+    /** The matrix is a 2D translation. */
     _2D_TRANSLATE = 5,
+    /** The matrix is the identity matrix. */
     IDENTITY = 6
 }
+/**
+ * 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 declare enum PathForeachFlags {
+    /** The default behavior, only allow lines. */
     ONLY_LINES = 0,
+    /** Allow emission of `GSK_PATH_QUAD` operations */
     QUAD = 1,
+    /** Allow emission of `GSK_PATH_CUBIC` operations. */
     CUBIC = 2,
+    /** Allow emission of `GSK_PATH_CONIC` operations. */
     CONIC = 4
 }