@gtkx/codegen 1.2.2 → 1.3.0

package/overrides/cairo/pattern.ts.ejs

@@ -1,476 +0,0 @@
-import { type ExternalObject, getHandle, type Handle, t, wrapHandle } from "@gtkx/runtime";
-import { type Extend, type Filter, Pattern, type PatternType, type Status, type Surface } from "../cairo.js";
-import { type PathData, parsePath } from "./context.js";
-import { allocMatrix, type Matrix as CairoMatrix } from "./matrix.js";
-
-const { bind } = t;
-const PATTERN_T = t.boxed("CairoPattern", {
-    ownership: "borrowed",
-    sharedLibrary: "libcairo-gobject.so.2",
-    getTypeFnName: "cairo_gobject_pattern_get_type",
-});
-
-export type RgbaColor = {
-    red: number;
-    green: number;
-    blue: number;
-    alpha: number;
-};
-
-const readRgba = (
-    fill: (red: { value: number }, green: { value: number }, blue: { value: number }, alpha: { value: number }) => void,
-): RgbaColor => {
-    const redRef = { value: 0 };
-    const greenRef = { value: 0 };
-    const blueRef = { value: 0 };
-    const alphaRef = { value: 0 };
-    fill(redRef, greenRef, blueRef, alphaRef);
-    return { red: redRef.value, green: greenRef.value, blue: blueRef.value, alpha: alphaRef.value };
-};
-
-declare module "../cairo.js" {
-    interface Pattern {
-        addColorStopRgb(offset: number, red: number, green: number, blue: number): void;
-        addColorStopRgba(offset: number, red: number, green: number, blue: number, alpha: number): void;
-        getColorStopCount(): number;
-        getColorStopRgba(index: number): { offset: number; red: number; green: number; blue: number; alpha: number };
-        getRgba(): { red: number; green: number; blue: number; alpha: number };
-        status(): Status;
-        setExtend(extend: Extend): void;
-        getExtend(): Extend;
-        setFilter(filter: Filter): void;
-        getFilter(): Filter;
-        setMatrix(matrix: CairoMatrix): void;
-        getMatrix(): CairoMatrix;
-        getType(): PatternType;
-        getReferenceCount(): number;
-    }
-
-    namespace Pattern {
-        function createRgb(red: number, green: number, blue: number): Pattern;
-        function createRgba(red: number, green: number, blue: number, alpha: number): Pattern;
-        function createLinear(x0: number, y0: number, x1: number, y1: number): LinearPattern;
-        function createRadial(
-            cx0: number,
-            cy0: number,
-            radius0: number,
-            cx1: number,
-            cy1: number,
-            radius1: number,
-        ): RadialPattern;
-        function createMesh(): MeshPattern;
-        function createForSurface(surface: Surface): Pattern;
-    }
-}
-
-const cairoPatternAddColorStopRgb = bind(
-    "libcairo.so.2",
-    "cairo_pattern_add_color_stop_rgb",
-    [PATTERN_T, t.float64, t.float64, t.float64, t.float64],
-    t.void,
-);
-Pattern.prototype.addColorStopRgb = function (offset: number, red: number, green: number, blue: number): void {
-    cairoPatternAddColorStopRgb(getHandle(this), offset, red, green, blue);
-};
-
-const cairoPatternAddColorStopRgba = bind(
-    "libcairo.so.2",
-    "cairo_pattern_add_color_stop_rgba",
-    [PATTERN_T, t.float64, t.float64, t.float64, t.float64, t.float64],
-    t.void,
-);
-Pattern.prototype.addColorStopRgba = function (
-    offset: number,
-    red: number,
-    green: number,
-    blue: number,
-    alpha: number,
-): void {
-    cairoPatternAddColorStopRgba(getHandle(this), offset, red, green, blue, alpha);
-};
-
-const cairoPatternGetColorStopCount = bind(
-    "libcairo.so.2",
-    "cairo_pattern_get_color_stop_count",
-    [PATTERN_T, t.ref(t.int32)],
-    t.int32,
-);
-Pattern.prototype.getColorStopCount = function (): number {
-    const countRef = { value: 0 };
-    cairoPatternGetColorStopCount(getHandle(this), countRef);
-    return countRef.value;
-};
-
-const cairoPatternGetColorStopRgba = bind(
-    "libcairo.so.2",
-    "cairo_pattern_get_color_stop_rgba",
-    [PATTERN_T, t.int32, t.ref(t.float64), t.ref(t.float64), t.ref(t.float64), t.ref(t.float64), t.ref(t.float64)],
-    t.int32,
-);
-Pattern.prototype.getColorStopRgba = function (index: number): {
-    offset: number;
-    red: number;
-    green: number;
-    blue: number;
-    alpha: number;
-} {
-    const offsetRef = { value: 0 };
-    const redRef = { value: 0 };
-    const greenRef = { value: 0 };
-    const blueRef = { value: 0 };
-    const alphaRef = { value: 0 };
-    cairoPatternGetColorStopRgba(getHandle(this), index, offsetRef, redRef, greenRef, blueRef, alphaRef);
-    return {
-        offset: offsetRef.value,
-        red: redRef.value,
-        green: greenRef.value,
-        blue: blueRef.value,
-        alpha: alphaRef.value,
-    };
-};
-
-const cairoPatternGetRgba = bind(
-    "libcairo.so.2",
-    "cairo_pattern_get_rgba",
-    [PATTERN_T, t.ref(t.float64), t.ref(t.float64), t.ref(t.float64), t.ref(t.float64)],
-    t.int32,
-);
-Pattern.prototype.getRgba = function (): RgbaColor {
-    return readRgba((red, green, blue, alpha) => cairoPatternGetRgba(getHandle(this), red, green, blue, alpha));
-};
-
-const cairoPatternStatus = bind("libcairo.so.2", "cairo_pattern_status", [PATTERN_T], t.int32);
-Pattern.prototype.status = function (): Status {
-    return cairoPatternStatus(getHandle(this)) as Status;
-};
-
-const cairoPatternSetExtend = bind("libcairo.so.2", "cairo_pattern_set_extend", [PATTERN_T, t.int32], t.void);
-Pattern.prototype.setExtend = function (extend: Extend): void {
-    cairoPatternSetExtend(getHandle(this), extend);
-};
-
-const cairoPatternGetExtend = bind("libcairo.so.2", "cairo_pattern_get_extend", [PATTERN_T], t.int32);
-Pattern.prototype.getExtend = function (): Extend {
-    return cairoPatternGetExtend(getHandle(this)) as Extend;
-};
-
-const cairoPatternSetFilter = bind("libcairo.so.2", "cairo_pattern_set_filter", [PATTERN_T, t.int32], t.void);
-Pattern.prototype.setFilter = function (filter: Filter): void {
-    cairoPatternSetFilter(getHandle(this), filter);
-};
-
-const cairoPatternGetFilter = bind("libcairo.so.2", "cairo_pattern_get_filter", [PATTERN_T], t.int32);
-Pattern.prototype.getFilter = function (): Filter {
-    return cairoPatternGetFilter(getHandle(this)) as Filter;
-};
-
-const cairoPatternSetMatrix = bind(
-    "libcairo.so.2",
-    "cairo_pattern_set_matrix",
-    [PATTERN_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
-    t.void,
-);
-Pattern.prototype.setMatrix = function (matrix: CairoMatrix): void {
-    cairoPatternSetMatrix(getHandle(this), getHandle(matrix));
-};
-
-const cairoPatternGetMatrix = bind(
-    "libcairo.so.2",
-    "cairo_pattern_get_matrix",
-    [PATTERN_T, t.boxed("cairo_matrix_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
-    t.void,
-);
-Pattern.prototype.getMatrix = function (): CairoMatrix {
-    const { handle, obj } = allocMatrix();
-    cairoPatternGetMatrix(getHandle(this), handle);
-    return obj;
-};
-
-const cairoPatternGetType = bind("libcairo.so.2", "cairo_pattern_get_type", [PATTERN_T], t.int32);
-Pattern.prototype.getType = function (): PatternType {
-    return cairoPatternGetType(getHandle(this)) as PatternType;
-};
-
-const cairoPatternGetReferenceCount = bind("libcairo.so.2", "cairo_pattern_get_reference_count", [PATTERN_T], t.int32);
-Pattern.prototype.getReferenceCount = function (): number {
-    return cairoPatternGetReferenceCount(getHandle(this)) as number;
-};
-
-const cairoPatternGetLinearPoints = bind(
-    "libcairo.so.2",
-    "cairo_pattern_get_linear_points",
-    [PATTERN_T, t.ref(t.float64), t.ref(t.float64), t.ref(t.float64), t.ref(t.float64)],
-    t.int32,
-);
-const cairoPatternGetRadialCircles = bind(
-    "libcairo.so.2",
-    "cairo_pattern_get_radial_circles",
-    [
-        PATTERN_T,
-        t.ref(t.float64),
-        t.ref(t.float64),
-        t.ref(t.float64),
-        t.ref(t.float64),
-        t.ref(t.float64),
-        t.ref(t.float64),
-    ],
-    t.int32,
-);
-const cairoMeshPatternBeginPatch = bind("libcairo.so.2", "cairo_mesh_pattern_begin_patch", [PATTERN_T], t.void);
-const cairoMeshPatternEndPatch = bind("libcairo.so.2", "cairo_mesh_pattern_end_patch", [PATTERN_T], t.void);
-const cairoMeshPatternMoveTo = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_move_to",
-    [PATTERN_T, t.float64, t.float64],
-    t.void,
-);
-const cairoMeshPatternLineTo = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_line_to",
-    [PATTERN_T, t.float64, t.float64],
-    t.void,
-);
-const cairoMeshPatternCurveTo = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_curve_to",
-    [PATTERN_T, t.float64, t.float64, t.float64, t.float64, t.float64, t.float64],
-    t.void,
-);
-const cairoMeshPatternSetControlPoint = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_set_control_point",
-    [PATTERN_T, t.int32, t.float64, t.float64],
-    t.void,
-);
-const cairoMeshPatternSetCornerColorRgb = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_set_corner_color_rgb",
-    [PATTERN_T, t.int32, t.float64, t.float64, t.float64],
-    t.void,
-);
-const cairoMeshPatternSetCornerColorRgba = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_set_corner_color_rgba",
-    [PATTERN_T, t.int32, t.float64, t.float64, t.float64, t.float64],
-    t.void,
-);
-const cairoMeshPatternGetPatchCount = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_get_patch_count",
-    [PATTERN_T, t.ref(t.int32)],
-    t.int32,
-);
-const cairoMeshPatternGetPath = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_get_path",
-    [PATTERN_T, t.int32],
-    t.boxed("cairo_path_t", { ownership: "full", sharedLibrary: "libcairo.so.2", freeFnName: "cairo_path_destroy" }),
-);
-const cairoMeshPatternGetControlPoint = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_get_control_point",
-    [PATTERN_T, t.int32, t.int32, t.ref(t.float64), t.ref(t.float64)],
-    t.int32,
-);
-const cairoMeshPatternGetCornerColorRgba = bind(
-    "libcairo.so.2",
-    "cairo_mesh_pattern_get_corner_color_rgba",
-    [PATTERN_T, t.int32, t.int32, t.ref(t.float64), t.ref(t.float64), t.ref(t.float64), t.ref(t.float64)],
-    t.int32,
-);
-
-export class LinearPattern extends Pattern {
-    getLinearPoints(): { x0: number; y0: number; x1: number; y1: number } {
-        const x0Ref = { value: 0 };
-        const y0Ref = { value: 0 };
-        const x1Ref = { value: 0 };
-        const y1Ref = { value: 0 };
-        cairoPatternGetLinearPoints(getHandle(this), x0Ref, y0Ref, x1Ref, y1Ref);
-        return { x0: x0Ref.value, y0: y0Ref.value, x1: x1Ref.value, y1: y1Ref.value };
-    }
-}
-
-export class RadialPattern extends Pattern {
-    getRadialCircles(): { x0: number; y0: number; r0: number; x1: number; y1: number; r1: number } {
-        const x0Ref = { value: 0 };
-        const y0Ref = { value: 0 };
-        const r0Ref = { value: 0 };
-        const x1Ref = { value: 0 };
-        const y1Ref = { value: 0 };
-        const r1Ref = { value: 0 };
-        cairoPatternGetRadialCircles(getHandle(this), x0Ref, y0Ref, r0Ref, x1Ref, y1Ref, r1Ref);
-        return {
-            x0: x0Ref.value,
-            y0: y0Ref.value,
-            r0: r0Ref.value,
-            x1: x1Ref.value,
-            y1: y1Ref.value,
-            r1: r1Ref.value,
-        };
-    }
-}
-
-export class MeshPattern extends Pattern {
-    beginPatch(): void {
-        cairoMeshPatternBeginPatch(getHandle(this));
-    }
-
-    endPatch(): void {
-        cairoMeshPatternEndPatch(getHandle(this));
-    }
-
-    moveTo(x: number, y: number): void {
-        cairoMeshPatternMoveTo(getHandle(this), x, y);
-    }
-
-    lineTo(x: number, y: number): void {
-        cairoMeshPatternLineTo(getHandle(this), x, y);
-    }
-
-    curveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void {
-        cairoMeshPatternCurveTo(getHandle(this), x1, y1, x2, y2, x3, y3);
-    }
-
-    setControlPoint(pointNum: number, x: number, y: number): void {
-        cairoMeshPatternSetControlPoint(getHandle(this), pointNum, x, y);
-    }
-
-    setCornerColorRgb(cornerNum: number, red: number, green: number, blue: number): void {
-        cairoMeshPatternSetCornerColorRgb(getHandle(this), cornerNum, red, green, blue);
-    }
-
-    setCornerColorRgba(cornerNum: number, red: number, green: number, blue: number, alpha: number): void {
-        cairoMeshPatternSetCornerColorRgba(getHandle(this), cornerNum, red, green, blue, alpha);
-    }
-
-    getPatchCount(): number {
-        const countRef = { value: 0 };
-        cairoMeshPatternGetPatchCount(getHandle(this), countRef);
-        return countRef.value;
-    }
-
-    getPath(patchNum: number): PathData[] {
-        return parsePath(cairoMeshPatternGetPath(getHandle(this), patchNum) as ExternalObject<Handle>);
-    }
-
-    getControlPoint(patchNum: number, pointNum: number): { x: number; y: number } {
-        const xRef = { value: 0 };
-        const yRef = { value: 0 };
-        cairoMeshPatternGetControlPoint(getHandle(this), patchNum, pointNum, xRef, yRef);
-        return { x: xRef.value, y: yRef.value };
-    }
-
-    getCornerColorRgba(patchNum: number, cornerNum: number): RgbaColor {
-        return readRgba((red, green, blue, alpha) =>
-            cairoMeshPatternGetCornerColorRgba(getHandle(this), patchNum, cornerNum, red, green, blue, alpha),
-        );
-    }
-}
-
-type PatternStatic = {
-    createRgb(red: number, green: number, blue: number): Pattern;
-    createRgba(red: number, green: number, blue: number, alpha: number): Pattern;
-    createLinear(x0: number, y0: number, x1: number, y1: number): LinearPattern;
-    createRadial(cx0: number, cy0: number, radius0: number, cx1: number, cy1: number, radius1: number): RadialPattern;
-    createMesh(): MeshPattern;
-    createForSurface(surface: Surface): Pattern;
-};
-
-const PatternWithStatics = Pattern as typeof Pattern & PatternStatic;
-
-const cairoPatternCreateRgb = bind(
-    "libcairo.so.2",
-    "cairo_pattern_create_rgb",
-    [t.float64, t.float64, t.float64],
-    t.boxed("CairoPattern", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_pattern_get_type",
-    }),
-);
-PatternWithStatics.createRgb = (red: number, green: number, blue: number): Pattern => {
-    return wrapHandle(cairoPatternCreateRgb(red, green, blue) as ExternalObject<Handle>, Pattern);
-};
-
-const cairoPatternCreateRgba = bind(
-    "libcairo.so.2",
-    "cairo_pattern_create_rgba",
-    [t.float64, t.float64, t.float64, t.float64],
-    t.boxed("CairoPattern", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_pattern_get_type",
-    }),
-);
-PatternWithStatics.createRgba = (red: number, green: number, blue: number, alpha: number): Pattern => {
-    return wrapHandle(cairoPatternCreateRgba(red, green, blue, alpha) as ExternalObject<Handle>, Pattern);
-};
-
-const cairoPatternCreateLinear = bind(
-    "libcairo.so.2",
-    "cairo_pattern_create_linear",
-    [t.float64, t.float64, t.float64, t.float64],
-    t.boxed("CairoPattern", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_pattern_get_type",
-    }),
-);
-PatternWithStatics.createLinear = (x0: number, y0: number, x1: number, y1: number): LinearPattern => {
-    return wrapHandle(cairoPatternCreateLinear(x0, y0, x1, y1) as ExternalObject<Handle>, LinearPattern);
-};
-
-const cairoPatternCreateRadial = bind(
-    "libcairo.so.2",
-    "cairo_pattern_create_radial",
-    [t.float64, t.float64, t.float64, t.float64, t.float64, t.float64],
-    t.boxed("CairoPattern", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_pattern_get_type",
-    }),
-);
-PatternWithStatics.createRadial = (
-    cx0: number,
-    cy0: number,
-    radius0: number,
-    cx1: number,
-    cy1: number,
-    radius1: number,
-): RadialPattern => {
-    return wrapHandle(cairoPatternCreateRadial(cx0, cy0, radius0, cx1, cy1, radius1) as ExternalObject<Handle>, RadialPattern);
-};
-
-const cairoPatternCreateMesh = bind(
-    "libcairo.so.2",
-    "cairo_pattern_create_mesh",
-    [],
-    t.boxed("CairoPattern", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_pattern_get_type",
-    }),
-);
-PatternWithStatics.createMesh = (): MeshPattern => {
-    return wrapHandle(cairoPatternCreateMesh() as ExternalObject<Handle>, MeshPattern);
-};
-
-const cairoPatternCreateForSurface = bind(
-    "libcairo.so.2",
-    "cairo_pattern_create_for_surface",
-    [
-        t.boxed("CairoSurface", {
-            ownership: "borrowed",
-            sharedLibrary: "libcairo-gobject.so.2",
-            getTypeFnName: "cairo_gobject_surface_get_type",
-        }),
-    ],
-    t.boxed("CairoPattern", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_pattern_get_type",
-    }),
-);
-PatternWithStatics.createForSurface = (surface: Surface): Pattern => {
-    return wrapHandle(cairoPatternCreateForSurface(getHandle(surface)) as ExternalObject<Handle>, Pattern);
-};

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

