@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gsk/glshader.js

@@ -2,10 +2,128 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * Implements a fragment shader using GLSL.
+ *
+ * A fragment shader gets the coordinates being rendered as input and
+ * produces the pixel values for that particular pixel. Additionally,
+ * the shader can declare a set of other input arguments, called
+ * uniforms (as they are uniform over all the calls to your shader in
+ * each instance of use). A shader can also receive up to 4
+ * textures that it can use as input when producing the pixel data.
+ *
+ * `GskGLShader` is usually used with gtk_snapshot_push_gl_shader()
+ * to produce a [class@Gsk.GLShaderNode] in the rendering hierarchy,
+ * and then its input textures are constructed by rendering the child
+ * nodes to textures before rendering the shader node itself. (You can
+ * pass texture nodes as children if you want to directly use a texture
+ * as input).
+ *
+ * The actual shader code is GLSL code that gets combined with
+ * some other code into the fragment shader. Since the exact
+ * capabilities of the GPU driver differs between different OpenGL
+ * drivers and hardware, GTK adds some defines that you can use
+ * to ensure your GLSL code runs on as many drivers as it can.
+ *
+ * If the OpenGL driver is GLES, then the shader language version
+ * is set to 100, and GSK_GLES will be defined in the shader.
+ *
+ * Otherwise, if the OpenGL driver does not support the 3.2 core profile,
+ * then the shader will run with language version 110 for GL2 and 130 for GL3,
+ * and GSK_LEGACY will be defined in the shader.
+ *
+ * If the OpenGL driver supports the 3.2 code profile, it will be used,
+ * the shader language version is set to 150, and GSK_GL3 will be defined
+ * in the shader.
+ *
+ * The main function the shader must implement is:
+ *
+ * ```glsl
+ * void mainImage(out vec4 fragColor,
+ * in vec2 fragCoord,
+ * in vec2 resolution,
+ * in vec2 uv)
+ * ```
+ *
+ * Where the input `fragCoord` is the coordinate of the pixel we're
+ * currently rendering, relative to the boundary rectangle that was
+ * specified in the `GskGLShaderNode`, and `resolution` is the width and
+ * height of that rectangle. This is in the typical GTK coordinate
+ * system with the origin in the top left. `uv` contains the u and v
+ * coordinates that can be used to index a texture at the
+ * corresponding point. These coordinates are in the [0..1]x[0..1]
+ * region, with 0, 0 being in the lower left corder (which is typical
+ * for OpenGL).
+ *
+ * The output `fragColor` should be a RGBA color (with
+ * premultiplied alpha) that will be used as the output for the
+ * specified pixel location. Note that this output will be
+ * automatically clipped to the clip region of the glshader node.
+ *
+ * In addition to the function arguments the shader can define
+ * up to 4 uniforms for textures which must be called u_textureN
+ * (i.e. u_texture1 to u_texture4) as well as any custom uniforms
+ * you want of types int, uint, bool, float, vec2, vec3 or vec4.
+ *
+ * All textures sources contain premultiplied alpha colors, but if some
+ * there are outer sources of colors there is a gsk_premultiply() helper
+ * to compute premultiplication when needed.
+ *
+ * Note that GTK parses the uniform declarations, so each uniform has to
+ * be on a line by itself with no other code, like so:
+ *
+ * ```glsl
+ * uniform float u_time;
+ * uniform vec3 u_color;
+ * uniform sampler2D u_texture1;
+ * uniform sampler2D u_texture2;
+ * ```
+ *
+ * GTK uses the "gsk" namespace in the symbols it uses in the
+ * shader, so your code should not use any symbols with the prefix gsk
+ * or GSK. There are some helper functions declared that you can use:
+ *
+ * ```glsl
+ * vec4 GskTexture(sampler2D sampler, vec2 texCoords);
+ * ```
+ *
+ * This samples a texture (e.g. u_texture1) at the specified
+ * coordinates, and contains some helper ifdefs to ensure that
+ * it works on all OpenGL versions.
+ *
+ * You can compile the shader yourself using [method@Gsk.GLShader.compile],
+ * otherwise the GSK renderer will do it when it handling the glshader
+ * node. If errors occurs, the returned `error` will include the glsl
+ * sources, so you can see what GSK was passing to the compiler. You
+ * can also set GSK_DEBUG=shaders in the environment to see the sources
+ * and other relevant information about all shaders that GSK is handling.
+ *
+ * # An example shader
+ *
+ * ```glsl
+ * uniform float position;
+ * uniform sampler2D u_texture1;
+ * uniform sampler2D u_texture2;
+ *
+ * void mainImage(out vec4 fragColor,
+ * in vec2 fragCoord,
+ * in vec2 resolution,
+ * in vec2 uv) {
+ * vec4 source1 = GskTexture(u_texture1, uv);
+ * vec4 source2 = GskTexture(u_texture2, uv);
+ *
+ * fragColor = position * source1 + (1.0 - position) * source2;
+ * }
+ * ```
+ */
 export class GLShader extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Creates a `GskGLShader` that will render pixels using the specified code.
