@gtkx/codegen 0.21.0 → 1.0.0-rc.2

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

@@ -0,0 +1,151 @@
+import { type ExternalObject, getHandle, type Handle, t, wrapHandle } from "@gtkx/runtime";
+import type { FontSlant, FontType, FontWeight, Status } from "../cairo.js";
+import { FontFace } from "../cairo.js";
+
+const { bind } = t;
+const FONT_FACE_T = t.boxed("CairoFontFace", {
+    ownership: "borrowed",
+    sharedLibrary: "libcairo-gobject.so.2",
+    getTypeFnName: "cairo_gobject_font_face_get_type",
+});
+const FC_PATTERN_T = t.boxed("FcPattern", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" });
+const FT_FACE_T = t.boxed("FT_Face", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" });
+
+declare module "../cairo.js" {
+    interface FontFace {
+        status(): Status;
+        getType(): FontType;
+        getReferenceCount(): number;
+    }
+
+    namespace FontFace {
+        function create(family: string, slant: FontSlant, weight: FontWeight): ToyFontFace;
+        function createForFtFace(face: ExternalObject<Handle>, loadFlags: number): FtFontFace;
+        function createForPattern(pattern: ExternalObject<Handle>): FtFontFace;
+    }
+}
+
+const cairoFontFaceStatus = bind("libcairo.so.2", "cairo_font_face_status", [FONT_FACE_T], t.int32);
+FontFace.prototype.status = function (): Status {
+    return cairoFontFaceStatus(getHandle(this)) as Status;
+};
+
+const cairoFontFaceGetType = bind("libcairo.so.2", "cairo_font_face_get_type", [FONT_FACE_T], t.int32);
+FontFace.prototype.getType = function (): FontType {
+    return cairoFontFaceGetType(getHandle(this)) as FontType;
+};
+
+const cairoFontFaceGetReferenceCount = bind(
+    "libcairo.so.2",
+    "cairo_font_face_get_reference_count",
+    [FONT_FACE_T],
+    t.int32,
+);
+FontFace.prototype.getReferenceCount = function (): number {
+    return cairoFontFaceGetReferenceCount(getHandle(this)) as number;
+};
+
+const cairoToyFontFaceGetFamily = bind(
+    "libcairo.so.2",
+    "cairo_toy_font_face_get_family",
+    [FONT_FACE_T],
+    t.string("borrowed"),
+);
+const cairoToyFontFaceGetSlant = bind("libcairo.so.2", "cairo_toy_font_face_get_slant", [FONT_FACE_T], t.int32);
+const cairoToyFontFaceGetWeight = bind("libcairo.so.2", "cairo_toy_font_face_get_weight", [FONT_FACE_T], t.int32);
+const cairoFtFontFaceGetSynthesize = bind("libcairo.so.2", "cairo_ft_font_face_get_synthesize", [FONT_FACE_T], t.int32);
+const cairoFtFontFaceSetSynthesize = bind(
+    "libcairo.so.2",
+    "cairo_ft_font_face_set_synthesize",
+    [FONT_FACE_T, t.int32],
+    t.void,
+);
+const cairoFtFontFaceUnsetSynthesize = bind(
+    "libcairo.so.2",
+    "cairo_ft_font_face_unset_synthesize",
+    [FONT_FACE_T, t.int32],
+    t.void,
+);
+
+export class ToyFontFace extends FontFace {
+    getFamily(): string {
+        return cairoToyFontFaceGetFamily(getHandle(this)) as string;
+    }
+
+    getSlant(): FontSlant {
+        return cairoToyFontFaceGetSlant(getHandle(this)) as FontSlant;
+    }
+
+    getWeight(): FontWeight {
+        return cairoToyFontFaceGetWeight(getHandle(this)) as FontWeight;
+    }
+}
+
+export enum FtSynthesize {
+    BOLD = 1,
+    OBLIQUE = 2,
+}
+
+export class FtFontFace extends FontFace {
+    getSynthesize(): FtSynthesize {
+        return cairoFtFontFaceGetSynthesize(getHandle(this)) as FtSynthesize;
+    }
+
+    setSynthesize(synthFlags: FtSynthesize): void {
+        cairoFtFontFaceSetSynthesize(getHandle(this), synthFlags);
+    }
+
+    unsetSynthesize(synthFlags: FtSynthesize): void {
+        cairoFtFontFaceUnsetSynthesize(getHandle(this), synthFlags);
+    }
+}
+
+type FontFaceStatic = {
+    create(family: string, slant: FontSlant, weight: FontWeight): ToyFontFace;
+    createForFtFace(face: ExternalObject<Handle>, loadFlags: number): FtFontFace;
+    createForPattern(pattern: ExternalObject<Handle>): FtFontFace;
+};
+
+const FontFaceWithStatics = FontFace as typeof FontFace & FontFaceStatic;
+
+const cairoToyFontFaceCreate = bind(
+    "libcairo.so.2",
+    "cairo_toy_font_face_create",
+    [t.string("full"), t.int32, t.int32],
+    t.boxed("CairoFontFace", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_font_face_get_type",
+    }),
+);
+FontFaceWithStatics.create = (family: string, slant: FontSlant, weight: FontWeight): ToyFontFace => {
+    return wrapHandle(cairoToyFontFaceCreate(family, slant, weight) as ExternalObject<Handle>, ToyFontFace);
+};
+
+const cairoFtFontFaceCreateForFtFace = bind(
+    "libcairo.so.2",
+    "cairo_ft_font_face_create_for_ft_face",
+    [FT_FACE_T, t.int32],
+    t.boxed("CairoFontFace", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_font_face_get_type",
+    }),
+);
+FontFaceWithStatics.createForFtFace = (face: ExternalObject<Handle>, loadFlags: number): FtFontFace => {
+    return wrapHandle(cairoFtFontFaceCreateForFtFace(face, loadFlags) as ExternalObject<Handle>, FtFontFace);
+};
+
+const cairoFtFontFaceCreateForPattern = bind(
+    "libcairo.so.2",
+    "cairo_ft_font_face_create_for_pattern",
+    [FC_PATTERN_T],
+    t.boxed("CairoFontFace", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_font_face_get_type",
+    }),
+);
+FontFaceWithStatics.createForPattern = (pattern: ExternalObject<Handle>): FtFontFace => {
+    return wrapHandle(cairoFtFontFaceCreateForPattern(pattern) as ExternalObject<Handle>, FtFontFace);
+};

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