@@ -1,102 +0,0 @@
-import { alloc, type ExternalObject, getHandle, type Handle, read, setHandle, t, write } from "@gtkx/runtime";
-import type { Content } from "../cairo.js";
-import { Surface } from "../cairo.js";
-
-const { bind } = t;
-const RECT_T = t.boxed("cairo_rectangle_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" });
-
-const cairoRecordingSurfaceCreateExtents = bind(
-    "libcairo.so.2",
-    "cairo_recording_surface_create",
-    [t.int32, RECT_T],
-    t.boxed("CairoSurface", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_surface_get_type",
-    }),
-);
-const cairoRecordingSurfaceCreateUnbounded = bind(
-    "libcairo.so.2",
-    "cairo_recording_surface_create",
-    [t.int32, t.uint64],
-    t.boxed("CairoSurface", {
-        ownership: "full",
-        sharedLibrary: "libcairo-gobject.so.2",
-        getTypeFnName: "cairo_gobject_surface_get_type",
-    }),
-);
-const cairoRecordingSurfaceInkExtents = bind(
-    "libcairo.so.2",
-    "cairo_recording_surface_ink_extents",
-    [
-        t.boxed("CairoSurface", {
-            ownership: "borrowed",
-            sharedLibrary: "libcairo-gobject.so.2",
-            getTypeFnName: "cairo_gobject_surface_get_type",
-        }),
-        t.ref(t.float64),
-        t.ref(t.float64),
-        t.ref(t.float64),
-        t.ref(t.float64),
-    ],
-    t.void,
-);
-const cairoRecordingSurfaceGetExtents = bind(
-    "libcairo.so.2",
-    "cairo_recording_surface_get_extents",
-    [
-        t.boxed("CairoSurface", {
-            ownership: "borrowed",
-            sharedLibrary: "libcairo-gobject.so.2",
-            getTypeFnName: "cairo_gobject_surface_get_type",
-        }),
-        RECT_T,
-    ],
-    t.boolean,
-);
-
-export class RecordingSurface extends Surface {
-    constructor(content: Content, extents?: { x: number; y: number; width: number; height: number }) {
-        super();
-        let handle: ExternalObject<Handle>;
-        if (extents) {
-            const rect = alloc(32);
-            write(rect, t.float64, 0, extents.x);
-            write(rect, t.float64, 8, extents.y);
-            write(rect, t.float64, 16, extents.width);
-            write(rect, t.float64, 24, extents.height);
-            handle = cairoRecordingSurfaceCreateExtents(content, rect) as ExternalObject<Handle>;
-        } else {
-            handle = cairoRecordingSurfaceCreateUnbounded(content, 0) as ExternalObject<Handle>;
-        }
-        setHandle(this, handle);
-    }
-
-    static create(
-        content: Content,
-        extents?: { x: number; y: number; width: number; height: number },
-    ): RecordingSurface {
-        return new RecordingSurface(content, extents);
-    }
-
-    inkExtents(): { x0: number; y0: number; width: number; height: number } {
-        const x0Ref = { value: 0 };
-        const y0Ref = { value: 0 };
-        const widthRef = { value: 0 };
-        const heightRef = { value: 0 };
-        cairoRecordingSurfaceInkExtents(getHandle(this), x0Ref, y0Ref, widthRef, heightRef);
-        return { x0: x0Ref.value, y0: y0Ref.value, width: widthRef.value, height: heightRef.value };
-    }
-
-    getExtents(): { x: number; y: number; width: number; height: number } | null {
-        const rect = alloc(32);
-        const result = cairoRecordingSurfaceGetExtents(getHandle(this), rect) as boolean;
-        if (!result) return null;
-        return {
-            x: read(rect, t.float64, 0) as number,
-            y: read(rect, t.float64, 8) as number,
-            width: read(rect, t.float64, 16) as number,
-            height: read(rect, t.float64, 24) as number,
-        };
-    }
-}