@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/graphene/vec4.js

@@ -1,7 +1,20 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A structure capable of holding a vector with four dimensions: x, y, z, and w.
+ *
+ * The contents of the #graphene_vec4_t structure are private and should
+ * never be accessed directly.
+ */
 export class Vec4 {
     ptr;
+    /**
+     * Allocates a new #graphene_vec4_t structure.
+     *
+     * The contents of the returned structure are undefined.
+     *
+     * Use graphene_vec4_init() to initialize the vector.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +25,10 @@ export class Vec4 {
             innerType: "GrapheneVec4",
         });
     }
+    /**
+     * Retrieves a pointer to a #graphene_vec4_t with all its
+     * components set to 1.
+     */
     static one() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_one", [], {
             type: "boxed",
@@ -21,6 +38,10 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Retrieves a pointer to a #graphene_vec4_t with its
+     * components set to (0, 0, 0, 1).
+     */
     static wAxis() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_w_axis", [], {
             type: "boxed",
@@ -30,6 +51,10 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Retrieves a pointer to a #graphene_vec4_t with its
+     * components set to (1, 0, 0, 0).
+     */
     static xAxis() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_x_axis", [], {
             type: "boxed",
@@ -39,6 +64,10 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Retrieves a pointer to a #graphene_vec4_t with its
+     * components set to (0, 1, 0, 0).
+     */
     static yAxis() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_y_axis", [], {
             type: "boxed",
@@ -48,6 +77,10 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Retrieves a pointer to a #graphene_vec4_t with its
+     * components set to (0, 0, 1, 0).
+     */
     static zAxis() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_z_axis", [], {
             type: "boxed",
@@ -57,6 +90,10 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Retrieves a pointer to a #graphene_vec4_t with all its
+     * components set to 0.
+     */
     static zero() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_zero", [], {
             type: "boxed",
@@ -66,6 +103,11 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Adds each component of the two given vectors.
+     * @param b - a #graphene_vec4_t
+     * @param res - return location for the resulting vector
+     */
     add(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_add", [
             {
@@ -94,6 +136,13 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Divides each component of the first operand `a` by the corresponding
+     * component of the second operand @b, and places the results into the
+     * vector @res.
+     * @param b - a #graphene_vec4_t
+     * @param res - return location for the resulting vector
+     */
     divide(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_divide", [
             {
@@ -122,6 +171,10 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the dot product of the two given vectors.
+     * @param b - a #graphene_vec4_t
+     */
     dot(b) {
         return call("libgraphene-1.0.so.0", "graphene_vec4_dot", [
             {
@@ -139,6 +192,10 @@ export class Vec4 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Checks whether the two given #graphene_vec4_t are equal.
+     * @param v2 - a #graphene_vec4_t
+     */
     equal(v2) {
         return call("libgraphene-1.0.so.0", "graphene_vec4_equal", [
             {
@@ -156,6 +213,9 @@ export class Vec4 {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Frees the resources allocated by @v
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_vec4_free", [
             {
@@ -164,6 +224,9 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the value of the fourth component of the given #graphene_vec4_t.
+     */
     getW() {
         return call("libgraphene-1.0.so.0", "graphene_vec4_get_w", [
             {
@@ -172,6 +235,9 @@ export class Vec4 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the value of the first component of the given #graphene_vec4_t.
+     */
     getX() {
         return call("libgraphene-1.0.so.0", "graphene_vec4_get_x", [
             {
@@ -180,6 +246,11 @@ export class Vec4 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Creates a #graphene_vec2_t that contains the first two components
+     * of the given #graphene_vec4_t.
+     * @param res - return location for a #graphene_vec2_t
+     */
     getXy(res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_get_xy", [
             {
@@ -199,6 +270,11 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a #graphene_vec3_t that contains the first three components
+     * of the given #graphene_vec4_t.
+     * @param res - return location for a graphene_vec3_t
+     */
     getXyz(res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_get_xyz", [
             {
@@ -218,6 +294,9 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the value of the second component of the given #graphene_vec4_t.
+     */
     getY() {
         return call("libgraphene-1.0.so.0", "graphene_vec4_get_y", [
             {
@@ -226,6 +305,9 @@ export class Vec4 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the value of the third component of the given #graphene_vec4_t.
+     */
     getZ() {
         return call("libgraphene-1.0.so.0", "graphene_vec4_get_z", [
             {
@@ -234,6 +316,15 @@ export class Vec4 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Initializes a #graphene_vec4_t using the given values.
+     *
+     * This function can be called multiple times.
+     * @param x - the X field of the vector
+     * @param y - the Y field of the vector
+     * @param z - the Z field of the vector
+     * @param w - the W field of the vector
+     */
     init(x, y, z, w) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_init", [
             {
@@ -264,6 +355,10 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Initializes a #graphene_vec4_t with the values inside the given array.
+     * @param src - an array of four floating point values
+     */
     initFromFloat(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_init_from_float", [
             {
@@ -282,6 +377,13 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Initializes a #graphene_vec4_t using the components of a
+     * #graphene_vec2_t and the values of `z` and @w.
+     * @param src - a #graphene_vec2_t
+     * @param z - the value for the third component of @v
+     * @param w - the value for the fourth component of @v
+     */
     initFromVec2(src, z, w) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_init_from_vec2", [
             {
@@ -313,6 +415,12 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Initializes a #graphene_vec4_t using the components of a
+     * #graphene_vec3_t and the value of @w.
+     * @param src - a #graphene_vec3_t
+     * @param w - the value for the fourth component of @v
+     */
     initFromVec3(src, w) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_init_from_vec3", [
             {
@@ -340,6 +448,11 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Initializes a #graphene_vec4_t using the components of
+     * another #graphene_vec4_t.
+     * @param src - a #graphene_vec4_t
+     */
     initFromVec4(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_vec4_init_from_vec4", [
             {
@@ -363,6 +476,12 @@ export class Vec4 {
         });
         return getObject(ptr, Vec4);
     }
+    /**
+     * Linearly interpolates `v1` and `v2` using the given @factor.
+     * @param v2 - a #graphene_vec4_t
+     * @param factor - the interpolation factor
+     * @param res - the interpolated vector
+     */
     interpolate(v2, factor, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_interpolate", [
             {
@@ -395,6 +514,9 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the length of the given #graphene_vec4_t.
+     */
     length() {
         return call("libgraphene-1.0.so.0", "graphene_vec4_length", [
             {
@@ -403,6 +525,12 @@ export class Vec4 {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Compares each component of the two given vectors and creates a
+     * vector that contains the maximum values.
+     * @param b - a #graphene_vec4_t
+     * @param res - return location for the result vector
+     */
     max(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_max", [
             {
@@ -431,6 +559,12 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compares each component of the two given vectors and creates a
+     * vector that contains the minimum values.
+     * @param b - a #graphene_vec4_t
+     * @param res - return location for the result vector
+     */
     min(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_min", [
             {
@@ -459,6 +593,11 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Multiplies each component of the two given vectors.
+     * @param b - a #graphene_vec4_t
+     * @param res - return location for the resulting vector
+     */
     multiply(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_multiply", [
             {
@@ -487,6 +626,12 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compares the two given #graphene_vec4_t vectors and checks
+     * whether their values are within the given @epsilon.
+     * @param v2 - a #graphene_vec4_t
+     * @param epsilon - the threshold between the two vectors
+     */
     near(v2, epsilon) {
         return call("libgraphene-1.0.so.0", "graphene_vec4_near", [
             {
@@ -508,6 +653,10 @@ export class Vec4 {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Negates the given #graphene_vec4_t.
+     * @param res - return location for the result vector
+     */
     negate(res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_negate", [
             {
@@ -527,6 +676,10 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Normalizes the given #graphene_vec4_t.
+     * @param res - return location for the normalized
+     */
     normalize(res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_normalize", [
             {
@@ -546,6 +699,11 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Multiplies all components of the given vector with the given scalar @factor.
+     * @param factor - the scalar factor
+     * @param res - return location for the result vector
+     */
     scale(factor, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_scale", [
             {
@@ -569,6 +727,13 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Subtracts from each component of the first operand `a` the
+     * corresponding component of the second operand `b` and places
+     * each result into the components of @res.
+     * @param b - a #graphene_vec4_t
+     * @param res - return location for the resulting vector
+     */
     subtract(b, res) {
         call("libgraphene-1.0.so.0", "graphene_vec4_subtract", [
             {
@@ -597,6 +762,11 @@ export class Vec4 {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Stores the components of the given #graphene_vec4_t into an array
+     * of floating point values.
+     * @param dest - return location for
+     */
     toFloat(dest) {
         call("libgraphene-1.0.so.0", "graphene_vec4_to_float", [
             {

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

@@ -1,10 +1,26 @@
 import { BlendMode } from "./enums.js";
 import { RenderNode } from "./render-node.js";
+/** A render node applying a blending function between its two child nodes. */
 export declare class BlendNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will use `blend_mode` to blend the `top` node onto the `bottom` node.
+     * @param bottom - The bottom node to be drawn
+     * @param top - The node to be blended onto the `bottom` node
+     * @param blendMode - The blend mode to use
+     */
     constructor(bottom: RenderNode, top: RenderNode, blendMode: BlendMode);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the blend mode used by @node.
+     */
     getBlendMode(): BlendMode;
+    /**
+     * Retrieves the bottom `GskRenderNode` child of the @node.
+     */
     getBottomChild(): RenderNode;
+    /**
+     * Retrieves the top `GskRenderNode` child of the @node.
+     */
     getTopChild(): RenderNode;
 }

package/dist/generated/gsk/blend-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 blending function between its two child nodes. */
 export class BlendNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -22,6 +23,9 @@ export class BlendNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the blend mode used by @node.
+     */
     getBlendMode() {
         return call("libgtk-4.so.1", "gsk_blend_node_get_blend_mode", [
             {
@@ -30,6 +34,9 @@ export class BlendNode extends RenderNode {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the bottom `GskRenderNode` child of the @node.
+     */
     getBottomChild() {
         const ptr = call("libgtk-4.so.1", "gsk_blend_node_get_bottom_child", [
             {
@@ -39,6 +46,9 @@ export class BlendNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the top `GskRenderNode` child of the @node.
+     */
     getTopChild() {
         const ptr = call("libgtk-4.so.1", "gsk_blend_node_get_top_child", [
             {

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

@@ -1,8 +1,20 @@
 import { RenderNode } from "./render-node.js";
+/** A render node applying a blur effect to its single child. */
 export declare class BlurNode extends RenderNode {
+    /**
+     * Creates a render node that blurs the child.
+     * @param child - the child node to blur
+     * @param radius - the blur radius. Must be positive
+     */
     constructor(child: RenderNode, radius: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the child `GskRenderNode` of the blur @node.
+     */
     getChild(): RenderNode;
+    /**
+     * Retrieves the blur radius of the @node.
+     */
     getRadius(): number;
 }

package/dist/generated/gsk/blur-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 blur effect to its single child. */
 export class BlurNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -18,6 +19,9 @@ export class BlurNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the child `GskRenderNode` of the blur @node.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gsk_blur_node_get_child", [
             {
@@ -27,6 +31,9 @@ export class BlurNode extends RenderNode {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, RenderNode);
     }
+    /**
+     * Retrieves the blur radius of the @node.
+     */
     getRadius() {
         return call("libgtk-4.so.1", "gsk_blur_node_get_radius", [
             {

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

@@ -1,10 +1,29 @@
 import * as Gdk from "../gdk/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for a border. */
 export declare class BorderNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will stroke a border rectangle inside the
+     * given @outline.
+     *
+     * The 4 sides of the border can have different widths and colors.
+     * @param outline - a `GskRoundedRect` describing the outline of the border
+     * @param borderWidth - the stroke width of the border on
+     * @param borderColor - the color used on the top, right,
+     */
     constructor(outline: number, borderWidth: number[], borderColor: Gdk.RGBA[]);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Retrieves the colors of the border.
+     */
     getColors(): Gdk.RGBA[];
+    /**
+     * Retrieves the outline of the border.
+     */
     getOutline(): number;
+    /**
+     * Retrieves the stroke widths of the border.
+     */
     getWidths(): number[];
 }

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

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { RenderNode } from "./render-node.js";
+/** A render node for a border. */
 export class BorderNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -28,6 +29,9 @@ export class BorderNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Retrieves the colors of the border.
+     */
     getColors() {
         return call("libgtk-4.so.1", "gsk_border_node_get_colors", [
             {
@@ -39,6 +43,9 @@ export class BorderNode extends RenderNode {
             itemType: { type: "boxed", innerType: "GdkRGBA", lib: "libgtk-4.so.1" },
         });
     }
+    /**
+     * Retrieves the outline of the border.
+     */
     getOutline() {
         return call("libgtk-4.so.1", "gsk_border_node_get_outline", [
             {
@@ -47,6 +54,9 @@ export class BorderNode extends RenderNode {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Retrieves the stroke widths of the border.
+     */
     getWidths() {
         return call("libgtk-4.so.1", "gsk_border_node_get_widths", [
             {

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

@@ -1,5 +1,20 @@
 import { Renderer } from "./renderer.js";
+/**
+ * A Broadway based renderer.
+ *
+ * See [class@Gsk.Renderer].
+ */
 export declare class BroadwayRenderer extends Renderer {
+    /**
+     * Creates a new Broadway renderer.
+     *
+     * The Broadway renderer is the default renderer for the broadway backend.
+     * It will only work with broadway surfaces, otherwise it will fail the
+     * call to gsk_renderer_realize().
+     *
+     * This function is only available when GTK was compiled with Broadway
+     * support.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
 }

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

@@ -1,6 +1,21 @@
 import { call } from "@gtkx/native";
 import { Renderer } from "./renderer.js";
+/**
+ * A Broadway based renderer.
+ *
+ * See [class@Gsk.Renderer].
+ */
 export class BroadwayRenderer extends Renderer {
+    /**
+     * Creates a new Broadway renderer.
+     *
+     * The Broadway renderer is the default renderer for the broadway backend.
+     * It will only work with broadway surfaces, otherwise it will fail the
+     * call to gsk_renderer_realize().
+     *
+     * This function is only available when GTK was compiled with Broadway
+     * support.
+     */
     constructor(...args) {
         super(...args);
     }

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

@@ -1,10 +1,28 @@
 import * as Graphene from "../graphene/index.js";
 import * as cairo from "../cairo/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for a Cairo surface. */
 export declare class CairoNode extends RenderNode {
+    /**
+     * Creates a `GskRenderNode` that will render a cairo surface
+     * into the area given by @bounds.
+     *
+     * You can draw to the cairo surface using [method@Gsk.CairoNode.get_draw_context].
+     * @param bounds - the rectangle to render to
+     */
     constructor(bounds: Graphene.Rect);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Creates a Cairo context for drawing using the surface associated
+     * to the render node.
+     *
+     * If no surface exists yet, a surface will be created optimized for
+     * rendering to @renderer.
+     */
     getDrawContext(): cairo.Context;
+    /**
+     * Retrieves the Cairo surface used by the render node.
+     */
     getSurface(): cairo.Surface;
 }

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

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as cairo from "../cairo/index.js";
 import { RenderNode } from "./render-node.js";
+/** A render node for a Cairo surface. */
 export class CairoNode extends RenderNode {
     constructor(...args) {
         super(...args);
@@ -20,6 +21,13 @@ export class CairoNode extends RenderNode {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Creates a Cairo context for drawing using the surface associated
+     * to the render node.
+     *
+     * If no surface exists yet, a surface will be created optimized for
+     * rendering to @renderer.
+     */
     getDrawContext() {
         const ptr = call("libgtk-4.so.1", "gsk_cairo_node_get_draw_context", [
             {
@@ -34,6 +42,9 @@ export class CairoNode extends RenderNode {
         });
         return getObject(ptr, cairo.Context);
     }
+    /**
+     * Retrieves the Cairo surface used by the render node.
+     */
     getSurface() {
         const ptr = call("libgtk-4.so.1", "gsk_cairo_node_get_surface", [
             {