@@ -0,0 +1,199 @@
+import { type ExternalObject, getHandle, type Handle, setHandle, t } from "@gtkx/runtime";
+import type { Antialias, HintMetrics, HintStyle, Status, SubpixelOrder } from "../cairo.js";
+import { FontOptions } from "../cairo.js";
+
+const { bind } = t;
+const FONT_OPTIONS_T = t.boxed("CairoFontOptions", {
+    ownership: "borrowed",
+    sharedLibrary: "libcairo-gobject.so.2",
+    getTypeFnName: "cairo_gobject_font_options_get_type",
+});
+
+declare module "../cairo.js" {
+    interface FontOptions {
+        setHintStyle(hintStyle: HintStyle): void;
+        getHintStyle(): HintStyle;
+        setAntialias(antialias: Antialias): void;
+        getAntialias(): Antialias;
+        setHintMetrics(hintMetrics: HintMetrics): void;
+        getHintMetrics(): HintMetrics;
+        setSubpixelOrder(subpixelOrder: SubpixelOrder): void;
+        getSubpixelOrder(): SubpixelOrder;
+        equal(other: FontOptions): boolean;
+        merge(other: FontOptions): void;
+    }
+}
+
+const cairoFontOptionsCreate = bind(
+    "libcairo.so.2",
+    "cairo_font_options_create",
+    [],
+    t.boxed("CairoFontOptions", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_font_options_get_type",
+    }),
+);
+const cairoFontOptionsCopy = bind(
+    "libcairo.so.2",
+    "cairo_font_options_copy",
+    [FONT_OPTIONS_T],
+    t.boxed("CairoFontOptions", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_font_options_get_type",
+    }),
+);
+
+class FontOptionsImpl extends FontOptions {
+    constructor(other?: FontOptions) {
+        super();
+        const handle = other === undefined ? cairoFontOptionsCreate() : cairoFontOptionsCopy(getHandle(other));
+        setHandle(this, handle as ExternalObject<Handle>);
+    }
+
+    static create(): FontOptionsImpl {
+        return new FontOptionsImpl();
+    }
+}
+
+export { FontOptionsImpl as FontOptions };
+
+const cairoFontOptionsSetHintStyle = bind(
+    "libcairo.so.2",
+    "cairo_font_options_set_hint_style",
+    [FONT_OPTIONS_T, t.int32],
+    t.void,
+);
+FontOptions.prototype.setHintStyle = function (hintStyle: HintStyle): void {
+    cairoFontOptionsSetHintStyle(getHandle(this), hintStyle);
+};
+
+const cairoFontOptionsGetHintStyle = bind(
+    "libcairo.so.2",
+    "cairo_font_options_get_hint_style",
+    [FONT_OPTIONS_T],
+    t.int32,
+);
+FontOptions.prototype.getHintStyle = function (): HintStyle {
+    return cairoFontOptionsGetHintStyle(getHandle(this)) as HintStyle;
+};
+
+const cairoFontOptionsSetAntialias = bind(
+    "libcairo.so.2",
+    "cairo_font_options_set_antialias",
+    [FONT_OPTIONS_T, t.int32],
+    t.void,
+);
+FontOptions.prototype.setAntialias = function (antialias: Antialias): void {
+    cairoFontOptionsSetAntialias(getHandle(this), antialias);
+};
+
+const cairoFontOptionsGetAntialias = bind(
+    "libcairo.so.2",
+    "cairo_font_options_get_antialias",
+    [FONT_OPTIONS_T],
+    t.int32,
+);
+FontOptions.prototype.getAntialias = function (): Antialias {
+    return cairoFontOptionsGetAntialias(getHandle(this)) as Antialias;
+};
+
+const cairoFontOptionsSetHintMetrics = bind(
+    "libcairo.so.2",
+    "cairo_font_options_set_hint_metrics",
+    [FONT_OPTIONS_T, t.int32],
+    t.void,
+);
+FontOptions.prototype.setHintMetrics = function (hintMetrics: HintMetrics): void {
+    cairoFontOptionsSetHintMetrics(getHandle(this), hintMetrics);
+};
+
+const cairoFontOptionsGetHintMetrics = bind(
+    "libcairo.so.2",
+    "cairo_font_options_get_hint_metrics",
+    [FONT_OPTIONS_T],
+    t.int32,
+);
+FontOptions.prototype.getHintMetrics = function (): HintMetrics {
+    return cairoFontOptionsGetHintMetrics(getHandle(this)) as HintMetrics;
+};
+
+const cairoFontOptionsSetSubpixelOrder = bind(
+    "libcairo.so.2",
+    "cairo_font_options_set_subpixel_order",
+    [FONT_OPTIONS_T, t.int32],
+    t.void,
+);
+FontOptions.prototype.setSubpixelOrder = function (subpixelOrder: SubpixelOrder): void {
+    cairoFontOptionsSetSubpixelOrder(getHandle(this), subpixelOrder);
+};
+
+const cairoFontOptionsGetSubpixelOrder = bind(
+    "libcairo.so.2",
+    "cairo_font_options_get_subpixel_order",
+    [FONT_OPTIONS_T],
+    t.int32,
+);
+FontOptions.prototype.getSubpixelOrder = function (): SubpixelOrder {
+    return cairoFontOptionsGetSubpixelOrder(getHandle(this)) as SubpixelOrder;
+};
+
+const cairoFontOptionsEqual = bind(
+    "libcairo.so.2",
+    "cairo_font_options_equal",
+    [FONT_OPTIONS_T, FONT_OPTIONS_T],
+    t.boolean,
+);
+FontOptions.prototype.equal = function (other: FontOptions): boolean {
+    return cairoFontOptionsEqual(getHandle(this), getHandle(other)) as boolean;
+};
+
+const cairoFontOptionsMerge = bind(
+    "libcairo.so.2",
+    "cairo_font_options_merge",
+    [FONT_OPTIONS_T, FONT_OPTIONS_T],
+    t.void,
+);
+FontOptions.prototype.merge = function (other: FontOptions): void {
+    cairoFontOptionsMerge(getHandle(this), getHandle(other));
+};
+
+declare module "../cairo.js" {
+    interface FontOptions {
+        status(): Status;
+        hash(): number;
+        setVariations(variations: string): void;
+        getVariations(): string;
+    }
+}
+
+const cairoFontOptionsStatus = bind("libcairo.so.2", "cairo_font_options_status", [FONT_OPTIONS_T], t.int32);
+FontOptions.prototype.status = function (): Status {
+    return cairoFontOptionsStatus(getHandle(this)) as Status;
+};
+
+const cairoFontOptionsHash = bind("libcairo.so.2", "cairo_font_options_hash", [FONT_OPTIONS_T], t.uint64);
+FontOptions.prototype.hash = function (): number {
+    return cairoFontOptionsHash(getHandle(this)) as number;
+};
+
+const cairoFontOptionsSetVariations = bind(
+    "libcairo.so.2",
+    "cairo_font_options_set_variations",
+    [FONT_OPTIONS_T, t.string("full")],
+    t.void,
+);
+FontOptions.prototype.setVariations = function (variations: string): void {
+    cairoFontOptionsSetVariations(getHandle(this), variations);
+};
+
+const cairoFontOptionsGetVariations = bind(
+    "libcairo.so.2",
+    "cairo_font_options_get_variations",
+    [FONT_OPTIONS_T],
+    t.string("borrowed"),
+);
+FontOptions.prototype.getVariations = function (): string {
+    return cairoFontOptionsGetVariations(getHandle(this)) as string;
+};

