reamkit 1.22.0 → 1.24.0

package/dist/esm/core/metafile/emf.js

@@ -1,5 +1,7 @@
 import { PathBuilder } from "../vector.js";
-import { applyTransform, cloneDc, colorRef, newDeviceContext } from "./picture.js";
+import { applyTransform, clippedAway, cloneDc, colorRef, intersectClip, newDeviceContext, primBounds } from "./picture.js";
+import { cropDib, fadedDib, readDib } from "./dib.js";
+import { makeBlitter } from "./blit.js";
 import { fromSymbolFont } from "./symbol-fonts.js";
 //#region src/core/metafile/emf.ts
 /** Whether the bytes open with an EMF header (MS-EMF §2.3.4.2: type 1 + " EMF"). */
@@ -21,11 +23,6 @@ var RECORD_NAMES = new Map([
 	[74, "region paint"],
 	[78, "masked blit"],
 	[79, "parallelogram blit"],
-	[80, "device bitmap"],
-	[81, "bitmap"],
-	[76, "bitmap"],
-	[77, "bitmap"],
-	[114, "alpha blit"],
 	[116, "transparent blit"],
 	[118, "gradient fill"]
 ]);
@@ -74,9 +71,47 @@ function readEmf(bytes) {
 	};
 	let building;
 	const open = () => building ?? [];