+     * @param resourcePath - path to a resource that contains the GLSL sourcecode for
+     */
     static shaderNewFromResource(resourcePath) {
         const ptr = call("libgtk-4.so.1", "gsk_gl_shader_new_from_resource", [
             {
@@ -29,6 +147,21 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Tries to compile the `shader` for the given @renderer.
+     *
+     * If there is a problem, this function returns %FALSE and reports
+     * an error. You should use this function before relying on the shader
+     * for rendering and use a fallback with a simpler shader or without
+     * shaders if it fails.
+     *
+     * Note that this will modify the rendering state (for example
+     * change the current GL context) and requires the renderer to be
+     * set up. This means that the widget has to be realized. Commonly you
+     * want to call this from the realize signal of a widget, or during
+     * widget snapshot.
+     * @param renderer - a `GskRenderer`
+     */
     compile(renderer) {
         const error = { value: null };
         const result = call("libgtk-4.so.1", "gsk_gl_shader_compile", [
@@ -57,6 +190,11 @@ export class GLShader extends GObject.GObject {
         }
         return result;
     }
+    /**
+     * Looks for a uniform by the name @name, and returns the index
+     * of the uniform, or -1 if it was not found.
+     * @param name - uniform name
+     */
     findUniformByName(name) {
         return call("libgtk-4.so.1", "gsk_gl_shader_find_uniform_by_name", [
             {
@@ -69,6 +207,13 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the value of the uniform `idx` in the `args` block.
+     *
+     * The uniform must be of bool type.
+     * @param args - uniform arguments
+     * @param idx - index of the uniform
+     */
     getArgBool(args, idx) {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_arg_bool", [
             {
@@ -90,6 +235,13 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the value of the uniform `idx` in the `args` block.
+     *
+     * The uniform must be of float type.
+     * @param args - uniform arguments
+     * @param idx - index of the uniform
+     */
     getArgFloat(args, idx) {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_arg_float", [
             {
@@ -111,6 +263,13 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Gets the value of the uniform `idx` in the `args` block.
+     *
+     * The uniform must be of int type.
+     * @param args - uniform arguments
+     * @param idx - index of the uniform
+     */
     getArgInt(args, idx) {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_arg_int", [
             {
@@ -132,6 +291,13 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the value of the uniform `idx` in the `args` block.
+     *
+     * The uniform must be of uint type.
+     * @param args - uniform arguments
+     * @param idx - index of the uniform
+     */
     getArgUint(args, idx) {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_arg_uint", [
             {
@@ -153,6 +319,14 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the value of the uniform `idx` in the `args` block.
+     *
+     * The uniform must be of vec2 type.
+     * @param args - uniform arguments
+     * @param idx - index of the uniform
+     * @param outValue - location to store the uniform value in
+     */
     getArgVec2(args, idx, outValue) {
         call("libgtk-4.so.1", "gsk_gl_shader_get_arg_vec2", [
             {
@@ -183,6 +357,14 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the value of the uniform `idx` in the `args` block.
+     *
+     * The uniform must be of vec3 type.
+     * @param args - uniform arguments
+     * @param idx - index of the uniform
+     * @param outValue - location to store the uniform value in
+     */
     getArgVec3(args, idx, outValue) {
         call("libgtk-4.so.1", "gsk_gl_shader_get_arg_vec3", [
             {
@@ -213,6 +395,14 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the value of the uniform `idx` in the `args` block.
+     *
+     * The uniform must be of vec4 type.
+     * @param args - uniform arguments
+     * @param idx - index of the uniform
+     * @param outValue - location to store set the uniform value in
+     */
     getArgVec4(args, idx, outValue) {
         call("libgtk-4.so.1", "gsk_gl_shader_get_arg_vec4", [
             {
@@ -243,6 +433,9 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Get the size of the data block used to specify arguments for this shader.
+     */
     getArgsSize() {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_args_size", [
             {
@@ -251,6 +444,13 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Returns the number of textures that the shader requires.
+     *
+     * This can be used to check that the a passed shader works
+     * in your usecase. It is determined by looking at the highest
+     * u_textureN value that the shader defines.
+     */
     getNTextures() {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_n_textures", [
             {
@@ -259,6 +459,9 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Get the number of declared uniforms for this shader.
+     */
     getNUniforms() {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_n_uniforms", [
             {
@@ -267,6 +470,10 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the resource path for the GLSL sourcecode being used
+     * to render this shader.
+     */
     getResource() {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_resource", [
             {
@@ -275,6 +482,9 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the GLSL sourcecode being used to render this shader.
+     */
     getSource() {
         const ptr = call("libgtk-4.so.1", "gsk_gl_shader_get_source", [
             {
@@ -289,6 +499,10 @@ export class GLShader extends GObject.GObject {
         });
         return getObject(ptr, GLib.Bytes);
     }
+    /**
+     * Get the name of the declared uniform for this shader at index @idx.
+     * @param idx - index of the uniform
+     */
     getUniformName(idx) {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_uniform_name", [
             {
@@ -301,6 +515,10 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Get the offset into the data block where data for this uniforms is stored.
+     * @param idx - index of the uniform
+     */
     getUniformOffset(idx) {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_uniform_offset", [
             {
@@ -313,6 +531,10 @@ export class GLShader extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Get the type of the declared uniform for this shader at index @idx.
+     * @param idx - index of the uniform
+     */
     getUniformType(idx) {
         return call("libgtk-4.so.1", "gsk_gl_shader_get_uniform_type", [
             {

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

@@ -1,13 +1,45 @@
 import * as Gdk from "../gdk/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for an inset shadow. */
 export declare class InsetShadowNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will render an inset shadow
+     * into the box given by @outline.
+     * @param outline - outline of the region containing the shadow
+     * @param color - color of the shadow
+     * @param dx - horizontal offset of shadow
+     * @param dy - vertical offset of shadow
+     * @param spread - how far the shadow spreads towards the inside
+     * @param blurRadius - how much blur to apply to the shadow
+     */
     constructor(outline: number, color: Gdk.RGBA, dx: number, dy: number, spread: number, blurRadius: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the blur radius to apply to the shadow.
+     */
     getBlurRadius(): number;
+    /**
+     * Retrieves the color of the inset shadow.
+     *
+     * The value returned by this function will not be correct
+     * if the render node was created for a non-sRGB color.
+     */
     getColor(): Gdk.RGBA;
+    /**
+     * Retrieves the horizontal offset of the inset shadow.
+     */
     getDx(): number;
+    /**
+     * Retrieves the vertical offset of the inset shadow.
+     */
     getDy(): number;
+    /**
+     * Retrieves the outline rectangle of the inset shadow.
+     */
     getOutline(): number;
+    /**
+     * Retrieves how much the shadow spreads inwards.
+     */
     getSpread(): number;
 }

package/dist/generated/gsk/inset-shadow-node.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Gdk from "../gdk/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for an inset shadow. */
 export class InsetShadowNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -40,6 +41,9 @@ export class InsetShadowNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the blur radius to apply to the shadow.
+     */
     getBlurRadius() {
         return call("libgtk-4.so.1", "gsk_inset_shadow_node_get_blur_radius", [
             {
@@ -48,6 +52,12 @@ export class InsetShadowNode extends RenderNode {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the color of the inset shadow.
+     *
+     * The value returned by this function will not be correct
+     * if the render node was created for a non-sRGB color.
+     */
     getColor() {
         const ptr = call("libgtk-4.so.1", "gsk_inset_shadow_node_get_color", [
             {
@@ -62,6 +72,9 @@ export class InsetShadowNode extends RenderNode {
         });
         return getObject(ptr, Gdk.RGBA);
     }
+    /**
+     * Retrieves the horizontal offset of the inset shadow.
+     */
     getDx() {
         return call("libgtk-4.so.1", "gsk_inset_shadow_node_get_dx", [
             {
@@ -70,6 +83,9 @@ export class InsetShadowNode extends RenderNode {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the vertical offset of the inset shadow.
+     */
     getDy() {
         return call("libgtk-4.so.1", "gsk_inset_shadow_node_get_dy", [
             {
@@ -78,6 +94,9 @@ export class InsetShadowNode extends RenderNode {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the outline rectangle of the inset shadow.
+     */
     getOutline() {
         return call("libgtk-4.so.1", "gsk_inset_shadow_node_get_outline", [
             {
@@ -86,6 +105,9 @@ export class InsetShadowNode extends RenderNode {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Retrieves how much the shadow spreads inwards.
+     */
     getSpread() {
         return call("libgtk-4.so.1", "gsk_inset_shadow_node_get_spread", [
             {

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

@@ -1,12 +1,35 @@
 import { Ref } from "@gtkx/native";
 import * as Graphene from "../graphene/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for a linear gradient. */
 export declare class LinearGradientNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will create a 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;
+    /**
+     * Retrieves the color stops in the gradient.
+     * @param nStops - the number of color stops in the returned array
+     */
     getColorStops(nStops?: Ref<number> | null): number[];
+    /**
+     * Retrieves the final point of the linear gradient.
+     */
     getEnd(): Graphene.Point;
+    /**
+     * Retrieves the number of color stops in the gradient.
+     */
     getNColorStops(): number;
+    /**
+     * Retrieves the initial point of the linear gradient.
+     */
     getStart(): Graphene.Point;
 }

package/dist/generated/gsk/linear-gradient-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 for a linear gradient. */
 export class LinearGradientNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -49,6 +50,10 @@ export class LinearGradientNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the color stops in the gradient.
+     * @param nStops - the number of color stops in the returned array
+     */
     getColorStops(nStops) {
         return call("libgtk-4.so.1", "gsk_linear_gradient_node_get_color_stops", [
             {
@@ -65,6 +70,9 @@ export class LinearGradientNode extends RenderNode {
             },
         ], { type: "array", itemType: { type: "int", size: 64, unsigned: true } });
     }
+    /**
+     * Retrieves the final point of the linear gradient.
+     */
     getEnd() {
         const ptr = call("libgtk-4.so.1", "gsk_linear_gradient_node_get_end", [
             {
@@ -79,6 +87,9 @@ export class LinearGradientNode extends RenderNode {
         });
         return getObject(ptr, Graphene.Point);
     }
+    /**
+     * Retrieves the number of color stops in the gradient.
+     */
     getNColorStops() {
         return call("libgtk-4.so.1", "gsk_linear_gradient_node_get_n_color_stops", [
             {
@@ -87,6 +98,9 @@ export class LinearGradientNode extends RenderNode {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Retrieves the initial point of the linear gradient.
+     */
     getStart() {
         const ptr = call("libgtk-4.so.1", "gsk_linear_gradient_node_get_start", [
             {

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

@@ -1,10 +1,30 @@
 import { MaskMode } from "./enums.js";
 import { RenderNode } from "./render-node.js";
+/** A render node masking one child node with another. */
 export declare class MaskNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will mask a given node by another.
+     *
+     * The `mask_mode` determines how the 'mask values' are derived from
+     * the colors of the @mask. Applying the mask consists of multiplying
+     * the 'mask value' with the alpha of the source.
+     * @param source - The source node to be drawn
+     * @param mask - The node to be used as mask
+     * @param maskMode - The mask mode to use
+     */
     constructor(source: RenderNode, mask: RenderNode, maskMode: MaskMode);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the mask `GskRenderNode` child of the @node.
+     */
     getMask(): RenderNode;
+    /**
+     * Retrieves the mask mode used by @node.
+     */
     getMaskMode(): MaskMode;
+    /**
+     * Retrieves the source `GskRenderNode` child of the @node.
+     */
     getSource(): RenderNode;
 }

package/dist/generated/gsk/mask-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 masking one child node with another. */
 export class MaskNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -22,6 +23,9 @@ export class MaskNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the mask `GskRenderNode` child of the @node.
+     */
     getMask() {
         const ptr = call("libgtk-4.so.1", "gsk_mask_node_get_mask", [
             {
@@ -31,6 +35,9 @@ export class MaskNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the mask mode used by @node.
+     */
     getMaskMode() {
         return call("libgtk-4.so.1", "gsk_mask_node_get_mask_mode", [
             {
@@ -39,6 +46,9 @@ export class MaskNode extends RenderNode {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the source `GskRenderNode` child of the @node.
+     */
     getSource() {
         const ptr = call("libgtk-4.so.1", "gsk_mask_node_get_source", [
             {

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

@@ -1,5 +1,13 @@
 import { Renderer } from "./renderer.js";
+/**
+ * A GL based renderer.
+ *
+ * See [class@Gsk.Renderer].
+ */
 export declare class NglRenderer extends Renderer {
+    /**
+     * Same as gsk_gl_renderer_new().
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
 }

package/dist/generated/gsk/ngl-renderer.js

@@ -1,6 +1,14 @@
 import { call } from "@gtkx/native";
 import { Renderer } from "./renderer.js";
+/**
+ * A GL based renderer.
+ *
+ * See [class@Gsk.Renderer].
+ */
 export class NglRenderer extends Renderer {
+    /**
+     * Same as gsk_gl_renderer_new().
+     */
     constructor(...args) {
         super(...args);
     }

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

@@ -1,8 +1,21 @@
 import { RenderNode } from "./render-node.js";
+/** A render node controlling the opacity of its single child node. */
 export declare class OpacityNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will drawn the `child` with reduced
+     * @opacity.
+     * @param child - The node to draw
+     * @param opacity - The opacity to apply
+     */
     constructor(child: RenderNode, opacity: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the child node that is getting opacityed by the given @node.
+     */
     getChild(): RenderNode;
+    /**
+     * Gets the transparency factor for an opacity node.
+     */
     getOpacity(): number;
 }

package/dist/generated/gsk/opacity-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 controlling the opacity of its single child node. */
 export class OpacityNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -18,6 +19,9 @@ export class OpacityNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the child node that is getting opacityed by the given @node.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gsk_opacity_node_get_child", [
             {
@@ -27,6 +31,9 @@ export class OpacityNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Gets the transparency factor for an opacity node.
+     */
     getOpacity() {
         return call("libgtk-4.so.1", "gsk_opacity_node_get_opacity", [
             {