package/overrides/cairo/image-surface.ts.ejs

@@ -0,0 +1,132 @@
+import { type ExternalObject, getHandle, type Handle, read, setHandle, t, wrapHandle } from "@gtkx/runtime";
+import type { Format } from "../cairo.js";
+import { Surface } from "../cairo.js";
+
+const { bind } = t;
+
+const cairoImageSurfaceCreate = bind(
+    "libcairo.so.2",
+    "cairo_image_surface_create",
+    [t.int32, t.int32, t.int32],
+    t.boxed("CairoSurface", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_surface_get_type",
+    }),
+);
+const cairoImageSurfaceCreateFromPng = bind(
+    "libcairo.so.2",
+    "cairo_image_surface_create_from_png",
+    [t.string("full")],
+    t.boxed("CairoSurface", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_surface_get_type",
+    }),
+);
+const cairoImageSurfaceGetWidth = bind(
+    "libcairo.so.2",
+    "cairo_image_surface_get_width",
+    [
+        t.boxed("CairoSurface", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_surface_get_type",
+        }),
+    ],
+    t.int32,
+);
+const cairoImageSurfaceGetHeight = bind(
+    "libcairo.so.2",
+    "cairo_image_surface_get_height",
+    [
+        t.boxed("CairoSurface", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_surface_get_type",
+        }),
+    ],
+    t.int32,
+);
+const cairoImageSurfaceGetFormat = bind(
+    "libcairo.so.2",
+    "cairo_image_surface_get_format",
+    [
+        t.boxed("CairoSurface", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_surface_get_type",
+        }),
+    ],
+    t.int32,
+);
+const cairoImageSurfaceGetStride = bind(
+    "libcairo.so.2",
+    "cairo_image_surface_get_stride",
+    [
+        t.boxed("CairoSurface", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_surface_get_type",
+        }),
+    ],
+    t.int32,
+);
+
+export class ImageSurface extends Surface {
+    constructor(format: Format, width: number, height: number) {
+        super();
+        setHandle(this, cairoImageSurfaceCreate(format, width, height) as ExternalObject<Handle>);
+    }
+
+    static create(format: Format, width: number, height: number): ImageSurface {
+        return wrapHandle(cairoImageSurfaceCreate(format, width, height) as ExternalObject<Handle>, ImageSurface);
+    }
+
+    static createFromPng(filename: string): ImageSurface {
+        return wrapHandle(cairoImageSurfaceCreateFromPng(filename) as ExternalObject<Handle>, ImageSurface);
+    }
+
+    getWidth(): number {
+        return cairoImageSurfaceGetWidth(getHandle(this)) as number;
+    }
+
+    getHeight(): number {
+        return cairoImageSurfaceGetHeight(getHandle(this)) as number;
+    }
+
+    getFormat(): Format {
+        return cairoImageSurfaceGetFormat(getHandle(this)) as Format;
+    }
+
+    getStride(): number {
+        return cairoImageSurfaceGetStride(getHandle(this)) as number;
+    }
+
+    getData(): Uint8Array {
+        this.flush();
+        const stride = this.getStride();
+        const height = this.getHeight();
+        const totalBytes = stride * height;
+        if (totalBytes === 0) return new Uint8Array(0);
+        const getImageData = bind(
+            "libcairo.so.2",
+            "cairo_image_surface_get_data",
+            [
+                t.boxed("CairoSurface", {
+                    ownership: "borrowed",
+                    sharedLibrary: "libcairo-gobject.so.2",
+                    getTypeFnName: "cairo_gobject_surface_get_type",
+                }),
+            ],
+            t.struct("borrowed", { size: totalBytes }),
+        );
+        const ptr = getImageData(getHandle(this)) as ExternalObject<Handle> | null;
+        if (ptr === null) return new Uint8Array(0);
+        const result = new Uint8Array(totalBytes);
+        for (let i = 0; i < totalBytes; i++) {
+            result[i] = read(ptr, t.uint8, i) as number;
+        }
+        return result;
+    }
+}

