@gtkx/cairo 1.2.2

package/src/region.ts

@@ -0,0 +1,216 @@
+import {
+    alloc,
+    type ExternalObject,
+    getHandle,
+    type Handle,
+    registerWrapperClass,
+    setHandle,
+    t,
+    wrapHandle,
+    write,
+} from "@gtkx/runtime";
+import type { RegionOverlap, Status } from "./enums.js";
+import type { RectangleData } from "./types.js";
+import {
+    bindCairo,
+    type BoundFunction,
+    cairoGType,
+    RECTANGLE_INT_ARRAY_T,
+    RECTANGLE_INT_T,
+    REGION_FULL_T,
+    REGION_T,
+} from "./lib.js";
+import { RectangleInt } from "./structs.js";
+
+const REGION_TYPE = cairoGType("cairo_gobject_region_get_type");
+const RECTANGLE_INT_SIZE = 16;
+const BINARY_OP_ARGS = [REGION_T, REGION_T];
+const RECTANGLE_OP_ARGS = [REGION_T, RECTANGLE_INT_T];
+const cairoRegionCreate = bindCairo("cairo_region_create", [], REGION_FULL_T);
+const cairoRegionCreateRectangle = bindCairo("cairo_region_create_rectangle", [RECTANGLE_INT_T], REGION_FULL_T);
+
+const cairoRegionCreateRectangles = bindCairo(
+    "cairo_region_create_rectangles",
+    [RECTANGLE_INT_ARRAY_T, t.int32],
+    REGION_FULL_T,
+);
+
+const cairoRegionCopy = bindCairo("cairo_region_copy", [REGION_T], REGION_FULL_T);
+const cairoRegionStatus = bindCairo("cairo_region_status", [REGION_T], t.int32);
+const cairoRegionGetExtents = bindCairo("cairo_region_get_extents", [REGION_T, RECTANGLE_INT_T], t.void);
+const cairoRegionNumRectangles = bindCairo("cairo_region_num_rectangles", [REGION_T], t.int32);
+const cairoRegionGetRectangle = bindCairo("cairo_region_get_rectangle", [REGION_T, t.int32, RECTANGLE_INT_T], t.void);
+const cairoRegionIsEmpty = bindCairo("cairo_region_is_empty", [REGION_T], t.boolean);
+const cairoRegionContainsPoint = bindCairo("cairo_region_contains_point", [REGION_T, t.int32, t.int32], t.boolean);
+const cairoRegionContainsRectangle = bindCairo("cairo_region_contains_rectangle", RECTANGLE_OP_ARGS, t.int32);
+const cairoRegionEqual = bindCairo("cairo_region_equal", BINARY_OP_ARGS, t.boolean);
+const cairoRegionTranslate = bindCairo("cairo_region_translate", [REGION_T, t.int32, t.int32], t.void);
+const cairoRegionIntersect = bindCairo("cairo_region_intersect", BINARY_OP_ARGS, t.int32);
+const cairoRegionSubtract = bindCairo("cairo_region_subtract", BINARY_OP_ARGS, t.int32);
+const cairoRegionUnion = bindCairo("cairo_region_union", BINARY_OP_ARGS, t.int32);
+const cairoRegionXor = bindCairo("cairo_region_xor", BINARY_OP_ARGS, t.int32);
+const cairoRegionIntersectRectangle = bindCairo("cairo_region_intersect_rectangle", RECTANGLE_OP_ARGS, t.int32);
+const cairoRegionSubtractRectangle = bindCairo("cairo_region_subtract_rectangle", RECTANGLE_OP_ARGS, t.int32);
+const cairoRegionUnionRectangle = bindCairo("cairo_region_union_rectangle", RECTANGLE_OP_ARGS, t.int32);
+const cairoRegionXorRectangle = bindCairo("cairo_region_xor_rectangle", RECTANGLE_OP_ARGS, t.int32);
+
+const allocRectangleBuffer = (rects: RectangleData[]): ExternalObject<Handle> => {
+    const buffer = alloc(rects.length * RECTANGLE_INT_SIZE);
+    let offset = 0;
+
+    for (const rect of rects) {
+        write(buffer, t.int32, offset, rect.x);
+        write(buffer, t.int32, offset + 4, rect.y);
+        write(buffer, t.int32, offset + 8, rect.width);
+        write(buffer, t.int32, offset + 12, rect.height);
+        offset += RECTANGLE_INT_SIZE;
+    }
+
+    return buffer;
+};
+
+const applyRegionOp = (self: object, boundFn: BoundFunction, arg: object): void => {
+    boundFn(getHandle(self), getHandle(arg));
+};
+
+/**
+ * A cairo region (`cairo_region_t`): a set of integer rectangles, as GTK uses for clip and damage areas.
+ * Set operations modify the region in place.
+ */
+class Region {
+    static {
+        registerWrapperClass(this, REGION_TYPE);
+    }
+
+    /** Creates an empty region. */
+    static empty(): Region {
+        return wrapHandle(cairoRegionCreate() as ExternalObject<Handle>, this);
+    }
+
+    /** Creates a region with the same rectangles as `original`. */
+    static copy(original: Region): Region {
+        return wrapHandle(cairoRegionCopy(getHandle(original)) as ExternalObject<Handle>, this);
+    }
+
+    /** Creates a region covering `rect`. */
+    static forRectangle(rect: RectangleInt): Region {
+        return wrapHandle(cairoRegionCreateRectangle(getHandle(rect)) as ExternalObject<Handle>, this);
+    }
+
+    /** Creates a region covering the union of `rects`; an empty list yields an empty region. */
+    static createRectangles(rects: RectangleData[]): Region {
+        if (rects.length === 0) {
+            return this.empty();
+        }
+
+        const buffer = allocRectangleBuffer(rects);
+
+        return wrapHandle(cairoRegionCreateRectangles(buffer, rects.length) as ExternalObject<Handle>, this);
+    }
+
+    /** GType of `CairoRegion`, the boxed type this class is registered under. */
+    declare __type__: bigint;
+
+    /** Creates a region covering `rect`. */
+    constructor(rect: RectangleInt) {
+        setHandle(this, cairoRegionCreateRectangle(getHandle(rect)) as ExternalObject<Handle>);
+    }
+
+    /** Returns a region with the same rectangles as this one. */
+    copy(): Region {
+        return wrapHandle(cairoRegionCopy(getHandle(this)) as ExternalObject<Handle>, Region);
+    }
+
+    /** Returns the error status of the region, `Status.SUCCESS` when it is usable. */
+    status(): Status {
+        return cairoRegionStatus(getHandle(this)) as Status;
+    }
+
+    /** Returns the bounding rectangle of the region. */
+    getExtents(): RectangleInt {
+        const rect = new RectangleInt();
+        cairoRegionGetExtents(getHandle(this), getHandle(rect));
+
+        return rect;
+    }
+
+    /** Returns how many rectangles make up the region. */
+    numRectangles(): number {
+        return cairoRegionNumRectangles(getHandle(this)) as number;
+    }
+
+    /** Returns the `nth` rectangle of the region, counting from zero. */
+    getRectangle(nth: number): RectangleInt {
+        const rect = new RectangleInt();
+        cairoRegionGetRectangle(getHandle(this), nth, getHandle(rect));
+
+        return rect;
+    }
+
+    /** Returns whether the region covers no area. */
+    isEmpty(): boolean {
+        return cairoRegionIsEmpty(getHandle(this)) as boolean;
+    }
+
+    /** Returns whether the point `(x, y)` lies inside the region. */
+    containsPoint(x: number, y: number): boolean {
+        return cairoRegionContainsPoint(getHandle(this), x, y) as boolean;
+    }
+
+    /** Returns whether `rect` lies inside, outside or partly inside the region. */
+    containsRectangle(rect: RectangleInt): RegionOverlap {
+        return cairoRegionContainsRectangle(getHandle(this), getHandle(rect)) as RegionOverlap;
+    }
+
+    /** Returns whether the region covers the same area as `other`. */
+    equal(other: Region): boolean {
+        return cairoRegionEqual(getHandle(this), getHandle(other)) as boolean;
+    }
+
+    /** Moves the region by `dx` and `dy`. */
+    translate(dx: number, dy: number): void {
+        cairoRegionTranslate(getHandle(this), dx, dy);
+    }
+
+    /** Keeps only the area the region shares with `other`. */
+    intersect(other: Region): void {
+        applyRegionOp(this, cairoRegionIntersect, other);
+    }
+
+    /** Keeps only the area the region shares with `rect`. */
+    intersectRectangle(rect: RectangleInt): void {
+        applyRegionOp(this, cairoRegionIntersectRectangle, rect);
+    }
+
+    /** Removes the area of `other` from the region. */
+    subtract(other: Region): void {
+        applyRegionOp(this, cairoRegionSubtract, other);
+    }
+
+    /** Removes the area of `rect` from the region. */
+    subtractRectangle(rect: RectangleInt): void {
+        applyRegionOp(this, cairoRegionSubtractRectangle, rect);
+    }
+
+    /** Adds the area of `other` to the region. */
+    union(other: Region): void {
+        applyRegionOp(this, cairoRegionUnion, other);
+    }
+
+    /** Adds the area of `rect` to the region. */
+    unionRectangle(rect: RectangleInt): void {
+        applyRegionOp(this, cairoRegionUnionRectangle, rect);
+    }
+
+    /** Keeps the area covered by exactly one of the region and `other`. */
+    xor(other: Region): void {
+        applyRegionOp(this, cairoRegionXor, other);
+    }
+
+    /** Keeps the area covered by exactly one of the region and `rect`. */
+    xorRectangle(rect: RectangleInt): void {
+        applyRegionOp(this, cairoRegionXorRectangle, rect);
+    }
+}
+
+export { Region };