+	const inFigure = () => {
+		const tail = building?.[building.length - 1];
+		return tail !== void 0 && tail.op !== "close";
+	};
+	const emit = (prim) => {
+		if (!clippedAway(dc, primBounds(prim))) prims.push(prim);
+	};
+	const blitter = makeBlitter(emit);
+	/**
+	* §2.3.1 — one blit record: the source bitmap into the destination
+	* rectangle, both stated in the record's own fields. The rectangle is mapped
+	* the way every other coordinate here is, so the picture lands in the same
+	* device frame as the paths around it.
+	*/
+	const blit = (o) => {
+		const dib = o.cbBmi > 0 ? readDib(bytes, off + o.bmiAt, {
+			bitsAt: off + o.bitsAt,
+			cbBits: o.cbBits,
+			...o.blend?.perPixel === true ? { alpha: true } : {}
+		}) : void 0;
+		if (!dib) {
+			skipped.add("bitmap");
+			return;
+		}
+		const s = o.src;
+		const part = s && (s.x !== 0 || s.y !== 0 || s.w !== dib.width || s.h !== dib.height) ? cropDib(dib, s.x, o.inBitmap === true && dib.bottomUp === true ? dib.height - s.y - s.h : s.y, s.w, s.h) : dib;
+		const a = px(o.dest.x, o.dest.y);
+		const b = px(o.dest.x + o.dest.w, o.dest.y + o.dest.h);
+		blitter.blit(o.blend && o.blend.alpha < 255 ? fadedDib(part, o.blend.alpha / 255) : part, {
+			x: Math.min(a.x, b.x),
+			y: Math.min(a.y, b.y),
+			width: Math.abs(b.x - a.x),
+			height: Math.abs(b.y - a.y)
+		}, o.rop);
+	};
 	const strokeOf = () => {
 		if (dc.pen.style === "none") return void 0;
-		const w = dc.pen.widthLu <= 1 ? 1 : dc.pen.widthLu * Math.abs(sx());
+		const m = dc.transform;
+		const world = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
+		const lu = dc.pen.widthLu * world;
+		const w = lu <= 1 ? 1 : lu * Math.abs(sx());
 		return {
 			colorHex: dc.pen.colorHex,
 			widthPt: w,
@@ -92,13 +127,22 @@ function readEmf(bytes) {
 		const st = stroke ? strokeOf() : void 0;
 		const fillHex = fill && !dc.brush.hollow ? dc.brush.colorHex : void 0;
 		if (fillHex === void 0 && !st) return;
-		prims.push({
+		emit({
 			kind: "path",
 			paths: [path],
 			...fillHex !== void 0 ? { fillColorHex: fillHex } : {},
 			...st ? { stroke: st } : {}
 		});
 	};
+	/** Two mapped corners → the rectangle they bound, in either order. */
+	function rectOf(a, b) {
+		return {
+			left: Math.min(a.x, b.x),
+			top: Math.min(a.y, b.y),
+			right: Math.max(a.x, b.x),
+			bottom: Math.max(a.y, b.y)
+		};
+	}
 	/** A closed rectangle, as the geometry records draw one. */
 	const rectSegments = (l, t, r, b) => {
 		const p0 = px(l, t);
@@ -151,6 +195,32 @@ function readEmf(bytes) {
 				};
 				haveView = true;
 				break;
+			case 30: {
+				const a = px(at(8), at(12));
+				const b = px(at(16), at(20));
+				dc = {
+					...dc,
+					clip: intersectClip(dc, rectOf(a, b))
+				};
+				break;
+			}
+			case 75: {
+				const cbRgnData = u(8);
+				const mode = u(12);
+				if (cbRgnData === 0 && mode === 5) {
+					const { clip: _drop, ...rest } = dc;
+					dc = rest;
+				} else if (mode === 5 && cbRgnData >= 32 && u(20) === 1) {
+					const base = off + 16 + 32;
+					const a = px(v.getInt32(base, true), v.getInt32(base + 4, true));
+					const b = px(v.getInt32(base + 8, true), v.getInt32(base + 12, true));
+					dc = {
+						...dc,
+						clip: rectOf(a, b)
+					};
+				}
+				break;
+			}
 			case 33:
 				stack.push(cloneDc(dc));
 				break;
@@ -256,7 +326,7 @@ function readEmf(bytes) {
 					dc.y = at(12);
 					const to = px(dc.x, dc.y);
 					if (building) {
-						if (building.length === 0) building.push({
+						if (!inFigure()) building.push({
 							op: "move",
 							x: from.x,
 							y: from.y
@@ -302,6 +372,11 @@ function readEmf(bytes) {
 			case 44:
 				paint(rectSegments(at(8), at(12), at(16), at(20)), true, true);
 				break;
+			case 47:
+			case 46:
+			case 45:
+				paint(arcSegments(px, at(8), at(12), at(16), at(20), at(24), at(28), at(32), at(36), type), type !== 45, true);
+				break;
 			case 3:
 			case 4:
 			case 2:
@@ -320,10 +395,13 @@ function readEmf(bytes) {
 					const segs = polySegments(px, pts, {
 						closed,
 						bezier: type === 2 || type === 5 || type === 85 || type === 88,
-						...type === 5 || type === 6 || type === 88 || type === 89 ? { from: {
-							x: dc.x,
-							y: dc.y
-						} } : {}
+						...type === 5 || type === 6 || type === 88 || type === 89 ? {
+							from: {
+								x: dc.x,
+								y: dc.y
+							},
+							joined: inFigure()
+						} : {}
 					});
 					if (pts.length > 0) {
 						dc.x = pts[pts.length - 1].x;
@@ -370,7 +448,7 @@ function readEmf(bytes) {
 					if (text.trim() !== "") {
 						const p = px(refX, refY);
 						const font = dc.font;
-						prims.push({
+						emit({
 							kind: "text",
 							text: fromSymbolFont(text, font?.family),
 							x: p.x,
@@ -388,25 +466,115 @@ function readEmf(bytes) {
 				}
 				break;
 			case 76:
-				{
-					const cbBmiSrc = u(88);
-					const rop = u(40);
-					if (cbBmiSrc === 0) {
-						const x = at(24);
-						const y = at(28);
-						const w = at(32);
-						const h = at(36);
-						const hex = rop === 66 ? "000000" : rop === 16711778 ? "FFFFFF" : void 0;
-						const brush = dc.brush;
-						if (hex !== void 0) dc.brush = {
-							kind: "brush",
-							colorHex: hex,
-							hollow: false
-						};
-						paint(rectSegments(x, y, x + w, y + h), true, false);
-						dc.brush = brush;
-					} else skipped.add("bitmap");
+			case 77: {
+				const cbBmiSrc = u(88);
+				const rop = u(40);
+				const x = at(24);
+				const y = at(28);
+				const w = at(32);
+				const h = at(36);
+				if (cbBmiSrc === 0) {
+					const hex = rop === 66 ? "000000" : rop === 16711778 ? "FFFFFF" : void 0;
+					if (hex === void 0 && rop !== 15728673) break;
+					const brush = dc.brush;
+					if (hex !== void 0) dc.brush = {
+						kind: "brush",
+						colorHex: hex,
+						hollow: false
+					};
+					paint(rectSegments(x, y, x + w, y + h), true, false);
+					dc.brush = brush;
+					break;
 				}
+				blit({
+					bmiAt: u(84),
+					cbBmi: cbBmiSrc,
+					bitsAt: u(92),
+					cbBits: u(96),
+					dest: {
+						x,
+						y,
+						w,
+						h
+					},
+					src: {
+						x: at(44),
+						y: at(48),
+						w: type === 77 ? at(100) : w,
+						h: type === 77 ? at(104) : h
+					},
+					rop
+				});
+				break;
+			}
+			case 80:
+				blit({
+					bmiAt: u(48),
+					cbBmi: u(52),
+					bitsAt: u(56),
+					cbBits: u(60),
+					dest: {
+						x: at(24),
+						y: at(28),
+						w: at(40),
+						h: at(44)
+					},
+					src: {
+						x: at(32),
+						y: at(36),
+						w: at(40),
+						h: at(44)
+					},
+					inBitmap: true,
+					rop: 13369376
+				});
+				break;
+			case 81:
+				blit({
+					bmiAt: u(48),
+					cbBmi: u(52),
+					bitsAt: u(56),
+					cbBits: u(60),
+					dest: {
+						x: at(24),
+						y: at(28),
+						w: at(72),
+						h: at(76)
+					},
+					src: {
+						x: at(32),
+						y: at(36),
+						w: at(40),
+						h: at(44)
+					},
+					inBitmap: true,
+					rop: u(68)
+				});
+				break;
+			case 114:
+				blit({
+					bmiAt: u(84),
+					cbBmi: u(88),
+					bitsAt: u(92),
+					cbBits: u(96),
+					dest: {
+						x: at(24),
+						y: at(28),
+						w: at(32),
+						h: at(36)
+					},
+					src: {
+						x: at(44),
+						y: at(48),
+						w: at(100),
+						h: at(104)
+					},
+					blend: {
+						alpha: u(40) >>> 16 & 255,
+						perPixel: u(40) >>> 24 === 1
+					},
+					rop: 13369376
+				});
 				break;
 			default:
 				{
@@ -557,12 +725,14 @@ function polySegments(map, pts, o) {
 	if (pts.length === 0) return segs;
 	let i = 0;
 	if (o.from) {
-		const s = map(o.from.x, o.from.y);
-		segs.push({
-			op: "move",
-			x: s.x,
-			y: s.y
-		});
+		if (o.joined !== true) {
+			const s = map(o.from.x, o.from.y);
+			segs.push({
+				op: "move",
+				x: s.x,
+				y: s.y
+			});
+		}
 	} else {
 		const s = map(pts[0].x, pts[0].y);
 		segs.push({
@@ -598,6 +768,78 @@ function polySegments(map, pts, o) {
 	return segs;
 }
 var KAPPA = .5522847498307936;
+/**
+* §2.3.5.2/.4/.13 — the wedge, chord or bare curve an `EMR_ARC`, `EMR_CHORD` or
+* `EMR_PIE` draws.
+*
+* All three state the same thing: an ellipse inscribed in a box, and two points
+* naming RAYS from its centre. The arc runs from where the first ray crosses
+* the ellipse to where the second does, anticlockwise on the page — GDI's
+* default direction — and the two records differ only in how they close: a pie
+* back through the centre, a chord straight across, an arc not at all.
+*
+* Built in the metafile's own coordinates and mapped point by point, exactly as
+* the ellipse and the polygons are: the mapping is affine, so a Bézier's
+* control points survive it.
+*
+* @param map        The metafile's logical → page mapping.
+* @param l,t,r,b    The box the ellipse is inscribed in.
+* @param sx,sy      The point naming the ray the arc starts at.
+* @param ex,ey      The point naming the ray it ends at.
+* @param type       The record type, which decides how the figure closes.
+* @returns The path segments, in page coordinates.
+*/
+function arcSegments(map, l, t, r, b, sx, sy, ex, ey, type) {
+	const cx = (l + r) / 2;
+	const cy = (t + b) / 2;
+	const rx = (r - l) / 2;
+	const ry = (b - t) / 2;
+	if (!(rx > 0) || !(ry > 0)) return [];
+	const angleOf = (x, y) => Math.atan2((y - cy) / ry, (x - cx) / rx);
+	const start = angleOf(sx, sy);
+	let sweep = angleOf(ex, ey) - start;
+	if (sweep >= 0) sweep -= 2 * Math.PI;
+	const point = (a) => map(cx + rx * Math.cos(a), cy + ry * Math.sin(a));
+	const segs = [];
+	const from = point(start);
+	if (type === 47) {
+		const c = map(cx, cy);
+		segs.push({
+			op: "move",
+			x: c.x,
+			y: c.y
+		}, {
+			op: "line",
+			x: from.x,
+			y: from.y
+		});
+	} else segs.push({
+		op: "move",
+		x: from.x,
+		y: from.y
+	});
+	const steps = Math.max(1, Math.ceil(Math.abs(sweep) / (Math.PI / 2)));
+	const delta = sweep / steps;
+	const alpha = 4 / 3 * Math.tan(delta / 4);
+	for (let i = 0; i < steps; i++) {
+		const a0 = start + delta * i;
+		const a1 = a0 + delta;
+		const t0 = map(cx + rx * Math.cos(a0) - alpha * rx * Math.sin(a0), cy + ry * Math.sin(a0) + alpha * ry * Math.cos(a0));
+		const t1 = map(cx + rx * Math.cos(a1) + alpha * rx * Math.sin(a1), cy + ry * Math.sin(a1) - alpha * ry * Math.cos(a1));
+		const to = point(a1);
+		segs.push({
+			op: "cubic",
+			x1: t0.x,
+			y1: t0.y,
+			x2: t1.x,
+			y2: t1.y,
+			x: to.x,
+			y: to.y
+		});
+	}
+	if (type !== 45) segs.push({ op: "close" });
+	return segs;
+}
 function ellipseSegments(map, l, t, r, b) {
 	const cx = (l + r) / 2;
 	const cy = (t + b) / 2;

package/dist/esm/core/metafile/picture.d.ts

@@ -74,7 +74,18 @@ export interface MetaFont {
     readonly italic?: boolean;
     readonly escapement?: number;
 }
-export type MetaObject = MetaPen | MetaBrush | MetaFont;
+/**
+ * An object the reader does not model — a palette, a region, a pattern brush.
+ * It still OCCUPIES a slot in the metafile's object table: handles are indices
+ * into that table, so a creation the reader passed over silently shifted every
+ * one that followed. 23884's chart selects its coloured pens by handle, and one
+ * unrecorded palette put every selection one slot back — on the black pen the
+ * pens had displaced.
+ */
+export interface MetaOther {
+    readonly kind: 'other';
+}
+export type MetaObject = MetaPen | MetaBrush | MetaFont | MetaOther;
 /** The device context: everything a record draws THROUGH. */
 export interface DeviceContext {
     pen: MetaPen;
@@ -91,12 +102,61 @@ export interface DeviceContext {
     y: number;
     /** The world→page transform, as `[a, b, c, d, e, f]`. */
     transform: readonly [number, number, number, number, number, number];
+    /**
+     * MS-EMF §2.3.2 / MS-WMF §2.3.2 — the region drawing is limited to, in
+     * logical units, when the metafile states a RECTANGULAR one. A primitive
+     * that falls wholly outside it is not drawn: an embedded workbook's preview
+     * clips its sheet to the used range, and unclipped we painted the whole
+     * empty grid around it.
+     */
+    clip?: {
+        readonly left: number;
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+    };
 }
 export declare const DEFAULT_PEN: MetaPen;
 export declare const DEFAULT_BRUSH: MetaBrush;
 /** A device context in its documented initial state (MS-WMF §3.1.5). */
 export declare function newDeviceContext(): DeviceContext;
 export declare function cloneDc(dc: DeviceContext): DeviceContext;
+/**
+ * Whether a primitive bounded by `box` is wholly outside the device context's
+ * clip. Partial overlaps are kept whole — the reader discards what the clip
+ * excludes rather than cutting geometry, which is a missing cut, never wrong
+ * content.
+ *
+ * @param dc  The device context, for its clip.
+ * @param box The primitive's bounds in logical units.
+ * @returns `true` when nothing of it would be drawn.
+ */
+export declare function clippedAway(dc: DeviceContext, box: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}): boolean;
+/** The intersection of a device context's clip with another rectangle. */
+export declare function intersectClip(dc: DeviceContext, rect: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}): NonNullable<DeviceContext['clip']>;
+/**
+ * A primitive's bounds in the units it is stored in, for the clip test.
+ *
+ * @param prim The primitive.
+ * @returns Its bounding rectangle; a text run's is its reference point, since
+ *          the box it fills is not known until it is measured.
+ */
+export declare function primBounds(prim: PicturePrim): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
 /** A COLORREF (`0x00bbggrr`) as the 6-hex this codebase's colours use. */
 export declare function colorRef(v: number): string;
 /** Apply the world transform to a point. */

package/dist/esm/core/metafile/picture.js

@@ -36,6 +36,75 @@ function newDeviceContext() {
 function cloneDc(dc) {
 	return { ...dc };
 }
+/**
+* Whether a primitive bounded by `box` is wholly outside the device context's
+* clip. Partial overlaps are kept whole — the reader discards what the clip
+* excludes rather than cutting geometry, which is a missing cut, never wrong
+* content.
+*
+* @param dc  The device context, for its clip.
+* @param box The primitive's bounds in logical units.
+* @returns `true` when nothing of it would be drawn.
+*/
+function clippedAway(dc, box) {
+	const c = dc.clip;
+	if (!c) return false;
+	return box.right < c.left || box.left > c.right || box.bottom < c.top || box.top > c.bottom;
+}
+/** The intersection of a device context's clip with another rectangle. */
+function intersectClip(dc, rect) {
+	const c = dc.clip;
+	if (!c) return rect;
+	return {
+		left: Math.max(c.left, rect.left),
+		top: Math.max(c.top, rect.top),
+		right: Math.min(c.right, rect.right),
+		bottom: Math.min(c.bottom, rect.bottom)
+	};
+}
+/**
+* A primitive's bounds in the units it is stored in, for the clip test.
+*
+* @param prim The primitive.
+* @returns Its bounding rectangle; a text run's is its reference point, since
+*          the box it fills is not known until it is measured.
+*/
+function primBounds(prim) {
+	if (prim.kind === "text") return {
+		left: prim.x,
+		top: prim.y,
+		right: prim.x,
+		bottom: prim.y
+	};
+	if (prim.kind === "image") return {
+		left: prim.x,
+		top: prim.y,
+		right: prim.x + prim.width,
+		bottom: prim.y + prim.height
+	};
+	let left = Infinity;
+	let top = Infinity;
+	let right = -Infinity;
+	let bottom = -Infinity;
+	for (const path of prim.paths) for (const sg of path.segments) {
+		if (!("x" in sg)) continue;
+		left = Math.min(left, sg.x);
+		right = Math.max(right, sg.x);
+		top = Math.min(top, sg.y);
+		bottom = Math.max(bottom, sg.y);
+	}
+	return Number.isFinite(left) ? {
+		left,
+		top,
+		right,
+		bottom
+	} : {
+		left: 0,
+		top: 0,
+		right: 0,
+		bottom: 0
+	};
+}
 /** A COLORREF (`0x00bbggrr`) as the 6-hex this codebase's colours use. */
 function colorRef(v) {
 	return [
@@ -52,4 +121,4 @@ function applyTransform(t, x, y) {
 	};
 }
 //#endregion
-export { applyTransform, cloneDc, colorRef, newDeviceContext };
+export { applyTransform, clippedAway, cloneDc, colorRef, intersectClip, newDeviceContext, primBounds };