@gtkx/cairo 1.3.0 → 1.4.0

package/src/scaled-font.ts

@@ -2,14 +2,13 @@ import {
     type ExternalObject,
     getHandle,
     type Handle,
-    read,
     registerWrapperClass,
     setHandle,
     t,
     wrapHandle,
 } from "@gtkx/runtime";
-import type { FontType, Status, TextClusterFlags } from "./enums.js";
-import type { CairoGlyph, CairoTextCluster, FontExtents, TextExtents } from "./types.js";
+import type { FontType, Status } from "./enums.js";
+import type { CairoGlyph, FontExtents, TextExtents } from "./types.js";
 import { FontFace } from "./font-face.js";
 import { FontOptions } from "./font-options.js";
 import {
@@ -23,23 +22,18 @@ import {
     MATRIX_T,
     SCALED_FONT_FULL_T,
     SCALED_FONT_T,
-    TEXT_CLUSTER_T,
     TEXT_EXTENTS_T,
 } from "./lib.js";
 import { allocMatrix, Matrix } from "./matrix.js";
 import { allocFontExtents, allocGlyphBuffer, allocTextExtents, readFontExtents, readTextExtents } from "./text.js";
 
 const SCALED_FONT_TYPE = cairoGType("cairo_gobject_scaled_font_get_type");
-const GLYPH_SIZE = 24;
-const CLUSTER_SIZE = 8;
 const cairoScaledFontStatus = bindCairo("cairo_scaled_font_status", [SCALED_FONT_T], t.int32);
 const cairoScaledFontExtents = bindCairo("cairo_scaled_font_extents", [SCALED_FONT_T, FONT_EXTENTS_T], t.void);
 const cairoScaledFontGetFontFace = bindCairo("cairo_scaled_font_get_font_face", [SCALED_FONT_T], FONT_FACE_T);
 const cairoScaledFontGetFontMatrix = bindCairo("cairo_scaled_font_get_font_matrix", [SCALED_FONT_T, MATRIX_T], t.void);
 const cairoScaledFontGetCtm = bindCairo("cairo_scaled_font_get_ctm", [SCALED_FONT_T, MATRIX_T], t.void);
 const cairoScaledFontGetType = bindCairo("cairo_scaled_font_get_type", [SCALED_FONT_T], t.int32);
-const cairoGlyphFree = bindCairo("cairo_glyph_free", [GLYPH_T], t.void);
-const cairoTextClusterFree = bindCairo("cairo_text_cluster_free", [TEXT_CLUSTER_T], t.void);
 
 const cairoScaledFontCreate = bindCairo(
     "cairo_scaled_font_create",
@@ -77,23 +71,6 @@ const cairoScaledFontGetReferenceCount = bindCairo(
     t.int32,
 );
 
-const cairoScaledFontTextToGlyphs = bindCairo(
-    "cairo_scaled_font_text_to_glyphs",
-    [
-        SCALED_FONT_T,
-        t.float64,
-        t.float64,
-        t.string("full"),
-        t.int32,
-        t.ref(t.struct("borrowed")),
-        t.ref(t.int32),
-        t.ref(t.struct("borrowed")),
-        t.ref(t.int32),
-        t.ref(t.int32),
-    ],
-    t.int32,
-);
-
 const readMatrixVia = (self: ScaledFont, boundFn: BoundFunction): Matrix => {
     const { handle, matrix } = allocMatrix();
     boundFn(getHandle(self), handle);
@@ -101,40 +78,9 @@ const readMatrixVia = (self: ScaledFont, boundFn: BoundFunction): Matrix => {
     return matrix;
 };
 
-const readGlyphs = (buffer: ExternalObject<Handle> | null, count: number): CairoGlyph[] => {
-    if (buffer === null) {
-        return [];
-    }
-
-    return Array.from({ length: count }, (_, index) => {
-        const offset = index * GLYPH_SIZE;
-
-        return {
-            index: read(buffer, t.uint64, offset) as number,
-            x: read(buffer, t.float64, offset + 8) as number,
-            y: read(buffer, t.float64, offset + 16) as number,
-        };
-    });
-};
-
-const readClusters = (buffer: ExternalObject<Handle> | null, count: number): CairoTextCluster[] => {
-    if (buffer === null) {
-        return [];
-    }
-
-    return Array.from({ length: count }, (_, index) => {
-        const offset = index * CLUSTER_SIZE;
-
-        return {
-            numBytes: read(buffer, t.int32, offset) as number,
-            numGlyphs: read(buffer, t.int32, offset + 4) as number,
-        };
-    });
-};
-
 /**
  * A cairo scaled font (`cairo_scaled_font_t`): a font face frozen at a given font matrix, transformation and
- * set of font options, ready to measure and shape text.
+ * set of font options, ready to measure text and positioned glyphs.
  */
 class ScaledFont {
     static {
@@ -228,41 +174,6 @@ class ScaledFont {
     getReferenceCount(): number {
         return cairoScaledFontGetReferenceCount(getHandle(this)) as number;
     }
-
-    /** Shapes `text` starting at `(x, y)` into glyphs, clusters and the flags describing their order. */
-    textToGlyphs(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 glyphs = readGlyphs(glyphsRef.value, numGlyphsRef.value);
-        const clusters = readClusters(clustersRef.value, numClustersRef.value);
-
-        if (glyphsRef.value !== null) {
-            cairoGlyphFree(glyphsRef.value);
-        }
-
-        if (clustersRef.value !== null) {
-            cairoTextClusterFree(clustersRef.value);
-        }
-
-        return [glyphs, clusters, clusterFlagsRef.value as TextClusterFlags];
-    }
 }
 
 export { ScaledFont };

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,7 +20,6 @@ import {
     cairoGType,
     DEVICE_T,
     FONT_OPTIONS_T,
-    RECTANGLE_INT_T,
     RECTANGLE_T,
     SURFACE_FULL_T,
     SURFACE_T,
@@ -31,6 +28,8 @@ 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];
@@ -82,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(
@@ -137,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> =>
@@ -309,16 +306,6 @@ 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. */
@@ -383,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);
     }
 }
 

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 };