@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/graphene/rect.js

@@ -1,5 +1,19 @@
 import { alloc, call, read } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * The location and size of a rectangle region.
+ *
+ * The width and height of a #graphene_rect_t can be negative; for instance,
+ * a #graphene_rect_t with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
+ * equivalent to a #graphene_rect_t with an origin of [ 10, 10 ] and a size
+ * of [ -10, -10 ].
+ *
+ * Application code can normalize rectangles using graphene_rect_normalize();
+ * this function will ensure that the width and height of a rectangle are
+ * positive values. All functions taking a #graphene_rect_t as an argument
+ * will internally operate on a normalized copy; all functions returning a
+ * #graphene_rect_t will always return a normalized rectangle.
+ */
 export class Rect {
     ptr;
     constructor() {
@@ -8,6 +22,11 @@ export class Rect {
     createPtr(_init) {
         return alloc(16, "GrapheneRect", "libgraphene-1.0.so.0");
     }
+    /**
+     * Allocates a new #graphene_rect_t.
+     *
+     * The contents of the returned rectangle are undefined.
+     */
     static alloc() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_alloc", [], {
             type: "boxed",
@@ -17,6 +36,10 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Returns a degenerate rectangle with origin fixed at (0, 0) and
+     * a size of 0, 0.
+     */
     static zero() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_zero", [], {
             type: "boxed",
@@ -26,6 +49,10 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Checks whether a #graphene_rect_t contains the given coordinates.
+     * @param p - a #graphene_point_t
+     */
     containsPoint(p) {
         return call("libgraphene-1.0.so.0", "graphene_rect_contains_point", [
             {
@@ -43,6 +70,11 @@ export class Rect {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether a #graphene_rect_t fully contains the given
+     * rectangle.
+     * @param b - a #graphene_rect_t
+     */
     containsRect(b) {
         return call("libgraphene-1.0.so.0", "graphene_rect_contains_rect", [
             {
@@ -60,6 +92,10 @@ export class Rect {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks whether the two given rectangle are equal.
+     * @param b - a #graphene_rect_t
+     */
     equal(b) {
         return call("libgraphene-1.0.so.0", "graphene_rect_equal", [
             {
@@ -77,6 +113,11 @@ export class Rect {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Expands a #graphene_rect_t to contain the given #graphene_point_t.
+     * @param p - a #graphene_point_t
+     * @param res - return location for the expanded rectangle
+     */
     expand(p, res) {
         call("libgraphene-1.0.so.0", "graphene_rect_expand", [
             {
@@ -105,6 +146,9 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Frees the resources allocated by graphene_rect_alloc().
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_rect_free", [
             {
@@ -113,6 +157,9 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Compute the area of given normalized rectangle.
+     */
     getArea() {
         return call("libgraphene-1.0.so.0", "graphene_rect_get_area", [
             {
@@ -121,6 +168,10 @@ export class Rect {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the coordinates of the bottom-left corner of the given rectangle.
+     * @param p - return location for a #graphene_point_t
+     */
     getBottomLeft(p) {
         call("libgraphene-1.0.so.0", "graphene_rect_get_bottom_left", [
             {
@@ -140,6 +191,10 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the coordinates of the bottom-right corner of the given rectangle.
+     * @param p - return location for a #graphene_point_t
+     */
     getBottomRight(p) {
         call("libgraphene-1.0.so.0", "graphene_rect_get_bottom_right", [
             {
@@ -159,6 +214,10 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the coordinates of the center of the given rectangle.
+     * @param p - return location for a #graphene_point_t
+     */
     getCenter(p) {
         call("libgraphene-1.0.so.0", "graphene_rect_get_center", [
             {
@@ -178,6 +237,9 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the normalized height of the given rectangle.
+     */
     getHeight() {
         return call("libgraphene-1.0.so.0", "graphene_rect_get_height", [
             {
@@ -186,6 +248,10 @@ export class Rect {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the coordinates of the top-left corner of the given rectangle.
+     * @param p - return location for a #graphene_point_t
+     */
     getTopLeft(p) {
         call("libgraphene-1.0.so.0", "graphene_rect_get_top_left", [
             {
@@ -205,6 +271,10 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the coordinates of the top-right corner of the given rectangle.
+     * @param p - return location for a #graphene_point_t
+     */
     getTopRight(p) {
         call("libgraphene-1.0.so.0", "graphene_rect_get_top_right", [
             {
@@ -224,6 +294,10 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the four vertices of a #graphene_rect_t.
+     * @param vertices - return location for an array
+     */
     getVertices(vertices) {
         call("libgraphene-1.0.so.0", "graphene_rect_get_vertices", [
             {
@@ -246,6 +320,9 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the normalized width of the given rectangle.
+     */
     getWidth() {
         return call("libgraphene-1.0.so.0", "graphene_rect_get_width", [
             {
@@ -254,6 +331,10 @@ export class Rect {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the normalized X coordinate of the origin of the given
+     * rectangle.
+     */
     getX() {
         return call("libgraphene-1.0.so.0", "graphene_rect_get_x", [
             {
@@ -262,6 +343,10 @@ export class Rect {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves the normalized Y coordinate of the origin of the given
+     * rectangle.
+     */
     getY() {
         return call("libgraphene-1.0.so.0", "graphene_rect_get_y", [
             {
@@ -270,6 +355,16 @@ export class Rect {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Initializes the given #graphene_rect_t with the given values.
+     *
+     * This function will implicitly normalize the #graphene_rect_t
+     * before returning.
+     * @param x - the X coordinate of the @graphene_rect_t.origin
+     * @param y - the Y coordinate of the @graphene_rect_t.origin
+     * @param width - the width of the @graphene_rect_t.size
+     * @param height - the height of the @graphene_rect_t.size
+     */
     init(x, y, width, height) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_init", [
             {
@@ -300,6 +395,13 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Initializes `r` using the given `src` rectangle.
+     *
+     * This function will implicitly normalize the #graphene_rect_t
+     * before returning.
+     * @param src - a #graphene_rect_t
+     */
     initFromRect(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_init_from_rect", [
             {
@@ -323,6 +425,23 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Changes the given rectangle to be smaller, or larger depending on the
+     * given inset parameters.
+     *
+     * To create an inset rectangle, use positive `d_x` or `d_y` values; to
+     * create a larger, encompassing rectangle, use negative `d_x` or `d_y` values.
+     *
+     * The origin of the rectangle is offset by `d_x` and @d_y, while the size
+     * is adjusted by `(2 * @d_x, 2 * @d_y)`. If `d_x` and `d_y` are positive
+     * values, the size of the rectangle is decreased; if `d_x` and `d_y` are
+     * negative values, the size of the rectangle is increased.
+     *
+     * If the size of the resulting inset rectangle has a negative width or
+     * height then the size will be set to zero.
+     * @param dX - the horizontal inset
+     * @param dY - the vertical inset
+     */
     inset(dX, dY) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_inset", [
             {
@@ -345,6 +464,24 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Changes the given rectangle to be smaller, or larger depending on the
+     * given inset parameters.
+     *
+     * To create an inset rectangle, use positive `d_x` or `d_y` values; to
+     * create a larger, encompassing rectangle, use negative `d_x` or `d_y` values.
+     *
+     * The origin of the rectangle is offset by `d_x` and @d_y, while the size
+     * is adjusted by `(2 * @d_x, 2 * @d_y)`. If `d_x` and `d_y` are positive
+     * values, the size of the rectangle is decreased; if `d_x` and `d_y` are
+     * negative values, the size of the rectangle is increased.
+     *
+     * If the size of the resulting inset rectangle has a negative width or
+     * height then the size will be set to zero.
+     * @param dX - the horizontal inset
+     * @param dY - the vertical inset
+     * @param res - return location for the inset rectangle
+     */
     insetR(dX, dY, res) {
         call("libgraphene-1.0.so.0", "graphene_rect_inset_r", [
             {
@@ -372,6 +509,13 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Linearly interpolates the origin and size of the two given
+     * rectangles.
+     * @param b - a #graphene_rect_t
+     * @param factor - the linear interpolation factor
+     * @param res - return location for the
+     */
     interpolate(b, factor, res) {
         call("libgraphene-1.0.so.0", "graphene_rect_interpolate", [
             {
@@ -404,6 +548,18 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the intersection of the two given rectangles.
+     *
+     *
+     *
+     * The intersection in the image above is the blue outline.
+     *
+     * If the two rectangles do not intersect, `res` will contain
+     * a degenerate rectangle with origin in (0, 0) and a size of 0.
+     * @param b - a #graphene_rect_t
+     * @param res - return location for
+     */
     intersection(b, res) {
         return call("libgraphene-1.0.so.0", "graphene_rect_intersection", [
             {
@@ -433,6 +589,13 @@ export class Rect {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Normalizes the passed rectangle.
+     *
+     * This function ensures that the size of the rectangle is made of
+     * positive values, and that the origin is the top-left corner of
+     * the rectangle.
+     */
     normalize() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_normalize", [
             {
@@ -447,6 +610,14 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Normalizes the passed rectangle.
+     *
+     * This function ensures that the size of the rectangle is made of
+     * positive values, and that the origin is in the top-left corner
+     * of the rectangle.
+     * @param res - the return location for the
+     */
     normalizeR(res) {
         call("libgraphene-1.0.so.0", "graphene_rect_normalize_r", [
             {
@@ -466,6 +637,13 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Offsets the origin by `d_x` and @d_y.
+     *
+     * The size of the rectangle is unchanged.
+     * @param dX - the horizontal offset
+     * @param dY - the vertical offset
+     */
     offset(dX, dY) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_offset", [
             {
@@ -488,6 +666,14 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Offsets the origin of the given rectangle by `d_x` and @d_y.
+     *
+     * The size of the rectangle is left unchanged.
+     * @param dX - the horizontal offset
+     * @param dY - the vertical offset
+     * @param res - return location for the offset
+     */
     offsetR(dX, dY, res) {
         call("libgraphene-1.0.so.0", "graphene_rect_offset_r", [
             {
@@ -515,6 +701,18 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Rounds the origin and size of the given rectangle to
+     * their nearest integer values; the rounding is guaranteed
+     * to be large enough to have an area bigger or equal to the
+     * original rectangle, but might not fully contain its extents.
+     * Use graphene_rect_round_extents() in case you need to round
+     * to a rectangle that covers fully the original one.
+     *
+     * This function is the equivalent of calling `floor` on
+     * the coordinates of the origin, and `ceil` on the size.
+     * @param res - return location for the
+     */
     round(res) {
         call("libgraphene-1.0.so.0", "graphene_rect_round", [
             {
@@ -534,6 +732,30 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Rounds the origin of the given rectangle to its nearest
+     * integer value and and recompute the size so that the
+     * rectangle is large enough to contain all the conrners
+     * of the original rectangle.
+     *
+     * This function is the equivalent of calling `floor` on
+     * the coordinates of the origin, and recomputing the size
+     * calling `ceil` on the bottom-right coordinates.
+     *
+     * If you want to be sure that the rounded rectangle
+     * completely covers the area that was covered by the
+     * original rectangle — i.e. you want to cover the area
+     * including all its corners — this function will make sure
+     * that the size is recomputed taking into account the ceiling
+     * of the coordinates of the bottom-right corner.
+     * If the difference between the original coordinates and the
+     * coordinates of the rounded rectangle is greater than the
+     * difference between the original size and and the rounded
+     * size, then the move of the origin would not be compensated
+     * by a move in the anti-origin, leaving the corners of the
+     * original rectangle outside the rounded one.
+     * @param res - return location for the
+     */
     roundExtents(res) {
         call("libgraphene-1.0.so.0", "graphene_rect_round_extents", [
             {
@@ -553,6 +775,11 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Rounds the origin and the size of the given rectangle to
+     * their nearest integer values; the rounding is guaranteed
+     * to be large enough to contain the original rectangle.
+     */
     roundToPixel() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_rect_round_to_pixel", [
             {
@@ -567,6 +794,13 @@ export class Rect {
         });
         return getObject(ptr, Rect);
     }
+    /**
+     * Scales the size and origin of a rectangle horizontaly by @s_h,
+     * and vertically by @s_v. The result `res` is normalized.
+     * @param sH - horizontal scale factor
+     * @param sV - vertical scale factor
+     * @param res - return location for the
+     */
     scale(sH, sV, res) {
         call("libgraphene-1.0.so.0", "graphene_rect_scale", [
             {
@@ -594,6 +828,15 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Computes the union of the two given rectangles.
+     *
+     *
+     *
+     * The union in the image above is the blue outline.
+     * @param b - a #graphene_rect_t
+     * @param res - return location for a #graphene_rect_t
+     */
     union(b, res) {
         call("libgraphene-1.0.so.0", "graphene_rect_union", [
             {
@@ -622,6 +865,7 @@ export class Rect {
             },
         ], { type: "undefined" });
     }
+    /** the coordinates of the origin of the rectangle */
     get origin() {
         return read(this.ptr, {
             type: "boxed",
@@ -629,6 +873,7 @@ export class Rect {
             lib: "libgraphene-1.0.so.0",
         }, 0);
     }
+    /** the size of the rectangle */
     get size() {
         return read(this.ptr, { type: "boxed", innerType: "GrapheneSize", lib: "libgraphene-1.0.so.0" }, 8);
     }

package/dist/generated/graphene/size.d.ts

@@ -1,17 +1,58 @@
 import { Ref } from "@gtkx/native";
+/** A size. */
 export declare class Size {
     ptr: unknown;
+    /**
+     * Allocates a new #graphene_size_t.
+     *
+     * The contents of the returned value are undefined.
+     */
     constructor();
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * A constant pointer to a zero #graphene_size_t, useful for
+     * equality checks and interpolations.
+     */
     static zero(): Size;
+    /**
+     * Checks whether the two give #graphene_size_t are equal.
+     * @param b - a #graphene_size_t
+     */
     equal(b: Size): boolean;
+    /**
+     * Frees the resources allocated by graphene_size_alloc().
+     */
     free(): void;
+    /**
+     * Initializes a #graphene_size_t using the given `width` and @height.
+     * @param width - the width
+     * @param height - the height
+     */
     init(width: number, height: number): Size;
+    /**
+     * Initializes a #graphene_size_t using the width and height of
+     * the given @src.
+     * @param src - a #graphene_size_t
+     */
     initFromSize(src: Size): Size;
+    /**
+     * Linearly interpolates the two given #graphene_size_t using the given
+     * interpolation @factor.
+     * @param b - a #graphene_size_t
+     * @param factor - the linear interpolation factor
+     * @param res - return location for the interpolated size
+     */
     interpolate(b: Size, factor: number, res: Ref<Size>): void;
+    /**
+     * Scales the components of a #graphene_size_t using the given @factor.
+     * @param factor - the scaling factor
+     * @param res - return location for the scaled size
+     */
     scale(factor: number, res: Ref<Size>): void;
+    /** the width */
     get width(): number;
     set width(value: number);
+    /** the height */
     get height(): number;
     set height(value: number);
 }

package/dist/generated/graphene/size.js

@@ -1,7 +1,13 @@
 import { call, read, write } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/** A size. */
 export class Size {
     ptr;
+    /**
+     * Allocates a new #graphene_size_t.
+     *
+     * The contents of the returned value are undefined.
+     */
     constructor() {
         this.ptr = this.createPtr([]);
     }
@@ -12,6 +18,10 @@ export class Size {
             innerType: "GrapheneSize",
         });
     }
+    /**
+     * A constant pointer to a zero #graphene_size_t, useful for
+     * equality checks and interpolations.
+     */
     static zero() {
         const ptr = call("libgraphene-1.0.so.0", "graphene_size_zero", [], {
             type: "boxed",
@@ -21,6 +31,10 @@ export class Size {
         });
         return getObject(ptr, Size);
     }
+    /**
+     * Checks whether the two give #graphene_size_t are equal.
+     * @param b - a #graphene_size_t
+     */
     equal(b) {
         return call("libgraphene-1.0.so.0", "graphene_size_equal", [
             {
@@ -38,6 +52,9 @@ export class Size {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Frees the resources allocated by graphene_size_alloc().
+     */
     free() {
         call("libgraphene-1.0.so.0", "graphene_size_free", [
             {
@@ -46,6 +63,11 @@ export class Size {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Initializes a #graphene_size_t using the given `width` and @height.
+     * @param width - the width
+     * @param height - the height
+     */
     init(width, height) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_size_init", [
             {
@@ -68,6 +90,11 @@ export class Size {
         });
         return getObject(ptr, Size);
     }
+    /**
+     * Initializes a #graphene_size_t using the width and height of
+     * the given @src.
+     * @param src - a #graphene_size_t
+     */
     initFromSize(src) {
         const ptr = call("libgraphene-1.0.so.0", "graphene_size_init_from_size", [
             {
@@ -91,6 +118,13 @@ export class Size {
         });
         return getObject(ptr, Size);
     }
+    /**
+     * Linearly interpolates the two given #graphene_size_t using the given
+     * interpolation @factor.
+     * @param b - a #graphene_size_t
+     * @param factor - the linear interpolation factor
+     * @param res - return location for the interpolated size
+     */
     interpolate(b, factor, res) {
         call("libgraphene-1.0.so.0", "graphene_size_interpolate", [
             {
@@ -123,6 +157,11 @@ export class Size {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Scales the components of a #graphene_size_t using the given @factor.
+     * @param factor - the scaling factor
+     * @param res - return location for the scaled size
+     */
     scale(factor, res) {
         call("libgraphene-1.0.so.0", "graphene_size_scale", [
             {
@@ -146,12 +185,14 @@ export class Size {
             },
         ], { type: "undefined" });
     }
+    /** the width */
     get width() {
         return read(this.ptr, { type: "float", size: 32 }, 0);
     }
     set width(value) {
         write(this.ptr, { type: "float", size: 32 }, 0, value);
     }
+    /** the height */
     get height() {
         return read(this.ptr, { type: "float", size: 32 }, 4);
     }