@gtkx/ffi 0.9.4 → 0.10.0

package/dist/cairo/cairo.js

@@ -1,271 +1,409 @@
-/**
- * Cairo drawing function bindings via libcairo.
- * These wrap Cairo calls for use in GtkDrawingArea draw callbacks.
- */
-import { call } from "@gtkx/native";
+// biome-ignore-all lint/suspicious/noExplicitAny: Cairo FFI requires dynamic typing for GObject interop
+// biome-ignore-all lint/style/noNonNullAssertion: Cairo FFI returns valid pointers that are guaranteed non-null
+import { alloc, call, read } from "@gtkx/native";
+import { Context } from "../generated/cairo/context.js";
+import { FontOptions } from "../generated/cairo/font-options.js";
+import { Pattern } from "../generated/cairo/pattern.js";
+export { Context, Pattern, FontOptions };
 const LIB = "libcairo.so.2";
-const CAIRO_T = { type: "boxed", innerType: "cairo_t", lib: LIB, borrowed: true };
-/**
- * Begin a new sub-path. After this call the current point will be (x, y).
- */
-export function moveTo(cr, x, y) {
+const LIB_GOBJECT = "libcairo-gobject.so.2";
+const FONT_OPTIONS_T = {
+    type: "boxed",
+    innerType: "CairoFontOptions",
+    lib: LIB_GOBJECT,
+    getTypeFn: "cairo_gobject_font_options_get_type",
+    borrowed: true,
+};
+const CAIRO_T = {
+    type: "boxed",
+    innerType: "CairoContext",
+    lib: LIB_GOBJECT,
+    getTypeFn: "cairo_gobject_context_get_type",
+    borrowed: true,
+};
+const PATTERN_T = {
+    type: "boxed",
+    innerType: "CairoPattern",
+    lib: LIB_GOBJECT,
+    getTypeFn: "cairo_gobject_pattern_get_type",
+    borrowed: false,
+};
+const PATTERN_T_BORROWED = {
+    type: "boxed",
+    innerType: "CairoPattern",
+    lib: LIB_GOBJECT,
+    getTypeFn: "cairo_gobject_pattern_get_type",
+    borrowed: true,
+};
+const DOUBLE_TYPE = { type: "float", size: 64 };
+Context.prototype.moveTo = function (x, y) {
     call(LIB, "cairo_move_to", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: x },
-        { type: { type: "float", size: 64 }, value: y },
-    ], { type: "undefined" });
-}
-/**
- * Adds a line to the path from the current point to position (x, y).
- */
-export function lineTo(cr, x, y) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: x },
+        { type: DOUBLE_TYPE, value: y },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.lineTo = function (x, y) {
     call(LIB, "cairo_line_to", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: x },
-        { type: { type: "float", size: 64 }, value: y },
-    ], { type: "undefined" });
-}
-/**
- * Adds a cubic Bezier spline to the path.
- */
-export function curveTo(cr, x1, y1, x2, y2, x3, y3) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: x },
+        { type: DOUBLE_TYPE, value: y },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.curveTo = function (x1, y1, x2, y2, x3, y3) {
     call(LIB, "cairo_curve_to", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: x1 },
-        { type: { type: "float", size: 64 }, value: y1 },
-        { type: { type: "float", size: 64 }, value: x2 },
-        { type: { type: "float", size: 64 }, value: y2 },
-        { type: { type: "float", size: 64 }, value: x3 },
-        { type: { type: "float", size: 64 }, value: y3 },
-    ], { type: "undefined" });
-}
-/**
- * Adds a circular arc to the current path.
- * @param xc - X position of the center of the arc
- * @param yc - Y position of the center of the arc
- * @param radius - The radius of the arc
- * @param angle1 - The start angle, in radians
- * @param angle2 - The end angle, in radians
- */
-export function arc(cr, xc, yc, radius, angle1, angle2) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: x1 },
+        { type: DOUBLE_TYPE, value: y1 },
+        { type: DOUBLE_TYPE, value: x2 },
+        { type: DOUBLE_TYPE, value: y2 },
+        { type: DOUBLE_TYPE, value: x3 },
+        { type: DOUBLE_TYPE, value: y3 },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.arc = function (xc, yc, radius, angle1, angle2) {
     call(LIB, "cairo_arc", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: xc },
-        { type: { type: "float", size: 64 }, value: yc },
-        { type: { type: "float", size: 64 }, value: radius },
-        { type: { type: "float", size: 64 }, value: angle1 },
-        { type: { type: "float", size: 64 }, value: angle2 },
-    ], { type: "undefined" });
-}
-/**
- * Adds a circular arc to the current path (counter-clockwise).
- */
-export function arcNegative(cr, xc, yc, radius, angle1, angle2) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: xc },
+        { type: DOUBLE_TYPE, value: yc },
+        { type: DOUBLE_TYPE, value: radius },
+        { type: DOUBLE_TYPE, value: angle1 },
+        { type: DOUBLE_TYPE, value: angle2 },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.arcNegative = function (xc, yc, radius, angle1, angle2) {
     call(LIB, "cairo_arc_negative", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: xc },
-        { type: { type: "float", size: 64 }, value: yc },
-        { type: { type: "float", size: 64 }, value: radius },
-        { type: { type: "float", size: 64 }, value: angle1 },
-        { type: { type: "float", size: 64 }, value: angle2 },
-    ], { type: "undefined" });
-}
-/**
- * Adds a closed sub-path rectangle to the current path.
- */
-export function rectangle(cr, x, y, width, height) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: xc },
+        { type: DOUBLE_TYPE, value: yc },
+        { type: DOUBLE_TYPE, value: radius },
+        { type: DOUBLE_TYPE, value: angle1 },
+        { type: DOUBLE_TYPE, value: angle2 },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.rectangle = function (x, y, width, height) {
     call(LIB, "cairo_rectangle", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: x },
-        { type: { type: "float", size: 64 }, value: y },
-        { type: { type: "float", size: 64 }, value: width },
-        { type: { type: "float", size: 64 }, value: height },
-    ], { type: "undefined" });
-}
-/**
- * Adds a line segment to the path from the current point to the beginning of the current sub-path.
- */
-export function closePath(cr) {
-    call(LIB, "cairo_close_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Clears the current path.
- */
-export function newPath(cr) {
-    call(LIB, "cairo_new_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Begin a new sub-path without clearing the current path.
- */
-export function newSubPath(cr) {
-    call(LIB, "cairo_new_sub_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Stroke the current path according to the current line width, line join, line cap, and dash settings.
- */
-export function stroke(cr) {
-    call(LIB, "cairo_stroke", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Stroke the current path but preserve the path for further use.
- */
-export function strokePreserve(cr) {
-    call(LIB, "cairo_stroke_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Fill the current path according to the current fill rule.
- */
-export function fill(cr) {
-    call(LIB, "cairo_fill", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Fill the current path but preserve the path for further use.
- */
-export function fillPreserve(cr) {
-    call(LIB, "cairo_fill_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Paint the current source everywhere within the current clip region.
- */
-export function paint(cr) {
-    call(LIB, "cairo_paint", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Paint the current source using alpha as a mask.
- */
-export function paintWithAlpha(cr, alpha) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: x },
+        { type: DOUBLE_TYPE, value: y },
+        { type: DOUBLE_TYPE, value: width },
+        { type: DOUBLE_TYPE, value: height },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.closePath = function () {
+    call(LIB, "cairo_close_path", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.newPath = function () {
+    call(LIB, "cairo_new_path", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.newSubPath = function () {
+    call(LIB, "cairo_new_sub_path", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.stroke = function () {
+    call(LIB, "cairo_stroke", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.strokePreserve = function () {
+    call(LIB, "cairo_stroke_preserve", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.fill = function () {
+    call(LIB, "cairo_fill", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.fillPreserve = function () {
+    call(LIB, "cairo_fill_preserve", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.paint = function () {
+    call(LIB, "cairo_paint", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.paintWithAlpha = function (alpha) {
     call(LIB, "cairo_paint_with_alpha", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: alpha },
-    ], { type: "undefined" });
-}
-/**
- * Sets the source pattern to an opaque color (RGB).
- */
-export function setSourceRgb(cr, red, green, blue) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: alpha },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.clip = function () {
+    call(LIB, "cairo_clip", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.clipPreserve = function () {
+    call(LIB, "cairo_clip_preserve", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.resetClip = function () {
+    call(LIB, "cairo_reset_clip", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.setSourceRgb = function (red, green, blue) {
     call(LIB, "cairo_set_source_rgb", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: red },
-        { type: { type: "float", size: 64 }, value: green },
-        { type: { type: "float", size: 64 }, value: blue },
-    ], { type: "undefined" });
-}
-/**
- * Sets the source pattern to a translucent color (RGBA).
- */
-export function setSourceRgba(cr, red, green, blue, alpha) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: red },
+        { type: DOUBLE_TYPE, value: green },
+        { type: DOUBLE_TYPE, value: blue },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.setSourceRgba = function (red, green, blue, alpha) {
     call(LIB, "cairo_set_source_rgba", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: red },
-        { type: { type: "float", size: 64 }, value: green },
-        { type: { type: "float", size: 64 }, value: blue },
-        { type: { type: "float", size: 64 }, value: alpha },
-    ], { type: "undefined" });
-}
-/**
- * Sets the current line width.
- */
-export function setLineWidth(cr, width) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: red },
+        { type: DOUBLE_TYPE, value: green },
+        { type: DOUBLE_TYPE, value: blue },
+        { type: DOUBLE_TYPE, value: alpha },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.setSource = function (pattern) {
+    call(LIB, "cairo_set_source", [
+        { type: CAIRO_T, value: this.id },
+        { type: PATTERN_T_BORROWED, value: pattern.id },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.setLineWidth = function (width) {
     call(LIB, "cairo_set_line_width", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: width },
-    ], { type: "undefined" });
-}
-/**
- * Sets the current line cap style.
- */
-export function setLineCap(cr, lineCap) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: width },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.setLineCap = function (lineCap) {
     call(LIB, "cairo_set_line_cap", [
-        { type: CAIRO_T, value: cr },
+        { type: CAIRO_T, value: this.id },
         { type: { type: "int", size: 32, unsigned: false }, value: lineCap },
     ], { type: "undefined" });
-}
-/**
- * Sets the current line join style.
- */
-export function setLineJoin(cr, lineJoin) {
+    return this;
+};
+Context.prototype.setLineJoin = function (lineJoin) {
     call(LIB, "cairo_set_line_join", [
-        { type: CAIRO_T, value: cr },
+        { type: CAIRO_T, value: this.id },
         { type: { type: "int", size: 32, unsigned: false }, value: lineJoin },
     ], { type: "undefined" });
-}
-/**
- * Sets the dash pattern to be used by stroke.
- */
-export function setDash(cr, dashes, offset) {
+    return this;
+};
+Context.prototype.setDash = function (dashes, offset) {
     call(LIB, "cairo_set_dash", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "array", itemType: { type: "float", size: 64 } }, value: dashes },
+        { type: CAIRO_T, value: this.id },
+        { type: { type: "array", itemType: DOUBLE_TYPE }, value: dashes },
         { type: { type: "int", size: 32, unsigned: false }, value: dashes.length },
-        { type: { type: "float", size: 64 }, value: offset },
-    ], { type: "undefined" });
-}
-/**
- * Makes a copy of the current state and saves it on an internal stack.
- */
-export function save(cr) {
-    call(LIB, "cairo_save", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Restores the state saved by a preceding call to save().
- */
-export function restore(cr) {
-    call(LIB, "cairo_restore", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Modifies the current transformation matrix by translating.
- */
-export function translate(cr, tx, ty) {
+        { type: DOUBLE_TYPE, value: offset },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.setFillRule = function (fillRule) {
+    call(LIB, "cairo_set_fill_rule", [
+        { type: CAIRO_T, value: this.id },
+        { type: { type: "int", size: 32, unsigned: false }, value: fillRule },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.getFillRule = function () {
+    return call(LIB, "cairo_get_fill_rule", [{ type: CAIRO_T, value: this.id }], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
+};
+Context.prototype.save = function () {
+    call(LIB, "cairo_save", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.restore = function () {
+    call(LIB, "cairo_restore", [{ type: CAIRO_T, value: this.id }], { type: "undefined" });
+    return this;
+};
+Context.prototype.translate = function (tx, ty) {
     call(LIB, "cairo_translate", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: tx },
-        { type: { type: "float", size: 64 }, value: ty },
-    ], { type: "undefined" });
-}
-/**
- * Modifies the current transformation matrix by scaling.
- */
-export function scale(cr, sx, sy) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: tx },
+        { type: DOUBLE_TYPE, value: ty },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.scale = function (sx, sy) {
     call(LIB, "cairo_scale", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: sx },
-        { type: { type: "float", size: 64 }, value: sy },
-    ], { type: "undefined" });
-}
-/**
- * Modifies the current transformation matrix by rotating.
- * @param angle - Angle of rotation in radians
- */
-export function rotate(cr, angle) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: sx },
+        { type: DOUBLE_TYPE, value: sy },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.rotate = function (angle) {
     call(LIB, "cairo_rotate", [
-        { type: CAIRO_T, value: cr },
-        { type: { type: "float", size: 64 }, value: angle },
-    ], { type: "undefined" });
-}
-/**
- * Establishes a new clip region by intersecting the current clip region with the current path.
- */
-export function clip(cr) {
-    call(LIB, "cairo_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Establishes a new clip region but preserves the path for further use.
- */
-export function clipPreserve(cr) {
-    call(LIB, "cairo_clip_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Reset the current clip region to its original, unrestricted state.
- */
-export function resetClip(cr) {
-    call(LIB, "cairo_reset_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
-}
-/**
- * Sets the compositing operator.
- */
-export function setOperator(cr, op) {
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: angle },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.setOperator = function (op) {
     call(LIB, "cairo_set_operator", [
-        { type: CAIRO_T, value: cr },
+        { type: CAIRO_T, value: this.id },
         { type: { type: "int", size: 32, unsigned: false }, value: op },
     ], { type: "undefined" });
-}
+    return this;
+};
+Context.prototype.selectFontFace = function (family, slant, weight) {
+    call(LIB, "cairo_select_font_face", [
+        { type: CAIRO_T, value: this.id },
+        { type: { type: "string" }, value: family },
+        { type: { type: "int", size: 32, unsigned: false }, value: slant },
+        { type: { type: "int", size: 32, unsigned: false }, value: weight },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.setFontSize = function (size) {
+    call(LIB, "cairo_set_font_size", [
+        { type: CAIRO_T, value: this.id },
+        { type: DOUBLE_TYPE, value: size },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.showText = function (text) {
+    call(LIB, "cairo_show_text", [
+        { type: CAIRO_T, value: this.id },
+        { type: { type: "string" }, value: text },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.textPath = function (text) {
+    call(LIB, "cairo_text_path", [
+        { type: CAIRO_T, value: this.id },
+        { type: { type: "string" }, value: text },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.textExtents = function (text) {
+    const extents = alloc(48, "cairo_text_extents_t", LIB);
+    call(LIB, "cairo_text_extents", [
+        { type: CAIRO_T, value: this.id },
+        { type: { type: "string" }, value: text },
+        { type: { type: "boxed", innerType: "cairo_text_extents_t", lib: LIB, borrowed: true }, value: extents },
+    ], { type: "undefined" });
+    return {
+        xBearing: read(extents, DOUBLE_TYPE, 0),
+        yBearing: read(extents, DOUBLE_TYPE, 8),
+        width: read(extents, DOUBLE_TYPE, 16),
+        height: read(extents, DOUBLE_TYPE, 24),
+        xAdvance: read(extents, DOUBLE_TYPE, 32),
+        yAdvance: read(extents, DOUBLE_TYPE, 40),
+    };
+};
+Context.prototype.setFontOptions = function (options) {
+    call(LIB, "cairo_set_font_options", [
+        { type: CAIRO_T, value: this.id },
+        { type: FONT_OPTIONS_T, value: options?.id ?? options },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.getFontOptions = function () {
+    const options = new FontOptions();
+    call(LIB, "cairo_get_font_options", [
+        { type: CAIRO_T, value: this.id },
+        { type: FONT_OPTIONS_T, value: options?.id ?? options },
+    ], { type: "undefined" });
+    return options;
+};
+Context.prototype.setAntialias = function (antialias) {
+    call(LIB, "cairo_set_antialias", [
+        { type: CAIRO_T, value: this.id },
+        { type: { type: "int", size: 32, unsigned: false }, value: antialias },
+    ], { type: "undefined" });
+    return this;
+};
+Context.prototype.getAntialias = function () {
+    return call(LIB, "cairo_get_antialias", [{ type: CAIRO_T, value: this.id }], {
+        type: "int",
+        size: 32,
+        unsigned: false,
+    });
+};
+Pattern.createLinear = (x0, y0, x1, y1) => {
+    const ptr = call(LIB, "cairo_pattern_create_linear", [
+        { type: DOUBLE_TYPE, value: x0 },
+        { type: DOUBLE_TYPE, value: y0 },
+        { type: DOUBLE_TYPE, value: x1 },
+        { type: DOUBLE_TYPE, value: y1 },
+    ], PATTERN_T);
+    return Pattern.fromPtr(ptr);
+};
+Pattern.createRadial = (cx0, cy0, radius0, cx1, cy1, radius1) => {
+    const ptr = call(LIB, "cairo_pattern_create_radial", [
+        { type: DOUBLE_TYPE, value: cx0 },
+        { type: DOUBLE_TYPE, value: cy0 },
+        { type: DOUBLE_TYPE, value: radius0 },
+        { type: DOUBLE_TYPE, value: cx1 },
+        { type: DOUBLE_TYPE, value: cy1 },
+        { type: DOUBLE_TYPE, value: radius1 },
+    ], PATTERN_T);
+    return Pattern.fromPtr(ptr);
+};
+Pattern.prototype.addColorStopRgb = function (offset, red, green, blue) {
+    call(LIB, "cairo_pattern_add_color_stop_rgb", [
+        { type: PATTERN_T_BORROWED, value: this.id },
+        { type: DOUBLE_TYPE, value: offset },
+        { type: DOUBLE_TYPE, value: red },
+        { type: DOUBLE_TYPE, value: green },
+        { type: DOUBLE_TYPE, value: blue },
+    ], { type: "undefined" });
+    return this;
+};
+Pattern.prototype.addColorStopRgba = function (offset, red, green, blue, alpha) {
+    call(LIB, "cairo_pattern_add_color_stop_rgba", [
+        { type: PATTERN_T_BORROWED, value: this.id },
+        { type: DOUBLE_TYPE, value: offset },
+        { type: DOUBLE_TYPE, value: red },
+        { type: DOUBLE_TYPE, value: green },
+        { type: DOUBLE_TYPE, value: blue },
+        { type: DOUBLE_TYPE, value: alpha },
+    ], { type: "undefined" });
+    return this;
+};
+// Override createPtr to allow `new FontOptions()` to work
+FontOptions.prototype.createPtr = () => call(LIB, "cairo_font_options_create", [], {
+    type: "boxed",
+    innerType: "CairoFontOptions",
+    lib: LIB_GOBJECT,
+    getTypeFn: "cairo_gobject_font_options_get_type",
+    borrowed: false,
+});
+FontOptions.prototype.setHintStyle = function (hintStyle) {
+    call(LIB, "cairo_font_options_set_hint_style", [
+        { type: FONT_OPTIONS_T, value: this.id },
+        { type: { type: "int", size: 32, unsigned: false }, value: hintStyle },
+    ], { type: "undefined" });
+    return this;
+};
+FontOptions.prototype.setAntialias = function (antialias) {
+    call(LIB, "cairo_font_options_set_antialias", [
+        { type: FONT_OPTIONS_T, value: this.id },
+        { type: { type: "int", size: 32, unsigned: false }, value: antialias },
+    ], { type: "undefined" });
+    return this;
+};
+FontOptions.prototype.setHintMetrics = function (hintMetrics) {
+    call(LIB, "cairo_font_options_set_hint_metrics", [
+        { type: FONT_OPTIONS_T, value: this.id },
+        { type: { type: "int", size: 32, unsigned: false }, value: hintMetrics },
+    ], { type: "undefined" });
+    return this;
+};
+FontOptions.prototype.setSubpixelOrder = function (subpixelOrder) {
+    call(LIB, "cairo_font_options_set_subpixel_order", [
+        { type: FONT_OPTIONS_T, value: this.id },
+        { type: { type: "int", size: 32, unsigned: false }, value: subpixelOrder },
+    ], { type: "undefined" });
+    return this;
+};