package/overrides/cairo/index.ts.ejs

@@ -0,0 +1,22 @@
+export * from "./cairo.js";
+
+import "./overrides/font-face.js";
+import "./overrides/scaled-font.js";
+import "./overrides/surface.js";
+
+export type { CairoGlyph, CairoTextCluster, PathData } from "./overrides/context.js";
+export {
+    Context,
+    type FontExtents,
+    statusToString,
+    type TextExtents,
+    version,
+    versionString,
+} from "./overrides/context.js";
+export { FtFontFace, FtSynthesize, ToyFontFace } from "./overrides/font-face.js";
+export { FontOptions } from "./overrides/font-options.js";
+export { ImageSurface } from "./overrides/image-surface.js";
+export { Matrix } from "./overrides/matrix.js";
+export { LinearPattern, MeshPattern, RadialPattern } from "./overrides/pattern.js";
+export { RecordingSurface } from "./overrides/recording-surface.js";
+export { Region } from "./overrides/region.js";

package/overrides/cairo/matrix.ts.ejs

@@ -0,0 +1,171 @@
+import { alloc, type ExternalObject, getHandle, type Handle, setHandle, t, wrapHandle } from "@gtkx/runtime";
+import type { Status } from "../cairo.js";
+
+const { bind } = t;
+
+export const allocMatrix = (): { handle: ExternalObject<Handle>; obj: Matrix } => {
+    const handle = alloc(48);
+    const obj = wrapHandle(handle, Matrix);
+    return { handle, obj };
+};
+
+const cairoMatrixTranslate = bind(
+    "libcairo.so.2",
+    "cairo_matrix_translate",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.float64, t.float64],
+    t.void,
+);
+const cairoMatrixScale = bind(
+    "libcairo.so.2",
+    "cairo_matrix_scale",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.float64, t.float64],
+    t.void,
+);
+const cairoMatrixRotate = bind(
+    "libcairo.so.2",
+    "cairo_matrix_rotate",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.float64],
+    t.void,
+);
+const cairoMatrixInvert = bind(
+    "libcairo.so.2",
+    "cairo_matrix_invert",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.int32,
+);
+const cairoMatrixMultiply = bind(
+    "libcairo.so.2",
+    "cairo_matrix_multiply",
+    [
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+    ],
+    t.void,
+);
+const cairoMatrixTransformPoint = bind(
+    "libcairo.so.2",
+    "cairo_matrix_transform_point",
+    [
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.ref(t.float64),
+        t.ref(t.float64),
+    ],
+    t.void,
+);
+const cairoMatrixTransformDistance = bind(
+    "libcairo.so.2",
+    "cairo_matrix_transform_distance",
+    [
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.ref(t.float64),
+        t.ref(t.float64),
+    ],
+    t.void,
+);
+const cairoMatrixInitIdentity = bind(
+    "libcairo.so.2",
+    "cairo_matrix_init_identity",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    t.void,
+);
+const cairoMatrixInitTranslate = bind(
+    "libcairo.so.2",
+    "cairo_matrix_init_translate",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.float64, t.float64],
+    t.void,
+);
+const cairoMatrixInitScale = bind(
+    "libcairo.so.2",
+    "cairo_matrix_init_scale",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.float64, t.float64],
+    t.void,
+);
+const cairoMatrixInitRotate = bind(
+    "libcairo.so.2",
+    "cairo_matrix_init_rotate",
+    [t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }), t.float64],
+    t.void,
+);
+const cairoMatrixInit = bind(
+    "libcairo.so.2",
+    "cairo_matrix_init",
+    [
+        t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" }),
+        t.float64,
+        t.float64,
+        t.float64,
+        t.float64,
+        t.float64,
+        t.float64,
+    ],
+    t.void,
+);
+
+export class Matrix {
+    constructor(xx: number, yx: number, xy: number, yy: number, x0: number, y0: number) {
+        const handle = alloc(48);
+        setHandle(this, handle);
+        cairoMatrixInit(handle, xx, yx, xy, yy, x0, y0);
+    }
+
+    translate(tx: number, ty: number): void {
+        cairoMatrixTranslate(getHandle(this), tx, ty);
+    }
+
+    scale(sx: number, sy: number): void {
+        cairoMatrixScale(getHandle(this), sx, sy);
+    }
+
+    rotate(radians: number): void {
+        cairoMatrixRotate(getHandle(this), radians);
+    }
+
+    invert(): Status {
+        return cairoMatrixInvert(getHandle(this)) as Status;
+    }
+
+    transformPoint(x: number, y: number): { x: number; y: number } {
+        const xRef = { value: x };
+        const yRef = { value: y };
+        cairoMatrixTransformPoint(getHandle(this), xRef, yRef);
+        return { x: xRef.value, y: yRef.value };
+    }
+
+    transformDistance(dx: number, dy: number): { dx: number; dy: number } {
+        const dxRef = { value: dx };
+        const dyRef = { value: dy };
+        cairoMatrixTransformDistance(getHandle(this), dxRef, dyRef);
+        return { dx: dxRef.value, dy: dyRef.value };
+    }
+
+    static initIdentity(): Matrix {
+        const { handle, obj } = allocMatrix();
+        cairoMatrixInitIdentity(handle);
+        return obj;
+    }
+
+    static initTranslate(tx: number, ty: number): Matrix {
+        const { handle, obj } = allocMatrix();
+        cairoMatrixInitTranslate(handle, tx, ty);
+        return obj;
+    }
+
+    static initScale(sx: number, sy: number): Matrix {
+        const { handle, obj } = allocMatrix();
+        cairoMatrixInitScale(handle, sx, sy);
+        return obj;
+    }
+
+    static initRotate(radians: number): Matrix {
+        const { handle, obj } = allocMatrix();
+        cairoMatrixInitRotate(handle, radians);
+        return obj;
+    }
+
+    static multiply(a: Matrix, b: Matrix): Matrix {
+        const { handle, obj } = allocMatrix();
+        cairoMatrixMultiply(handle, getHandle(a), getHandle(b));
+        return obj;
+    }
+}