@gtkx/cairo 1.2.2 → 1.4.0

package/src/status.ts

@@ -0,0 +1,23 @@
+import type { ExternalObject, Handle } from "@gtkx/runtime";
+import { t } from "@gtkx/runtime";
+import { Status } from "./enums.js";
+import { bindCairo, SURFACE_T } from "./lib.js";
+import { statusToString } from "./version.js";
+
+const cairoSurfaceStatus = bindCairo("cairo_surface_status", [SURFACE_T], t.int32);
+
+const checkStatus = (status: Status, subject: string): void => {
+    if (status === Status.SUCCESS) {
+        return;
+    }
+
+    throw new Error(`cairo error on ${subject}: "${statusToString(status)}" (${String(status)})`);
+};
+
+const checkSurface = (handle: ExternalObject<Handle>): ExternalObject<Handle> => {
+    checkStatus(cairoSurfaceStatus(handle) as Status, "surface");
+
+    return handle;
+};
+
+export { checkStatus, checkSurface };

package/src/structs.ts

@@ -147,7 +147,7 @@ class Rectangle {
     }
 }
 
-/** A rectangle with integer edges, as regions and `Surface.mapToImage` use. */
+/** A rectangle with integer edges, as Cairo regions use. */
 class RectangleInt {
     static {
         registerWrapperClass(this, RECTANGLE_INT_TYPE);

package/src/surface.ts

@@ -3,7 +3,6 @@ import {
     type ExternalObject,
     getHandle,
     type Handle,
-    read,
     registerWrapperClass,
     registerWrapperClassResolver,
     setHandle,
@@ -12,7 +11,6 @@ import {
     type WrapperClassResolver,
     write,
 } from "@gtkx/runtime";
-import type { RectangleInt } from "./structs.js";
 import type { DeviceOffset, DeviceScale, FallbackResolution, InkExtents, RectangleData } from "./types.js";
 import { type Content, type Format, type Status, SurfaceType } from "./enums.js";
 import { FontOptions } from "./font-options.js";
@@ -22,14 +20,16 @@ import {
     cairoGType,
     DEVICE_T,
     FONT_OPTIONS_T,
-    RECTANGLE_INT_T,
     RECTANGLE_T,
     SURFACE_FULL_T,
     SURFACE_T,
 } from "./lib.js";
+import { checkSurface } from "./status.js";
 
 const SURFACE_TYPE = cairoGType("cairo_gobject_surface_get_type");
 const RECTANGLE_SIZE = 32;
+const DOUBLE = t.fieldAt(t.float64);
+const UINT8 = t.fieldAt(t.uint8);
 const DEVICE_PAIR_ARGS = [SURFACE_T, t.float64, t.float64];
 const DEVICE_PAIR_OUT_ARGS = [SURFACE_T, t.ref(t.float64), t.ref(t.float64)];
 const SIMILAR_ARGS = [SURFACE_T, t.int32, t.int32, t.int32];
@@ -81,8 +81,6 @@ const cairoSurfaceSupportsMimeType = bindCairo(
     t.boolean,
 );
 
-const cairoSurfaceMapToImage = bindCairo("cairo_surface_map_to_image", [SURFACE_T, RECTANGLE_INT_T], SURFACE_T);
-const cairoSurfaceUnmapImage = bindCairo("cairo_surface_unmap_image", [SURFACE_T, SURFACE_T], t.void);
 const cairoImageSurfaceCreate = bindCairo("cairo_image_surface_create", [t.int32, t.int32, t.int32], SURFACE_FULL_T);
 
 const cairoImageSurfaceCreateFromPng = bindCairo(
@@ -136,10 +134,10 @@ const allocRectangle = (rect: RectangleData): ExternalObject<Handle> => {
 };
 
 const readRectangle = (buffer: ExternalObject<Handle>): RectangleData => ({
-    x: read(buffer, t.float64, 0) as number,
-    y: read(buffer, t.float64, 8) as number,
-    width: read(buffer, t.float64, 16) as number,
-    height: read(buffer, t.float64, 24) as number,
+    x: DOUBLE.read(buffer, 0) as number,
+    y: DOUBLE.read(buffer, 8) as number,
+    width: DOUBLE.read(buffer, 16) as number,
+    height: DOUBLE.read(buffer, 24) as number,
 });
 
 const createRecordingSurface = (content: Content, extents?: RectangleData): ExternalObject<Handle> =>
@@ -174,17 +172,25 @@ abstract class Surface {
 
     /** Creates a surface of the given `content` and size as compatible as possible with `other`. */
     static createSimilar(other: Surface, content: Content, width: number, height: number): Surface {
-        return wrapSurface(cairoSurfaceCreateSimilar(getHandle(other), content, width, height));
+        const handle = cairoSurfaceCreateSimilar(getHandle(other), content, width, height) as ExternalObject<Handle>;
+
+        return wrapSurface(checkSurface(handle));
     }
 
     /** Creates an image surface of the given `format` and size as compatible as possible with `other`. */
-    static createSimilarImage(other: Surface, format: Format, width: number, height: number): Surface {
-        return wrapSurface(cairoSurfaceCreateSimilarImage(getHandle(other), format, width, height));
+    static createSimilarImage(other: Surface, format: Format, width: number, height: number): ImageSurface {
+        const handle =
+            cairoSurfaceCreateSimilarImage(getHandle(other), format, width, height) as ExternalObject<Handle>;
+
+        return wrapHandle(checkSurface(handle), ImageSurface);
     }
 
     /** Creates a surface that draws onto the given rectangle of `target`. */
     static createForRectangle(target: Surface, x: number, y: number, width: number, height: number): Surface {
-        return wrapSurface(cairoSurfaceCreateForRectangle(getHandle(target), x, y, width, height));
+        const handle =
+            cairoSurfaceCreateForRectangle(getHandle(target), x, y, width, height) as ExternalObject<Handle>;
+
+        return wrapSurface(checkSurface(handle));
     }
 
     /** GType of `CairoSurface`, the boxed type this class is registered under. */
@@ -300,34 +306,27 @@ abstract class Surface {
     supportsMimeType(mimeType: string): boolean {
         return cairoSurfaceSupportsMimeType(getHandle(this), mimeType) as boolean;
     }
-
-    /** Returns an image surface giving direct access to the pixels of `extents`; release it with `unmapImage`. */
-    mapToImage(extents: RectangleInt): Surface {
-        return wrapSurface(cairoSurfaceMapToImage(getHandle(this), getHandle(extents)));
-    }
-
-    /** Uploads the pixels of `image`, obtained from `mapToImage`, back to the surface and releases it. */
-    unmapImage(image: Surface): void {
-        cairoSurfaceUnmapImage(getHandle(this), getHandle(image));
-    }
 }
 
 /** A surface backed by an in-memory pixel buffer, the usual target for offscreen drawing. */
 class ImageSurface extends Surface {
     /** Creates an image surface of the given pixel `format` and size, the same as `new ImageSurface(...)`. */
     static create(format: Format, width: number, height: number): ImageSurface {
-        return wrapHandle(cairoImageSurfaceCreate(format, width, height) as ExternalObject<Handle>, this);
+        return wrapHandle(
+            checkSurface(cairoImageSurfaceCreate(format, width, height) as ExternalObject<Handle>),
+            this,
+        );
     }
 
-    /** Loads a PNG file into a new image surface; a missing or invalid file yields a surface in an error status. */
+    /** Loads a PNG file into a new image surface; throws when the file is missing or invalid. */
     static createFromPng(filename: string): ImageSurface {
-        return wrapHandle(cairoImageSurfaceCreateFromPng(filename) as ExternalObject<Handle>, this);
+        return wrapHandle(checkSurface(cairoImageSurfaceCreateFromPng(filename) as ExternalObject<Handle>), this);
     }
 
     /** Creates an image surface of the given pixel `format` and size. */
     constructor(format: Format, width: number, height: number) {
         super();
-        setHandle(this, cairoImageSurfaceCreate(format, width, height) as ExternalObject<Handle>);
+        setHandle(this, checkSurface(cairoImageSurfaceCreate(format, width, height) as ExternalObject<Handle>));
     }
 
     /** Returns the width of the surface in pixels. */
@@ -371,7 +370,7 @@ class ImageSurface extends Surface {
             return new Uint8Array(0);
         }
 
-        return Uint8Array.from({ length: totalBytes }, (_, index) => read(data, t.uint8, index) as number);
+        return Uint8Array.from({ length: totalBytes }, (_, index) => UINT8.read(data, index) as number);
     }
 }
 
@@ -385,7 +384,7 @@ class RecordingSurface extends Surface {
     /** Creates a recording surface of the given `content`, bounded to `extents` or unbounded when omitted. */
     constructor(content: Content, extents?: RectangleData) {
         super();
-        setHandle(this, createRecordingSurface(content, extents));
+        setHandle(this, checkSurface(createRecordingSurface(content, extents)));
     }
 
     /** Returns the area that has been drawn on so far. */

package/src/text.ts

@@ -1,19 +1,22 @@
-import { alloc, type ExternalObject, type Handle, read, t, write } from "@gtkx/runtime";
+import { alloc, type ExternalObject, type Handle, t } from "@gtkx/runtime";
 import type { CairoGlyph, CairoTextCluster, FontExtents, TextExtents } from "./types.js";
 
 const GLYPH_SIZE = 24;
 const CLUSTER_SIZE = 8;
 const TEXT_EXTENTS_SIZE = 48;
 const FONT_EXTENTS_SIZE = 40;
+const DOUBLE = t.fieldAt(t.float64);
+const UINT64 = t.fieldAt(t.uint64);
+const INT = t.fieldAt(t.int32);
 
 const allocGlyphBuffer = (glyphs: CairoGlyph[]): ExternalObject<Handle> => {
     const buffer = alloc(glyphs.length * GLYPH_SIZE);
     let offset = 0;
 
     for (const glyph of glyphs) {
-        write(buffer, t.uint64, offset, glyph.index);
-        write(buffer, t.float64, offset + 8, glyph.x);
-        write(buffer, t.float64, offset + 16, glyph.y);
+        UINT64.write(buffer, offset, glyph.index);
+        DOUBLE.write(buffer, offset + 8, glyph.x);
+        DOUBLE.write(buffer, offset + 16, glyph.y);
         offset += GLYPH_SIZE;
     }
 
@@ -25,8 +28,8 @@ const allocClusterBuffer = (clusters: CairoTextCluster[]): ExternalObject<Handle
     let offset = 0;
 
     for (const cluster of clusters) {
-        write(buffer, t.int32, offset, cluster.numBytes);
-        write(buffer, t.int32, offset + 4, cluster.numGlyphs);
+        INT.write(buffer, offset, cluster.numBytes);
+        INT.write(buffer, offset + 4, cluster.numGlyphs);
         offset += CLUSTER_SIZE;
     }
 
@@ -37,20 +40,20 @@ const allocTextExtents = (): ExternalObject<Handle> => alloc(TEXT_EXTENTS_SIZE);
 const allocFontExtents = (): ExternalObject<Handle> => alloc(FONT_EXTENTS_SIZE);
 
 const readTextExtents = (handle: ExternalObject<Handle>): TextExtents => ({
-    xBearing: read(handle, t.float64, 0) as number,
-    yBearing: read(handle, t.float64, 8) as number,
-    width: read(handle, t.float64, 16) as number,
-    height: read(handle, t.float64, 24) as number,
-    xAdvance: read(handle, t.float64, 32) as number,
-    yAdvance: read(handle, t.float64, 40) as number,
+    xBearing: DOUBLE.read(handle, 0) as number,
+    yBearing: DOUBLE.read(handle, 8) as number,
+    width: DOUBLE.read(handle, 16) as number,
+    height: DOUBLE.read(handle, 24) as number,
+    xAdvance: DOUBLE.read(handle, 32) as number,
+    yAdvance: DOUBLE.read(handle, 40) as number,
 });
 
 const readFontExtents = (handle: ExternalObject<Handle>): FontExtents => ({
-    ascent: read(handle, t.float64, 0) as number,
-    descent: read(handle, t.float64, 8) as number,
-    height: read(handle, t.float64, 16) as number,
-    maxXAdvance: read(handle, t.float64, 24) as number,
-    maxYAdvance: read(handle, t.float64, 32) as number,
+    ascent: DOUBLE.read(handle, 0) as number,
+    descent: DOUBLE.read(handle, 8) as number,
+    height: DOUBLE.read(handle, 16) as number,
+    maxXAdvance: DOUBLE.read(handle, 24) as number,
+    maxYAdvance: DOUBLE.read(handle, 32) as number,
 });
 
 export { allocClusterBuffer, allocFontExtents, allocGlyphBuffer, allocTextExtents, readFontExtents, readTextExtents };