summaryrefslogtreecommitdiff
path: root/web/host.js
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 09:06:20 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commit303478956e0086467a9073d7f6fa67b51b6580ad (patch)
tree6c69e13eef575b514433373893e1f14c435b4f1a /web/host.js
parentc94455e1a8d2a430d8dcd74603bcd0d7b27aeb68 (diff)
downloadsketchbook-303478956e0086467a9073d7f6fa67b51b6580ad.tar.gz
sketchbook-303478956e0086467a9073d7f6fa67b51b6580ad.zip
text: sk.text measures anywhere, Frame.paragraph wraps, aligns, spans, reveals and finds a caret
The ABI's one text entry is textRun (Host.VTable.textSize goes): a run in a face at a scale, as data, its advance and line box and each byte's x, a pure function of the font, the scale and the bytes, never of the display; and font, a face for a sketch's own TTF/OTF bytes (abi.Face is non-exhaustive: faces past the ten are a sketch's). The native host serves them from vendor/text.c (sk_text_run, sk_text_font), the web host from canvas measureText and FontFace (web/host.js), and the web draws each run in the page's monospace or sans-serif in the face's weight and style instead of 8 px a character. src/sketch/text.zig (sk.text) does the rest in plain Zig, the same on every host: size, layout and font anywhere, update included (the glue sets the host before each call into the sketch; a test binary has none and calls sketchbook-text directly, which App.addTest now links); a Paragraph is a face, scale and colour, a width to wrap at spaces, an alignment, spans (from a byte on: a colour, a face, a scale), reveal (the first N glyphs drawn, the layout the whole text's) and a caret byte, and its Layout the size, lines, glyphs and the caret's place. f.paragraph draws one, a Command.text a piece. f.text, f.textIn and f.print are a paragraph with no width when the bytes hold a \n, else the one command they were; host.textSize and textSizeIn stay, one line through textRun. Test: sk.text's own tests (a wrap, the space not counted, centred and right, a caret at a line's start and end and after a \n, a span twice the size, a word wider than the width, an empty text; reveal drawing the first glyphs of the same layout), run through sketchbook-text; and test/text.zig draws a centred paragraph with a red and a double-size span and a caret from its Layout, which test/text.script pins. zig build test-text runs these and the atlas's comparison with pardes's raster. Every other pinned pixel of test/text.script holds: the lines it pins are the same pixels Pango drew. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'web/host.js')
-rw-r--r--web/host.js53
1 files changed, 47 insertions, 6 deletions
diff --git a/web/host.js b/web/host.js
index 32bdbfb..8213dbd 100644
--- a/web/host.js
+++ b/web/host.js
@@ -519,8 +519,49 @@ function drawImage(id, x, y, w, h, sx, sy, sw, sh, r, g, b, a, place) {
ctx.restore();
}
+// Text (docs/text.md): sketchbook's faces in the page's fonts, in their
+// weight and style, and a sketch's own font a FontFace (`fonts`, its bytes
+// kept to give the same face for the same bytes). 13 px at scale 1.
+const faceFonts = [['', 'monospace'], ['bold', 'monospace'], ['italic', 'monospace'], ['', 'sans-serif'], ['500', 'sans-serif'], ['bold', 'sans-serif'], ['', 'monospace'], ['bold', 'monospace'], ['italic', 'monospace'], ['500', 'monospace']];
+const fonts = [];
+const fontOf = (face, scale) => {
+ const [style, family] = face < 10 ? faceFonts[face] : ['', fonts[face - 10]?.family ?? 'monospace'];
+ return `${style} ${13 * scale}px ${family}`.trim();
+};
+const measurer = document.createElement('canvas').getContext('2d');
+
const imports = {
host: {
+ // A run's width, ascent and line height, and each byte's x (a byte inside
+ // a codepoint at its codepoint's): the prefixes measured, so drawn is
+ // measured, kerning included.
+ textRun(face, scale, ptr, len, xsPtr, xsLen, outPtr) {
+ measurer.font = fontOf(face, scale);
+ const all = bytes(ptr, len).slice();
+ const m = measurer.measureText(decoder.decode(all));
+ new Float32Array(wasm.memory.buffer, outPtr, 3).set([m.width, m.fontBoundingBoxAscent, m.fontBoundingBoxAscent + m.fontBoundingBoxDescent]);
+ if (!xsLen) return;
+ const xs = new Float32Array(wasm.memory.buffer, xsPtr, xsLen);
+ let x = 0;
+ for (let i = 0; i < len; i++) {
+ if ((all[i] & 0xc0) !== 0x80) x = i ? measurer.measureText(decoder.decode(all.subarray(0, i))).width : 0;
+ xs[i] = x;
+ }
+ },
+ font(ptr, len) {
+ const data = bytes(ptr, len).slice();
+ const known = fonts.findIndex(f => f.data.length === data.length && f.data.every((b, i) => b === data[i]));
+ if (known >= 0) return 10 + known;
+ if (fonts.length === 54) return -1;
+ const family = `sketchbook-font-${fonts.length}`;
+ try {
+ const face = new FontFace(family, data);
+ document.fonts.add(face);
+ face.load().catch(err => console.warn(`font ${family}: ${err}`));
+ } catch { return -1; }
+ fonts.push({family, data});
+ return 10 + fonts.length - 1;
+ },
log(ptr, len) { console.log(string(ptr, len)); },
loadImage(ptr, len) {
const path = string(ptr, len);
@@ -615,15 +656,15 @@ const imports = {
if (open) ctx.fill('nonzero');
},
// Always blended alpha, as native text is.
- text(x, y, scale, ptr, len, r, g, b, a) {
+ // A run from its line box's top left, in the face textRun measures it in.
+ text(x, y, scale, face, ptr, len, r, g, b, a) {
ctx.save();
ctx.globalCompositeOperation = 'source-over';
ctx.fillStyle = rgba(r, g, b, a);
- // The native font is a fixed 8px cell: the same advance, and a size
- // whose capitals fill the cell as native ones do.
- ctx.font = `${10 * scale}px monospace`;
- ctx.textBaseline = 'top';
- for (const [i, ch] of Array.from(string(ptr, len)).entries()) ctx.fillText(ch, x + i * 8 * scale, y);
+ ctx.font = fontOf(face, scale);
+ ctx.textBaseline = 'alphabetic';
+ const s = string(ptr, len);
+ ctx.fillText(s, x, y + ctx.measureText(s).fontBoundingBoxAscent);
ctx.restore();
},
clip(enabled, x, y, w, h) {