@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -3,16 +3,95 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Graphene from "../graphene/index.js";
 import * as cairo from "../cairo/index.js";
+/**
+ * Renders a scene graph defined via a tree of [class@Gsk.RenderNode] instances.
+ *
+ * Typically you will use a `GskRenderer` instance to repeatedly call
+ * [method@Gsk.Renderer.render] to update the contents of its associated
+ * [class@Gdk.Surface].
+ *
+ * It is necessary to realize a `GskRenderer` instance using
+ * [method@Gsk.Renderer.realize] before calling [method@Gsk.Renderer.render],
+ * in order to create the appropriate windowing system resources needed
+ * to render the scene.
+ */
 export declare class Renderer extends GObject.GObject {
+    /**
+     * Creates an appropriate `GskRenderer` instance for the given surface.
+     *
+     * If the `GSK_RENDERER` environment variable is set, GSK will
+     * try that renderer first, before trying the backend-specific
+     * default. The ultimate fallback is the cairo renderer.
+     *
+     * The renderer will be realized before it is returned.
+     * @param surface - a surface
+     */
     constructor(surface: Gdk.Surface);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the surface that the renderer is associated with.
+     *
+     * If the renderer has not been realized yet, `NULL` will be returned.
+     */
     getSurface(): Gdk.Surface | null;
+    /**
+     * Checks whether the renderer is realized or not.
+     */
     isRealized(): boolean;
+    /**
+     * Creates the resources needed by the renderer.
+     *
+     * Since GTK 4.6, the surface may be `NULL`, which allows using
+     * renderers without having to create a surface. Since GTK 4.14,
+     * it is recommended to use [method@Gsk.Renderer.realize_for_display]
+     * for this case.
+     *
+     * Note that it is mandatory to call [method@Gsk.Renderer.unrealize]
+     * before destroying the renderer.
+     * @param surface - the surface that renderer will be used on
+     */
     realize(surface?: Gdk.Surface | null): boolean;
+    /**
+     * Creates the resources needed by the renderer.
+     *
+     * Note that it is mandatory to call [method@Gsk.Renderer.unrealize]
+     * before destroying the renderer.
+     * @param display - the display that the renderer will be used on
+     */
     realizeForDisplay(display: Gdk.Display): boolean;
+    /**
+     * Renders the scene graph, described by a tree of `GskRenderNode` instances
+     * to the renderer's surface, ensuring that the given region gets redrawn.
+     *
+     * If the renderer has no associated surface, this function does nothing.
+     *
+     * Renderers must ensure that changes of the contents given by the `root` node as well as the area given by `region` are redrawn. They are however
+     * free to not redraw any pixel outside of `region` if they can guarantee that
+     * it didn't change.
+     *
+     * The renderer will acquire a reference on the `GskRenderNode` tree while
+     * the rendering is in progress.
+     * @param root - the render node to render
+     * @param region - the `cairo_region_t` that must be redrawn or `NULL`
+     */
     render(root: RenderNode, region?: cairo.Region | null): void;
+    /**
+     * Renders a scene graph, described by a tree of `GskRenderNode` instances,
+     * to a texture.
+     *
+     * The renderer will acquire a reference on the `GskRenderNode` tree while
+     * the rendering is in progress.
+     *
+     * If you want to apply any transformations to @root, you should put it into a
+     * transform node and pass that node instead.
+     * @param root - the render node to render
+     * @param viewport - the section to draw or `NULL` to use @root's bounds
+     */
     renderTexture(root: RenderNode, viewport?: Graphene.Rect | null): Gdk.Texture;
+    /**
+     * Releases all the resources created by [method@Gsk.Renderer.realize].
+     */
     unrealize(): void;
     connect(signal: "notify", handler: (self: Renderer, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gsk/renderer.js

@@ -2,6 +2,18 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
+/**
+ * Renders a scene graph defined via a tree of [class@Gsk.RenderNode] instances.
+ *
+ * Typically you will use a `GskRenderer` instance to repeatedly call
+ * [method@Gsk.Renderer.render] to update the contents of its associated
+ * [class@Gdk.Surface].
+ *
+ * It is necessary to realize a `GskRenderer` instance using
+ * [method@Gsk.Renderer.realize] before calling [method@Gsk.Renderer.render],
+ * in order to create the appropriate windowing system resources needed
+ * to render the scene.
+ */
 export class Renderer extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -15,6 +27,11 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the surface that the renderer is associated with.
+     *
+     * If the renderer has not been realized yet, `NULL` will be returned.
+     */
     getSurface() {
         const ptr = call("libgtk-4.so.1", "gsk_renderer_get_surface", [
             {
@@ -26,6 +43,9 @@ export class Renderer extends GObject.GObject {
             return null;
         return getObject(ptr, Gdk.Surface);
     }
+    /**
+     * Checks whether the renderer is realized or not.
+     */
     isRealized() {
         return call("libgtk-4.so.1", "gsk_renderer_is_realized", [
             {
@@ -34,6 +54,18 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates the resources needed by the renderer.
+     *
+     * Since GTK 4.6, the surface may be `NULL`, which allows using
+     * renderers without having to create a surface. Since GTK 4.14,
+     * it is recommended to use [method@Gsk.Renderer.realize_for_display]
+     * for this case.
+     *
+     * Note that it is mandatory to call [method@Gsk.Renderer.unrealize]
+     * before destroying the renderer.
+     * @param surface - the surface that renderer will be used on
+     */
     realize(surface) {
         const error = { value: null };
         const result = call("libgtk-4.so.1", "gsk_renderer_realize", [
@@ -63,6 +95,13 @@ export class Renderer extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Creates the resources needed by the renderer.
+     *
+     * Note that it is mandatory to call [method@Gsk.Renderer.unrealize]
+     * before destroying the renderer.
+     * @param display - the display that the renderer will be used on
+     */
     realizeForDisplay(display) {
         const error = { value: null };
         const result = call("libgtk-4.so.1", "gsk_renderer_realize_for_display", [
@@ -91,6 +130,21 @@ export class Renderer extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Renders the scene graph, described by a tree of `GskRenderNode` instances
+     * to the renderer's surface, ensuring that the given region gets redrawn.
+     *
+     * If the renderer has no associated surface, this function does nothing.
+     *
+     * Renderers must ensure that changes of the contents given by the `root` node as well as the area given by `region` are redrawn. They are however
+     * free to not redraw any pixel outside of `region` if they can guarantee that
+     * it didn't change.
+     *
+     * The renderer will acquire a reference on the `GskRenderNode` tree while
+     * the rendering is in progress.
+     * @param root - the render node to render
+     * @param region - the `cairo_region_t` that must be redrawn or `NULL`
+     */
     render(root, region) {
         call("libgtk-4.so.1", "gsk_renderer_render", [
             {
@@ -113,6 +167,18 @@ export class Renderer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Renders a scene graph, described by a tree of `GskRenderNode` instances,
+     * to a texture.
+     *
+     * The renderer will acquire a reference on the `GskRenderNode` tree while
+     * the rendering is in progress.
+     *
+     * If you want to apply any transformations to @root, you should put it into a
+     * transform node and pass that node instead.
+     * @param root - the render node to render
+     * @param viewport - the section to draw or `NULL` to use @root's bounds
+     */
     renderTexture(root, viewport) {
         const ptr = call("libgtk-4.so.1", "gsk_renderer_render_texture", [
             {
@@ -136,6 +202,9 @@ export class Renderer extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gdk.Texture);
     }
+    /**
+     * Releases all the resources created by [method@Gsk.Renderer.realize].
+     */
     unrealize() {
         call("libgtk-4.so.1", "gsk_renderer_unrealize", [
             {

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

@@ -1,9 +1,23 @@
 import * as Graphene from "../graphene/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node repeating its single child node. */
 export declare class RepeatNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will repeat the drawing of `child` across
+     * the given @bounds.
+     * @param bounds - The bounds of the area to be painted
+     * @param child - The child to repeat
+     * @param childBounds - The area of the child to repeat or %NULL to
+     */
     constructor(bounds: Graphene.Rect, child: RenderNode, childBounds?: Graphene.Rect | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the child of @node.
+     */
     getChild(): RenderNode;
+    /**
+     * Retrieves the bounding rectangle of the child of @node.
+     */
     getChildBounds(): Graphene.Rect;
 }

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

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Graphene from "../graphene/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node repeating its single child node. */
 export class RepeatNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -34,6 +35,9 @@ export class RepeatNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the child of @node.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gsk_repeat_node_get_child", [
             {
@@ -43,6 +47,9 @@ export class RepeatNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the bounding rectangle of the child of @node.
+     */
     getChildBounds() {
         const ptr = call("libgtk-4.so.1", "gsk_repeat_node_get_child_bounds", [
             {

package/dist/generated/gsk/repeating-linear-gradient-node.d.ts

@@ -1,6 +1,17 @@
 import * as Graphene from "../graphene/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for a repeating linear gradient. */
 export declare class RepeatingLinearGradientNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will create a repeating linear gradient
+     * from the given points and color stops, and render that into the area
+     * given by @bounds.
+     * @param bounds - the rectangle to render the linear gradient into
+     * @param start - the point at which the linear gradient will begin
+     * @param end - the point at which the linear gradient will finish
+     * @param colorStops - a pointer to an array of
+     * @param nColorStops - the number of elements in @color_stops
+     */
     constructor(bounds: Graphene.Rect, start: Graphene.Point, end: Graphene.Point, colorStops: number[], nColorStops: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;

package/dist/generated/gsk/repeating-linear-gradient-node.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { RenderNode } from "./render-node.js";
+/** A render node for a repeating linear gradient. */
 export class RepeatingLinearGradientNode extends RenderNode {
     constructor(...args) {
         super(...args);

package/dist/generated/gsk/repeating-radial-gradient-node.d.ts

@@ -1,6 +1,21 @@
 import * as Graphene from "../graphene/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for a repeating radial gradient. */
 export declare class RepeatingRadialGradientNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that draws a repeating radial gradient.
+     *
+     * The radial gradient starts around @center. The size of the gradient
+     * is dictated by `hradius` in horizontal orientation and by `vradius` in vertical orientation.
+     * @param bounds - the bounds of the node
+     * @param center - the center of the gradient
+     * @param hradius - the horizontal radius
+     * @param vradius - the vertical radius
+     * @param start - a percentage >= 0 that defines the start of the gradient around @center
+     * @param end - a percentage >= 0 that defines the end of the gradient around @center
+     * @param colorStops - a pointer to an array of
+     * @param nColorStops - the number of elements in @color_stops
+     */
     constructor(bounds: Graphene.Rect, center: Graphene.Point, hradius: number, vradius: number, start: number, end: number, colorStops: number[], nColorStops: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;

package/dist/generated/gsk/repeating-radial-gradient-node.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { RenderNode } from "./render-node.js";
+/** A render node for a repeating radial gradient. */
 export class RepeatingRadialGradientNode extends RenderNode {
     constructor(...args) {
         super(...args);

package/dist/generated/gsk/rounded-clip-node.d.ts

@@ -1,8 +1,21 @@
 import { RenderNode } from "./render-node.js";
+/** A render node applying a rounded rectangle clip to its single child. */
 export declare class RoundedClipNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will clip the `child` to the area
+     * given by @clip.
+     * @param child - The node to draw
+     * @param clip - The clip to apply
+     */
     constructor(child: RenderNode, clip: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the child node that is getting clipped by the given @node.
+     */
     getChild(): RenderNode;
+    /**
+     * Retrieves the rounded rectangle used to clip the contents of the @node.
+     */
     getClip(): number;
 }

package/dist/generated/gsk/rounded-clip-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 applying a rounded rectangle clip to its single child. */
 export class RoundedClipNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -18,6 +19,9 @@ export class RoundedClipNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the child node that is getting clipped by the given @node.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gsk_rounded_clip_node_get_child", [
             {
@@ -27,6 +31,9 @@ export class RoundedClipNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the rounded rectangle used to clip the contents of the @node.
+     */
     getClip() {
         return call("libgtk-4.so.1", "gsk_rounded_clip_node_get_clip", [
             {

package/dist/generated/gsk/shader-args-builder.d.ts

@@ -1,19 +1,96 @@
 import { GLShader } from "./glshader.js";
 import * as GLib from "../glib/index.js";
 import * as Graphene from "../graphene/index.js";
+/** Builds the uniforms data for a `GskGLShader`. */
 export declare class ShaderArgsBuilder {
     ptr: unknown;
+    /**
+     * Allocates a builder that can be used to construct a new uniform data
+     * chunk.
+     * @param shader - a `GskGLShader`
+     * @param initialValues - optional `GBytes` with initial values
+     */
     constructor(shader: GLShader, initialValues?: GLib.Bytes | null);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Increases the reference count of a `GskShaderArgsBuilder` by one.
+     */
     ref(): ShaderArgsBuilder;
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of bool type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setBool(idx: number, value: boolean): void;
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of float type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setFloat(idx: number, value: number): void;
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of int type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setInt(idx: number, value: number): void;
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of uint type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setUint(idx: number, value: number): void;
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of vec2 type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform too
+     */
     setVec2(idx: number, value: Graphene.Vec2): void;
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of vec3 type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform too
+     */
     setVec3(idx: number, value: Graphene.Vec3): void;
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of vec4 type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform too
+     */
     setVec4(idx: number, value: Graphene.Vec4): void;
+    /**
+     * Creates a new `GBytes` args from the current state of the
+     * given @builder.
+     *
+     * Any uniforms of the shader that have not been explicitly set on
+     * the `builder` are zero-initialized.
+     *
+     * The given `GskShaderArgsBuilder` is reset once this function returns;
+     * you cannot call this function multiple times on the same `builder` instance.
+     *
+     * This function is intended primarily for bindings. C code should use
+     * [method@Gsk.ShaderArgsBuilder.free_to_args].
+     */
     toArgs(): GLib.Bytes;
+    /**
+     * Decreases the reference count of a `GskShaderArgBuilder` by one.
+     *
+     * If the resulting reference count is zero, frees the builder.
+     */
     unref(): void;
 }

package/dist/generated/gsk/shader-args-builder.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
+/** Builds the uniforms data for a `GskGLShader`. */
 export class ShaderArgsBuilder {
     ptr;
     constructor(...args) {
@@ -26,6 +27,9 @@ export class ShaderArgsBuilder {
             },
         ], { type: "boxed", borrowed: true, innerType: "GskShaderArgsBuilder" });
     }
+    /**
+     * Increases the reference count of a `GskShaderArgsBuilder` by one.
+     */
     ref() {
         const ptr = call("libgtk-4.so.1", "gsk_shader_args_builder_ref", [
             {
@@ -40,6 +44,13 @@ export class ShaderArgsBuilder {
         });
         return getObject(ptr, ShaderArgsBuilder);
     }
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of bool type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setBool(idx, value) {
         call("libgtk-4.so.1", "gsk_shader_args_builder_set_bool", [
             {
@@ -56,6 +67,13 @@ export class ShaderArgsBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of float type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setFloat(idx, value) {
         call("libgtk-4.so.1", "gsk_shader_args_builder_set_float", [
             {
@@ -72,6 +90,13 @@ export class ShaderArgsBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of int type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setInt(idx, value) {
         call("libgtk-4.so.1", "gsk_shader_args_builder_set_int", [
             {
@@ -88,6 +113,13 @@ export class ShaderArgsBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of uint type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform to
+     */
     setUint(idx, value) {
         call("libgtk-4.so.1", "gsk_shader_args_builder_set_uint", [
             {
@@ -104,6 +136,13 @@ export class ShaderArgsBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of vec2 type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform too
+     */
     setVec2(idx, value) {
         call("libgtk-4.so.1", "gsk_shader_args_builder_set_vec2", [
             {
@@ -125,6 +164,13 @@ export class ShaderArgsBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of vec3 type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform too
+     */
     setVec3(idx, value) {
         call("libgtk-4.so.1", "gsk_shader_args_builder_set_vec3", [
             {
@@ -146,6 +192,13 @@ export class ShaderArgsBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the value of the uniform @idx.
+     *
+     * The uniform must be of vec4 type.
+     * @param idx - index of the uniform
+     * @param value - value to set the uniform too
+     */
     setVec4(idx, value) {
         call("libgtk-4.so.1", "gsk_shader_args_builder_set_vec4", [
             {
@@ -167,6 +220,19 @@ export class ShaderArgsBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a new `GBytes` args from the current state of the
+     * given @builder.
+     *
+     * Any uniforms of the shader that have not been explicitly set on
+     * the `builder` are zero-initialized.
+     *
+     * The given `GskShaderArgsBuilder` is reset once this function returns;
+     * you cannot call this function multiple times on the same `builder` instance.
+     *
+     * This function is intended primarily for bindings. C code should use
+     * [method@Gsk.ShaderArgsBuilder.free_to_args].
+     */
     toArgs() {
         const ptr = call("libgtk-4.so.1", "gsk_shader_args_builder_to_args", [
             {
@@ -181,6 +247,11 @@ export class ShaderArgsBuilder {
         });
         return getObject(ptr, GLib.Bytes);
     }
+    /**
+     * Decreases the reference count of a `GskShaderArgBuilder` by one.
+     *
+     * If the resulting reference count is zero, frees the builder.
+     */
     unref() {
         call("libgtk-4.so.1", "gsk_shader_args_builder_unref", [
             {

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

@@ -1,9 +1,27 @@
 import { RenderNode } from "./render-node.js";
+/** A render node drawing one or more shadows behind its single child node. */
 export declare class ShadowNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will draw a `child` with the given
+     * `shadows` below it.
+     * @param child - The node to draw
+     * @param shadows - The shadows to apply
+     * @param nShadows - number of entries in the `shadows` array
+     */
     constructor(child: RenderNode, shadows: number[], nShadows: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the child `GskRenderNode` of the shadow @node.
+     */
     getChild(): RenderNode;
+    /**
+     * Retrieves the number of shadows in the @node.
+     */
     getNShadows(): number;
+    /**
+     * Retrieves the shadow data at the given index @i.
+     * @param i - the given index
+     */
     getShadow(i: number): number;
 }

package/dist/generated/gsk/shadow-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 drawing one or more shadows behind its single child node. */
 export class ShadowNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -25,6 +26,9 @@ export class ShadowNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the child `GskRenderNode` of the shadow @node.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gsk_shadow_node_get_child", [
             {
@@ -34,6 +38,9 @@ export class ShadowNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the number of shadows in the @node.
+     */
     getNShadows() {
         return call("libgtk-4.so.1", "gsk_shadow_node_get_n_shadows", [
             {
@@ -42,6 +49,10 @@ export class ShadowNode extends RenderNode {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Retrieves the shadow data at the given index @i.
+     * @param i - the given index
+     */
     getShadow(i) {
         return call("libgtk-4.so.1", "gsk_shadow_node_get_shadow", [
             {