@gtkx/codegen 0.21.0 → 1.0.0-rc.2

package/overrides/cairo/region.ts.ejs

@@ -0,0 +1,237 @@
+import { alloc, type ExternalObject, getHandle, type Handle, setHandle, t, wrapHandle, write } from "@gtkx/runtime";
+import type { RegionOverlap, Status } from "../cairo.js";
+import { RectangleInt, Region } from "../cairo.js";
+
+const { bind } = t;
+const REGION_T = t.boxed("CairoRegion", {
+    ownership: "borrowed",
+    sharedLibrary: "libcairo-gobject.so.2",
+    getTypeFnName: "cairo_gobject_region_get_type",
+});
+const RECT_INT_ARRAY_T = t.boxed("cairo_rectangle_int_t[]", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" });
+
+declare module "../cairo.js" {
+    interface Region {
+        copy(): Region;
+        status(): Status;
+        getExtents(): RectangleInt;
+        numRectangles(): number;
+        getRectangle(nth: number): RectangleInt;
+        isEmpty(): boolean;
+        containsPoint(x: number, y: number): boolean;
+        containsRectangle(rect: RectangleInt): RegionOverlap;
+        equal(other: Region): boolean;
+        translate(dx: number, dy: number): void;
+        intersect(other: Region): void;
+        intersectRectangle(rect: RectangleInt): void;
+        subtract(other: Region): void;
+        subtractRectangle(rect: RectangleInt): void;
+        union(other: Region): void;
+        unionRectangle(rect: RectangleInt): void;
+        xor(other: Region): void;
+        xorRectangle(rect: RectangleInt): void;
+    }
+}
+
+const cairoRegionCreate = bind(
+    "libcairo.so.2",
+    "cairo_region_create",
+    [],
+    t.boxed("CairoRegion", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_region_get_type",
+    }),
+);
+const cairoRegionCreateRectangle = bind(
+    "libcairo.so.2",
+    "cairo_region_create_rectangle",
+    [t.boxed("cairo_rectangle_int_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.boxed("CairoRegion", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_region_get_type",
+    }),
+);
+const cairoRegionCreateRectangles = bind(
+    "libcairo.so.2",
+    "cairo_region_create_rectangles",
+    [RECT_INT_ARRAY_T, t.int32],
+    t.boxed("CairoRegion", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_region_get_type",
+    }),
+);
+
+class RegionImpl extends Region {
+    constructor(rect: RectangleInt) {
+        super();
+        setHandle(this, cairoRegionCreateRectangle(getHandle(rect)) as ExternalObject<Handle>);
+    }
+
+    static empty(): Region {
+        return wrapHandle(cairoRegionCreate() as ExternalObject<Handle>, RegionImpl);
+    }
+
+    static copy(original: Region): Region {
+        return wrapHandle(cairoRegionCopy(getHandle(original)) as ExternalObject<Handle>, RegionImpl);
+    }
+
+    static forRectangle(rect: RectangleInt): Region {
+        return wrapHandle(cairoRegionCreateRectangle(getHandle(rect)) as ExternalObject<Handle>, RegionImpl);
+    }
+
+    static createRectangles(rects: Array<{ x: number; y: number; width: number; height: number }>): Region {
+        if (rects.length === 0) {
+            return RegionImpl.empty();
+        }
+        const buf = alloc(rects.length * 16);
+        let offset = 0;
+        for (const rect of rects) {
+            write(buf, t.int32, offset, rect.x);
+            write(buf, t.int32, offset + 4, rect.y);
+            write(buf, t.int32, offset + 8, rect.width);
+            write(buf, t.int32, offset + 12, rect.height);
+            offset += 16;
+        }
+        const ptr = cairoRegionCreateRectangles(buf, rects.length) as ExternalObject<Handle>;
+        return wrapHandle(ptr, Region) as Region;
+    }
+}
+
+export { RegionImpl as Region };
+
+const cairoRegionCopy = bind(
+    "libcairo.so.2",
+    "cairo_region_copy",
+    [REGION_T],
+    t.boxed("CairoRegion", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_region_get_type",
+    }),
+);
+Region.prototype.copy = function (): Region {
+    return wrapHandle(cairoRegionCopy(getHandle(this)) as ExternalObject<Handle>, Region) as Region;
+};
+
+const cairoRegionStatus = bind("libcairo.so.2", "cairo_region_status", [REGION_T], t.int32);
+Region.prototype.status = function (): Status {
+    return cairoRegionStatus(getHandle(this)) as Status;
+};
+
+const cairoRegionGetExtents = bind(
+    "libcairo.so.2",
+    "cairo_region_get_extents",
+    [REGION_T, t.boxed("cairo_rectangle_int_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Region.prototype.getExtents = function (): RectangleInt {
+    const rect = new RectangleInt();
+    cairoRegionGetExtents(getHandle(this), getHandle(rect));
+    return rect;
+};
+
+const cairoRegionNumRectangles = bind("libcairo.so.2", "cairo_region_num_rectangles", [REGION_T], t.int32);
+Region.prototype.numRectangles = function (): number {
+    return cairoRegionNumRectangles(getHandle(this)) as number;
+};
+
+const cairoRegionGetRectangle = bind(
+    "libcairo.so.2",
+    "cairo_region_get_rectangle",
+    [REGION_T, t.int32, t.boxed("cairo_rectangle_int_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+Region.prototype.getRectangle = function (nth: number): RectangleInt {
+    const rect = new RectangleInt();
+    cairoRegionGetRectangle(getHandle(this), nth, getHandle(rect));
+    return rect;
+};
+
+const cairoRegionIsEmpty = bind("libcairo.so.2", "cairo_region_is_empty", [REGION_T], t.boolean);
+Region.prototype.isEmpty = function (): boolean {
+    return cairoRegionIsEmpty(getHandle(this)) as boolean;
+};
+
+const cairoRegionContainsPoint = bind(
+    "libcairo.so.2",
+    "cairo_region_contains_point",
+    [REGION_T, t.int32, t.int32],
+    t.boolean,
+);
+Region.prototype.containsPoint = function (x: number, y: number): boolean {
+    return cairoRegionContainsPoint(getHandle(this), x, y) as boolean;
+};
+
+const cairoRegionContainsRectangle = bind(
+    "libcairo.so.2",
+    "cairo_region_contains_rectangle",
+    [REGION_T, t.boxed("cairo_rectangle_int_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.int32,
+);
+Region.prototype.containsRectangle = function (rect: RectangleInt): RegionOverlap {
+    return cairoRegionContainsRectangle(getHandle(this), getHandle(rect)) as RegionOverlap;
+};
+
+const cairoRegionEqual = bind("libcairo.so.2", "cairo_region_equal", [REGION_T, REGION_T], t.boolean);
+Region.prototype.equal = function (other: Region): boolean {
+    return cairoRegionEqual(getHandle(this), getHandle(other)) as boolean;
+};
+
+const cairoRegionTranslate = bind("libcairo.so.2", "cairo_region_translate", [REGION_T, t.int32, t.int32], t.void);
+Region.prototype.translate = function (dx: number, dy: number): void {
+    cairoRegionTranslate(getHandle(this), dx, dy);
+};
+
+const BINARY_OP_ARGS = [REGION_T, REGION_T];
+const cairoRegionIntersect = bind("libcairo.so.2", "cairo_region_intersect", BINARY_OP_ARGS, t.int32);
+const cairoRegionSubtract = bind("libcairo.so.2", "cairo_region_subtract", BINARY_OP_ARGS, t.int32);
+const cairoRegionUnion = bind("libcairo.so.2", "cairo_region_union", BINARY_OP_ARGS, t.int32);
+const cairoRegionXor = bind("libcairo.so.2", "cairo_region_xor", BINARY_OP_ARGS, t.int32);
+
+const RECT_OP_ARGS = [
+    REGION_T,
+    t.boxed("cairo_rectangle_int_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+];
+const cairoRegionIntersectRectangle = bind("libcairo.so.2", "cairo_region_intersect_rectangle", RECT_OP_ARGS, t.int32);
+const cairoRegionSubtractRectangle = bind("libcairo.so.2", "cairo_region_subtract_rectangle", RECT_OP_ARGS, t.int32);
+const cairoRegionUnionRectangle = bind("libcairo.so.2", "cairo_region_union_rectangle", RECT_OP_ARGS, t.int32);
+const cairoRegionXorRectangle = bind("libcairo.so.2", "cairo_region_xor_rectangle", RECT_OP_ARGS, t.int32);
+
+const regionOp = (self: Region, boundFn: (...args: unknown[]) => unknown, arg: Region | RectangleInt): void => {
+    boundFn(getHandle(self), getHandle(arg));
+};
+
+Region.prototype.intersect = function (other: Region): void {
+    regionOp(this, cairoRegionIntersect, other);
+};
+
+Region.prototype.intersectRectangle = function (rect: RectangleInt): void {
+    regionOp(this, cairoRegionIntersectRectangle, rect);
+};
+
+Region.prototype.subtract = function (other: Region): void {
+    regionOp(this, cairoRegionSubtract, other);
+};
+
+Region.prototype.subtractRectangle = function (rect: RectangleInt): void {
+    regionOp(this, cairoRegionSubtractRectangle, rect);
+};
+
+Region.prototype.union = function (other: Region): void {
+    regionOp(this, cairoRegionUnion, other);
+};
+
+Region.prototype.unionRectangle = function (rect: RectangleInt): void {
+    regionOp(this, cairoRegionUnionRectangle, rect);
+};
+
+Region.prototype.xor = function (other: Region): void {
+    regionOp(this, cairoRegionXor, other);
+};
+
+Region.prototype.xorRectangle = function (rect: RectangleInt): void {
+    regionOp(this, cairoRegionXorRectangle, rect);
+};

package/overrides/cairo/scaled-font.ts.ejs

@@ -0,0 +1,330 @@
+import { alloc, type ExternalObject, getHandle, type Handle, read, t, wrapHandle } from "@gtkx/runtime";
+import type { FontOptions, FontType, Status, TextClusterFlags } from "../cairo.js";
+import { FontFace, ScaledFont } from "../cairo.js";
+import {
+    allocGlyphBuffer,
+    type CairoGlyph,
+    type CairoTextCluster,
+    type FontExtents,
+    readFontExtents,
+    readTextExtents,
+    type TextExtents,
+} from "./context.js";
+import { FontOptions as FontOptionsConstructor } from "./font-options.js";
+import { allocMatrix, type Matrix as CairoMatrix } from "./matrix.js";
+
+const { bind } = t;
+const SCALED_FONT_T = t.boxed("CairoScaledFont", {
+    ownership: "borrowed",
+    sharedLibrary: "libcairo-gobject.so.2",
+    getTypeFnName: "cairo_gobject_scaled_font_get_type",
+});
+const GLYPH_BUF_REF = t.ref(t.boxed("cairo_glyph_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }));
+const CLUSTER_BUF_REF = t.ref(
+    t.boxed("cairo_text_cluster_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+);
+
+declare module "../cairo.js" {
+    interface ScaledFont {
+        status(): Status;
+        extents(): FontExtents;
+        textExtents(text: string): TextExtents;
+        glyphExtents(glyphs: Array<{ index: number; x: number; y: number }>): TextExtents;
+        getFontFace(): FontFace;
+        getFontOptions(): FontOptions;
+        getFontMatrix(): CairoMatrix;
+        getCtm(): CairoMatrix;
+        getScaleMatrix(): CairoMatrix;
+        getType(): FontType;
+        getReferenceCount(): number;
+    }
+
+    namespace ScaledFont {
+        function create(
+            fontFace: FontFace,
+            fontMatrix: CairoMatrix,
+            ctm: CairoMatrix,
+            options: FontOptions,
+        ): ScaledFont;
+    }
+}
+
+type ScaledFontStatic = {
+    create(fontFace: FontFace, fontMatrix: CairoMatrix, ctm: CairoMatrix, options: FontOptions): ScaledFont;
+};
+
+const ScaledFontWithStatics = ScaledFont as typeof ScaledFont & ScaledFontStatic;
+
+const cairoScaledFontCreate = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_create",
+    [
+        t.boxed("CairoFontFace", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_font_face_get_type",
+        }),
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.boxed("CairoFontOptions", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_font_options_get_type",
+        }),
+    ],
+    t.boxed("CairoScaledFont", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_scaled_font_get_type",
+    }),
+);
+
+ScaledFontWithStatics.create = (
+    fontFace: FontFace,
+    fontMatrix: CairoMatrix,
+    ctm: CairoMatrix,
+    options: FontOptions,
+): ScaledFont => {
+    const ptr = cairoScaledFontCreate(
+        getHandle(fontFace),
+        getHandle(fontMatrix),
+        getHandle(ctm),
+        getHandle(options),
+    ) as ExternalObject<Handle>;
+    return wrapHandle(ptr, ScaledFont) as ScaledFont;
+};
+
+const cairoScaledFontStatus = bind("libcairo.so.2", "cairo_scaled_font_status", [SCALED_FONT_T], t.int32);
+ScaledFont.prototype.status = function (): Status {
+    return cairoScaledFontStatus(getHandle(this)) as Status;
+};
+
+const cairoScaledFontExtents = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_extents",
+    [SCALED_FONT_T, t.boxed("cairo_font_extents_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+ScaledFont.prototype.extents = function (): FontExtents {
+    const ext = alloc(40);
+    cairoScaledFontExtents(getHandle(this), ext);
+    return readFontExtents(ext);
+};
+
+const cairoScaledFontTextExtents = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_text_extents",
+    [
+        SCALED_FONT_T,
+        t.string("full"),
+        t.boxed("cairo_text_extents_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+    ],
+    t.void,
+);
+ScaledFont.prototype.textExtents = function (text: string): TextExtents {
+    const ext = alloc(48);
+    cairoScaledFontTextExtents(getHandle(this), text, ext);
+    return readTextExtents(ext);
+};
+
+const cairoScaledFontGlyphExtents = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_glyph_extents",
+    [
+        SCALED_FONT_T,
+        t.boxed("cairo_glyph_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.int32,
+        t.boxed("cairo_text_extents_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+    ],
+    t.void,
+);
+ScaledFont.prototype.glyphExtents = function (glyphs: Array<{ index: number; x: number; y: number }>): TextExtents {
+    const buf = allocGlyphBuffer(glyphs);
+    const ext = alloc(48);
+    cairoScaledFontGlyphExtents(getHandle(this), buf, glyphs.length, ext);
+    return readTextExtents(ext);
+};
+
+const cairoScaledFontGetFontFace = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_get_font_face",
+    [SCALED_FONT_T],
+    t.boxed("CairoFontFace", {
+        ownership: "borrowed",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_font_face_get_type",
+    }),
+);
+ScaledFont.prototype.getFontFace = function (): FontFace {
+    return wrapHandle(cairoScaledFontGetFontFace(getHandle(this)) as ExternalObject<Handle>, FontFace) as FontFace;
+};
+
+const cairoScaledFontGetFontOptions = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_get_font_options",
+    [
+        SCALED_FONT_T,
+        t.boxed("CairoFontOptions", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_font_options_get_type",
+        }),
+    ],
+    t.void,
+);
+ScaledFont.prototype.getFontOptions = function (): FontOptions {
+    const options = FontOptionsConstructor.create();
+    cairoScaledFontGetFontOptions(getHandle(this), getHandle(options));
+    return options;
+};
+
+const cairoScaledFontGetFontMatrix = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_get_font_matrix",
+    [SCALED_FONT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+const cairoScaledFontGetCtm = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_get_ctm",
+    [SCALED_FONT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+const cairoScaledFontGetScaleMatrix = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_get_scale_matrix",
+    [SCALED_FONT_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+
+function readMatrixVia(self: ScaledFont, boundFn: (...args: unknown[]) => unknown): CairoMatrix {
+    const { handle, obj } = allocMatrix();
+    boundFn(getHandle(self), handle);
+    return obj;
+}
+
+ScaledFont.prototype.getFontMatrix = function (): CairoMatrix {
+    return readMatrixVia(this, cairoScaledFontGetFontMatrix);
+};
+
+ScaledFont.prototype.getCtm = function (): CairoMatrix {
+    return readMatrixVia(this, cairoScaledFontGetCtm);
+};
+
+ScaledFont.prototype.getScaleMatrix = function (): CairoMatrix {
+    return readMatrixVia(this, cairoScaledFontGetScaleMatrix);
+};
+
+const cairoScaledFontGetType = bind("libcairo.so.2", "cairo_scaled_font_get_type", [SCALED_FONT_T], t.int32);
+ScaledFont.prototype.getType = function (): FontType {
+    return cairoScaledFontGetType(getHandle(this)) as FontType;
+};
+
+const cairoScaledFontGetReferenceCount = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_get_reference_count",
+    [SCALED_FONT_T],
+    t.int32,
+);
+ScaledFont.prototype.getReferenceCount = function (): number {
+    return cairoScaledFontGetReferenceCount(getHandle(this)) as number;
+};
+
+declare module "../cairo.js" {
+    interface ScaledFont {
+        textToGlyphs(x: number, y: number, text: string): [CairoGlyph[], CairoTextCluster[], TextClusterFlags];
+    }
+}
+
+const cairoScaledFontTextToGlyphs = bind(
+    "libcairo.so.2",
+    "cairo_scaled_font_text_to_glyphs",
+    [
+        SCALED_FONT_T,
+        t.float64,
+        t.float64,
+        t.string("full"),
+        t.int32,
+        GLYPH_BUF_REF,
+        t.ref(t.int32),
+        CLUSTER_BUF_REF,
+        t.ref(t.int32),
+        t.ref(t.int32),
+    ],
+    t.int32,
+);
+const cairoGlyphFree = bind(
+    "libcairo.so.2",
+    "cairo_glyph_free",
+    [t.boxed("cairo_glyph_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+const cairoTextClusterFree = bind(
+    "libcairo.so.2",
+    "cairo_text_cluster_free",
+    [t.boxed("cairo_text_cluster_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+
+ScaledFont.prototype.textToGlyphs = function (
+    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 numGlyphs = numGlyphsRef.value;
+    const numClusters = numClustersRef.value;
+
+    const glyphsBuf = glyphsRef.value;
+    const clustersBuf = clustersRef.value;
+
+    const glyphs: CairoGlyph[] = [];
+    if (glyphsBuf !== null) {
+        for (let i = 0; i < numGlyphs; i++) {
+            const offset = i * 24;
+            glyphs.push({
+                index: read(glyphsBuf, t.uint64, offset) as number,
+                x: read(glyphsBuf, t.float64, offset + 8) as number,
+                y: read(glyphsBuf, t.float64, offset + 16) as number,
+            });
+        }
+    }
+
+    const clusters: CairoTextCluster[] = [];
+    if (clustersBuf !== null) {
+        for (let i = 0; i < numClusters; i++) {
+            const offset = i * 8;
+            clusters.push({
+                numBytes: read(clustersBuf, t.int32, offset) as number,
+                numGlyphs: read(clustersBuf, t.int32, offset + 4) as number,
+            });
+        }
+    }
+
+    if (glyphsBuf !== null) {
+        cairoGlyphFree(glyphsBuf);
+    }
+    if (clustersBuf !== null) {
+        cairoTextClusterFree(clustersBuf);
+    }
+
+    return [glyphs, clusters, clusterFlagsRef.value as TextClusterFlags];
+};