package/src/scaled-font.ts

@@ -0,0 +1,268 @@
+import {
+    type ExternalObject,
+    getHandle,
+    type Handle,
+    read,
+    registerWrapperClass,
+    setHandle,
+    t,
+    wrapHandle,
+} from "@gtkx/runtime";
+import type { FontType, Status, TextClusterFlags } from "./enums.js";
+import type { CairoGlyph, CairoTextCluster, FontExtents, TextExtents } from "./types.js";
+import { FontFace } from "./font-face.js";
+import { FontOptions } from "./font-options.js";
+import {
+    bindCairo,
+    type BoundFunction,
+    cairoGType,
+    FONT_EXTENTS_T,
+    FONT_FACE_T,
+    FONT_OPTIONS_T,
+    GLYPH_T,
+    MATRIX_T,
+    SCALED_FONT_FULL_T,
+    SCALED_FONT_T,
+    TEXT_CLUSTER_T,
+    TEXT_EXTENTS_T,
+} from "./lib.js";
+import { allocMatrix, Matrix } from "./matrix.js";
+import { allocFontExtents, allocGlyphBuffer, allocTextExtents, readFontExtents, readTextExtents } from "./text.js";
+
+const SCALED_FONT_TYPE = cairoGType("cairo_gobject_scaled_font_get_type");
+const GLYPH_SIZE = 24;
+const CLUSTER_SIZE = 8;
+const cairoScaledFontStatus = bindCairo("cairo_scaled_font_status", [SCALED_FONT_T], t.int32);
+const cairoScaledFontExtents = bindCairo("cairo_scaled_font_extents", [SCALED_FONT_T, FONT_EXTENTS_T], t.void);
+const cairoScaledFontGetFontFace = bindCairo("cairo_scaled_font_get_font_face", [SCALED_FONT_T], FONT_FACE_T);
+const cairoScaledFontGetFontMatrix = bindCairo("cairo_scaled_font_get_font_matrix", [SCALED_FONT_T, MATRIX_T], t.void);
+const cairoScaledFontGetCtm = bindCairo("cairo_scaled_font_get_ctm", [SCALED_FONT_T, MATRIX_T], t.void);
+const cairoScaledFontGetType = bindCairo("cairo_scaled_font_get_type", [SCALED_FONT_T], t.int32);
+const cairoGlyphFree = bindCairo("cairo_glyph_free", [GLYPH_T], t.void);
+const cairoTextClusterFree = bindCairo("cairo_text_cluster_free", [TEXT_CLUSTER_T], t.void);
+
+const cairoScaledFontCreate = bindCairo(
+    "cairo_scaled_font_create",
+    [FONT_FACE_T, MATRIX_T, MATRIX_T, FONT_OPTIONS_T],
+    SCALED_FONT_FULL_T,
+);
+
+const cairoScaledFontTextExtents = bindCairo(
+    "cairo_scaled_font_text_extents",
+    [SCALED_FONT_T, t.string("full"), TEXT_EXTENTS_T],
+    t.void,
+);
+
+const cairoScaledFontGlyphExtents = bindCairo(
+    "cairo_scaled_font_glyph_extents",
+    [SCALED_FONT_T, GLYPH_T, t.int32, TEXT_EXTENTS_T],
+    t.void,
+);
+
+const cairoScaledFontGetFontOptions = bindCairo(
+    "cairo_scaled_font_get_font_options",
+    [SCALED_FONT_T, FONT_OPTIONS_T],
+    t.void,
+);
+
+const cairoScaledFontGetScaleMatrix = bindCairo(
+    "cairo_scaled_font_get_scale_matrix",
+    [SCALED_FONT_T, MATRIX_T],
+    t.void,
+);
+
+const cairoScaledFontGetReferenceCount = bindCairo(
+    "cairo_scaled_font_get_reference_count",
+    [SCALED_FONT_T],
+    t.int32,
+);
+
+const cairoScaledFontTextToGlyphs = bindCairo(
+    "cairo_scaled_font_text_to_glyphs",
+    [
+        SCALED_FONT_T,
+        t.float64,
+        t.float64,
+        t.string("full"),
+        t.int32,
+        t.ref(t.struct("borrowed")),
+        t.ref(t.int32),
+        t.ref(t.struct("borrowed")),
+        t.ref(t.int32),
+        t.ref(t.int32),
+    ],
+    t.int32,
+);
+
+const readMatrixVia = (self: ScaledFont, boundFn: BoundFunction): Matrix => {
+    const { handle, matrix } = allocMatrix();
+    boundFn(getHandle(self), handle);
+
+    return matrix;
+};
+
+const readGlyphs = (buffer: ExternalObject<Handle> | null, count: number): CairoGlyph[] => {
+    if (buffer === null) {
+        return [];
+    }
+
+    return Array.from({ length: count }, (_, index) => {
+        const offset = index * GLYPH_SIZE;
+
+        return {
+            index: read(buffer, t.uint64, offset) as number,
+            x: read(buffer, t.float64, offset + 8) as number,
+            y: read(buffer, t.float64, offset + 16) as number,
+        };
+    });
+};
+
+const readClusters = (buffer: ExternalObject<Handle> | null, count: number): CairoTextCluster[] => {
+    if (buffer === null) {
+        return [];
+    }
+
+    return Array.from({ length: count }, (_, index) => {
+        const offset = index * CLUSTER_SIZE;
+
+        return {
+            numBytes: read(buffer, t.int32, offset) as number,
+            numGlyphs: read(buffer, t.int32, offset + 4) as number,
+        };
+    });
+};
+
+/**
+ * A cairo scaled font (`cairo_scaled_font_t`): a font face frozen at a given font matrix, transformation and
+ * set of font options, ready to measure and shape text.
+ */
+class ScaledFont {
+    static {
+        registerWrapperClass(this, SCALED_FONT_TYPE);
+    }
+
+    /** Creates a scaled font, the same as `new ScaledFont(fontFace, fontMatrix, ctm, options)`. */
+    static create(fontFace: FontFace, fontMatrix: Matrix, ctm: Matrix, options: FontOptions): ScaledFont {
+        return new ScaledFont(fontFace, fontMatrix, ctm, options);
+    }
+
+    /** GType of `CairoScaledFont`, the boxed type this class is registered under. */
+    declare __type__: bigint;
+
+    /** Creates a scaled font from a font face, a font matrix, a user-to-device transformation and font options. */
+    constructor(fontFace: FontFace, fontMatrix: Matrix, ctm: Matrix, options: FontOptions) {
+        const handle = cairoScaledFontCreate(
+            getHandle(fontFace),
+            getHandle(fontMatrix),
+            getHandle(ctm),
+            getHandle(options),
+        ) as ExternalObject<Handle>;
+
+        setHandle(this, handle);
+    }
+
+    /** Returns the error status of the scaled font, `Status.SUCCESS` when it is usable. */
+    status(): Status {
+        return cairoScaledFontStatus(getHandle(this)) as Status;
+    }
+
+    /** Returns the metrics of the font. */
+    extents(): FontExtents {
+        const ext = allocFontExtents();
+        cairoScaledFontExtents(getHandle(this), ext);
+
+        return readFontExtents(ext);
+    }
+
+    /** Measures `text` with the font. */
+    textExtents(text: string): TextExtents {
+        const ext = allocTextExtents();
+        cairoScaledFontTextExtents(getHandle(this), text, ext);
+
+        return readTextExtents(ext);
+    }
+
+    /** Measures positioned glyphs with the font. */
+    glyphExtents(glyphs: CairoGlyph[]): TextExtents {
+        const buf = allocGlyphBuffer(glyphs);
+        const ext = allocTextExtents();
+        cairoScaledFontGlyphExtents(getHandle(this), buf, glyphs.length, ext);
+
+        return readTextExtents(ext);
+    }
+
+    /** Returns the font face the scaled font was created from, wrapped as its concrete class. */
+    getFontFace(): FontFace {
+        return wrapHandle(cairoScaledFontGetFontFace(getHandle(this)) as ExternalObject<Handle>, FontFace);
+    }
+
+    /** Returns a copy of the font options the scaled font was created with. */
+    getFontOptions(): FontOptions {
+        const options = FontOptions.create();
+        cairoScaledFontGetFontOptions(getHandle(this), getHandle(options));
+
+        return options;
+    }
+
+    /** Returns the font matrix the scaled font was created with. */
+    getFontMatrix(): Matrix {
+        return readMatrixVia(this, cairoScaledFontGetFontMatrix);
+    }
+
+    /** Returns the user-to-device transformation the scaled font was created with. */
+    getCtm(): Matrix {
+        return readMatrixVia(this, cairoScaledFontGetCtm);
+    }
+
+    /** Returns the scale matrix: the font matrix multiplied by the transformation, without translation. */
+    getScaleMatrix(): Matrix {
+        return readMatrixVia(this, cairoScaledFontGetScaleMatrix);
+    }
+
+    /** Returns the backend the scaled font belongs to. */
+    getType(): FontType {
+        return cairoScaledFontGetType(getHandle(this)) as FontType;
+    }
+
+    /** Returns the reference count of the scaled font. */
+    getReferenceCount(): number {
+        return cairoScaledFontGetReferenceCount(getHandle(this)) as number;
+    }
+
+    /** Shapes `text` starting at `(x, y)` into glyphs, clusters and the flags describing their order. */
+    textToGlyphs(x: number, y: number, text: string): [CairoGlyph[], CairoTextCluster[], TextClusterFlags] {
+        const glyphsRef: { value: ExternalObject<Handle> | null } = { value: null };
+        const numGlyphsRef = { value: 0 };
+        const clustersRef: { value: ExternalObject<Handle> | null } = { value: null };
+        const numClustersRef = { value: 0 };
+        const clusterFlagsRef = { value: 0 };
+
+        cairoScaledFontTextToGlyphs(
+            getHandle(this),
+            x,
+            y,
+            text,
+            -1,
+            glyphsRef,
+            numGlyphsRef,
+            clustersRef,
+            numClustersRef,
+            clusterFlagsRef,
+        );
+
+        const glyphs = readGlyphs(glyphsRef.value, numGlyphsRef.value);
+        const clusters = readClusters(clustersRef.value, numClustersRef.value);
+
+        if (glyphsRef.value !== null) {
+            cairoGlyphFree(glyphsRef.value);
+        }
+
+        if (clustersRef.value !== null) {
+            cairoTextClusterFree(clustersRef.value);
+        }
+
+        return [glyphs, clusters, clusterFlagsRef.value as TextClusterFlags];
+    }
+}
+
+export { ScaledFont };