@reekon-tools/boldr-cad 1.6.0 → 1.7.0

package/src/react/host.ts

@@ -1,4 +1,4 @@
-import { applyReading, laser } from '../editor/laser';
+import { applyReading, laser, readingOverwrites } from '../editor/laser';
 import { store } from '../model/store';
 import { closeSurveyRun, setSurveyCursor, takeSurveyPoint } from '../tools/survey';
 import { notify } from './store';
@@ -33,6 +33,16 @@ export function laserReading(inches: number, capture?: unknown): boolean {
   return true;
 }
 
+/**
+ * Whether a reading of `inches`, passed to laserReading now, would replace a length or diameter already measured on
+ * the selected line, wall edge or curve (see readingOverwrites), for a host that warns first: hold the reading, ask,
+ * and pass it on only once the person agrees. Nothing changes by asking. False when no drawing is open to take it.
+ */
+export function laserReadingOverwrites(inches: number): boolean {
+  if (!editorHost.open || !store.project || !Number.isFinite(inches) || inches <= 0) return false;
+  return readingOverwrites(inches);
+}
+
 /**
  * A point measured by a templating device (BOLDR's T1R), in inches, on the plan's axes: x to the right, y UP. Turning
  * the device's own frame into that is the host's job, and it's where the handedness goes: a device whose angle turns

package/src/react/ports.ts

@@ -59,8 +59,8 @@ function hostRequest(spec: KeypadSpec): HostKeypadRequest {
   };
 }
 
-/** A slider above the bar (an image's opacity or rotation, the tiles' size): opened, swapped for another, or closed by its button again. */
-function toggleImagePop(kind: 'opacity' | 'rotate' | 'tilesize'): void {
+/** A slider above the bar (an image's opacity or rotation, the tiles' or measurement tiles' size): opened, swapped for another, or closed by its button again. */
+function toggleImagePop(kind: 'opacity' | 'rotate' | 'tilesize' | 'dimsize'): void {
   ui.imgPop = ui.imgPop === kind ? null : kind;
   ui.menu = false;
   // (a toast would sit over the slider: it's done with once the slider opens)
@@ -153,6 +153,7 @@ export const reactPorts: EditorPorts = {
   toggleImageOpacity() { toggleImagePop('opacity'); },
   toggleImageRotation() { toggleImagePop('rotate'); },
   toggleTileSize() { toggleImagePop('tilesize'); },
+  toggleDimSize() { toggleImagePop('dimsize'); },
   editRoomName(roomId) { ui.drawer = 'rooms'; ui.renameRoom = roomId; notify(); },
   setCursor(cursor, where = 'plan') { cursorTargets[where]?.(cursor); },
   interacting: setInteracting,

package/src/react/store.ts

@@ -59,7 +59,7 @@ export const ui = sessionState(() => ({
    * what's open above the bar: the selected image's opacity or turn, or the link tiles' size (sliders), or Open's
    * question (here, or side by side)
    */
-  imgPop: null as null | 'opacity' | 'rotate' | 'tilesize' | 'open',
+  imgPop: null as null | 'opacity' | 'rotate' | 'tilesize' | 'dimsize' | 'open',
   /** the tool each shared place on the rail draws with (the last picked; editor/mode.ts TOOL_GROUPS), and the menu of
       a group's tools, open beside its place at x, y */
   picked: { shapes: 'line', marks: 'arrow' } as Record<string, string>,

package/src/render/draw.ts

@@ -41,7 +41,8 @@ export function rr(c: C2D, x: number, y: number, w: number, h: number, r: number
 }
 
 export interface ChipOpts {
-  bg: string; fg: string; border?: [string, number?] | null; font?: string; pad?: number; h?: number; minW?: number;
+  /** `r`: its corners' radius (5) */
+  bg: string; fg: string; border?: [string, number?] | null; font?: string; pad?: number; h?: number; minW?: number; r?: number;
   kind?: HitChip['kind']; id?: string; rot?: number;
   /**
    * 'link': a measurement of the job sets it. The chip is then Figma's linked measurement (2795:77149): a white badge
@@ -80,13 +81,22 @@ export function chipSize(c: C2D, text: string, { font = '600 12px', pad = 7, h =
   return { w: Math.max(minW, c.measureText(text).width + room), h };
 }
 
+/**
+ * A measurement tile's size — a dimension's chip: its font, padding, height and corners — times the file's measurement
+ * tile size (settings.chipPct, editor/dimSize.ts). At 100%, chip()'s own: 12 px, 7, 22, 5.
+ */
+export function dimChip(): Pick<ChipOpts, 'font' | 'pad' | 'h' | 'r'> {
+  const k = settings.chipPct / 100;
+  return k === 1 ? {} : { font: '600 ' + 12 * k + 'px', pad: 7 * k, h: 22 * k, r: 5 * k };
+}
+
 /** Rounded label on the canvas; registers a hit region when `kind` is given. */
 export function chip(c: C2D, text: string, cx: number, cy: number, opts: ChipOpts): number {
   const { bg, fg, border, kind, id, rot = 0, mark } = opts;
   const { w, h } = chipSize(c, text, opts), x = cx - w / 2, y = cy - h / 2;
   c.save();
   if (rot) { c.translate(cx, cy); c.rotate(rot); c.translate(-cx, -cy); }
-  rr(c, x, y, w, h, 5);
+  rr(c, x, y, w, h, opts.r ?? 5);
   c.fillStyle = bg; c.fill();
   if (border) { c.lineWidth = border[1] || 1; c.strokeStyle = border[0]; c.stroke(); }
   c.fillStyle = fg; c.textAlign = 'center'; c.textBaseline = 'middle';
@@ -627,7 +637,7 @@ function drawDims(c: C2D, T: Xform, sk: Sketch): void {
         }
         c.restore();
       }
-      const text = wrap(fmtAng(val)), opts: ChipOpts = { bg, fg, border, kind: 'dim', id, mark };
+      const text = wrap(fmtAng(val)), opts: ChipOpts = { bg, fg, border, kind: 'dim', id, mark, ...dimChip() };
       // (left where it was drawn: 50 px out along the bisector, or as far as its corners stay clear of the corner — a
       // linked chip is wider)
       const sz = chipSize(c, text, opts), out = Math.max(50, Math.hypot(sz.w, sz.h) / 2 + 28);
@@ -636,7 +646,7 @@ function drawDims(c: C2D, T: Xform, sk: Sketch): void {
       continue;
     }
     if (d.type === 'diam' && 'o' in A) {
-      drawDiameter(c, T, A.o, A.r, d, d.rad ? 'R ' + wrap(fmtLen(val / 2)) : 'Ø ' + wrap(fmtLen(val)), bad ? TH.red : ref ? TH.chipline : TH.blue, { bg, fg, border, kind: 'dim', id, mark }, ref);
+      drawDiameter(c, T, A.o, A.r, d, d.rad ? 'R ' + wrap(fmtLen(val / 2)) : 'Ø ' + wrap(fmtLen(val)), bad ? TH.red : ref ? TH.chipline : TH.blue, { bg, fg, border, kind: 'dim', id, mark, ...dimChip() }, ref);
       continue;
     }
     if (!('a' in A)) continue;
@@ -650,7 +660,7 @@ function drawDims(c: C2D, T: Xform, sk: Sketch): void {
       c.save(); if (ref) c.setLineDash([3, 3]); c.strokeStyle = bad ? TH.red : ref ? TH.chipline : TH.blue; c.lineWidth = 1.2;
       c.beginPath(); c.moveTo(ax, ay); c.lineTo(bx, by); c.stroke(); c.restore();
     }
-    chip(c, wrap(fmtLen(val)), mx, my, { bg, fg, border, kind: 'dim', id, mark });
+    chip(c, wrap(fmtLen(val)), mx, my, { bg, fg, border, kind: 'dim', id, mark, ...dimChip() });
   }
 }
 
@@ -664,14 +674,15 @@ function drawDims(c: C2D, T: Xform, sk: Sketch): void {
  */
 function drawOpeningDims(c: C2D, T: Xform, sk: Sketch): void {
   if (!settings.layers.dims || ed.mode !== 'draft') return;
-  const ROW = 26 / T.s;
+  // (the rows, and how far apart along them, grow with the measurement tiles: editor/dimSize.ts)
+  const k = settings.chipPct / 100, ROW = (26 * k) / T.s;
   for (const id in sk.openings) {
     const o = sk.openings[id], g = openingFrame(sk, id);
     if (!g) continue;
     const l = sk.lines[o.line], L = hyp(sk.points[l.b].x - g.A.x, sk.points[l.b].y - g.A.y);
     const side = outsideSide(sk, o.line);
     // automatic rows start 34 px past the wall face (clear of the H/V badges); a dragged dimension keeps its own offset
-    const k0 = g.t / 2 + 34 / T.s;
+    const k0 = g.t / 2 + (34 + 11 * (k - 1)) / T.s;
     const kRow = (row: number) => side * (k0 + row * ROW);
     /** screen point at `s` along the wall, `k` (signed, world) off its centerline */
     const P = (s: number, k: number) => S(T, g.A.x + g.ux * s + g.nx * k, g.A.y + g.uy * s + g.ny * k);
@@ -699,14 +710,14 @@ function drawOpeningDims(c: C2D, T: Xform, sk: Sketch): void {
     };
     const label = (s0: number, s1: number, part: string, text: string, k: number, bg: string = TH.blue, fg = '#fff', border: [string, number] | null = null) => {
       const [mx, my] = P((s0 + s1) / 2, k);
-      chip(c, text, mx, my, { bg, fg, border: odimSel(part) ? [TH.yellow, 2] : border, kind: 'odim', id });
+      chip(c, text, mx, my, { bg, fg, border: odimSel(part) ? [TH.yellow, 2] : border, kind: 'odim', id, ...dimChip() });
       if (hits && hits.length) hits[hits.length - 1].part = part;
     };
     // automatic placement packs dimensions into rows so they don't overlap each other or the width chip;
     // spans that only touch end to end share a row (a chained string)
     const rows: [number, number][][] = [o.wOff == null ? [[g.s0, g.s1]] : []];
     const place = (a: number, b: number) => {
-      const lo = Math.min(a, b), hi = Math.max(a, b), gap = 64 / T.s;
+      const lo = Math.min(a, b), hi = Math.max(a, b), gap = (64 * k) / T.s;
       const clash = ([x, y]: [number, number]) => (lo < y - 1e-6 && hi > x + 1e-6) || Math.abs((lo + hi) / 2 - (x + y) / 2) < gap;
       for (let r = 0; ; r++) {
         rows[r] = rows[r] || [];

package/src/render/navigate.ts

@@ -59,46 +59,57 @@ export interface UiView extends NavView { seq: number }
 /** What the drawing on screen was drawn at: its view, the latest of the fingers' views it includes, the screen size. */
 export interface DrawnAt { view: NavView; seq: number; W: number; H: number }
 
-/** The fingers on the screen and what they're doing: navigating or not, where they were last, whether a pen has been seen. */
-export interface NavState { fingers: Record<number, { x: number; y: number }>; navigating: boolean; last: Pinch | null; pen: boolean }
+/**
+ * The pointers on the screen and what they're doing: the fingers that count (a finger a Pencil landed on doesn't — see
+ * navTouch), navigating or not, where they were last, and any Pencil down.
+ */
+export interface NavState { fingers: Record<number, { x: number; y: number }>; navigating: boolean; last: Pinch | null; pens: number[] }
 
 export const NAV_DOWN = 0, NAV_MOVE = 1, NAV_UP = 2, NAV_CANCEL = 3;
 
 /**
  * One touch event, as the UI thread sees it: the fingers after it, and the view (moved if `moved`). Fingers navigate —
- * pan, and zoom about their middle — once two are down, or any one once a pen has been seen or when the drawing is
- * view only (editor/gestures.ts decides the same on its side), until the last one lifts. A pen or a mouse never
- * navigates. `type` is NAV_DOWN… ; `allIds`, every pointer still down (on a down event: a finger that went without
- * a word, a lost touch-up, is dropped so it can't hold a gesture open).
+ * pan, and zoom about their middle — once two are down, or a finger lands while a Pencil is down or when the drawing is
+ * view only (editor/gestures.ts decides the same on its side), until the last one lifts. A finger already down and not
+ * navigating when a Pencil lands is set aside until it lifts. A pen or a mouse never navigates. `type` is NAV_DOWN… ;
+ * `kind` is the event's pointer, for a touch that doesn't say what it is itself; `allIds`, every pointer still down (on
+ * a down event: a finger that went without a word, a lost touch-up, is dropped so it can't hold a gesture open).
  */
 export function navTouch(
-  st: NavState, type: number, kind: string, changed: { id: number; x: number; y: number }[], allIds: number[] | null,
+  st: NavState, type: number, kind: string, changed: { id: number; x: number; y: number; kind?: string }[], allIds: number[] | null,
   readOnly: boolean, view: UiView, drawn: DrawnAt | null,
 ): { st: NavState; view: UiView; moved: boolean } {
   'worklet';
-  const pen = st.pen || kind === 'pen';
-  if (kind !== 'touch') return { st: { ...st, pen }, view, moved: false };
+  const lost = (id: number) => type === NAV_DOWN && !!allIds && !allIds.includes(id);
   const fingers: Record<number, { x: number; y: number }> = {};
-  for (const k in st.fingers) {
-    const id = Number(k);
-    if (type !== NAV_DOWN || !allIds || allIds.includes(id)) fingers[id] = st.fingers[id];
-  }
+  for (const k in st.fingers) if (!lost(Number(k))) fingers[Number(k)] = st.fingers[Number(k)];
+  let pens = st.pens.filter(id => !lost(id)), landed = false, moved = false;
   for (const t of changed) {
-    if (type === NAV_UP || type === NAV_CANCEL) delete fingers[t.id];
-    else fingers[t.id] = { x: t.x, y: t.y };
+    const k = t.kind ?? kind;
+    if (type === NAV_UP || type === NAV_CANCEL) {
+      delete fingers[t.id];
+      pens = pens.filter(id => id !== t.id);
+    } else if (type === NAV_DOWN && k === 'pen') {
+      if (!pens.includes(t.id)) pens = [...pens, t.id];
+      // (fingers down and not navigating are let go of: their moves and lifts are no finger's from here)
+      if (!st.navigating) for (const f in fingers) delete fingers[f];
+    } else if (type === NAV_DOWN ? k === 'touch' : t.id in fingers) {
+      fingers[t.id] = { x: t.x, y: t.y };
+      if (type === NAV_DOWN) landed = true; else moved = true;
+    }
   }
   const pts = Object.keys(fingers).map(k => fingers[Number(k)]);
-  if (!pts.length) return { st: { fingers, navigating: false, last: null, pen }, view, moved: false };
+  if (!pts.length) return { st: { fingers, navigating: false, last: null, pens }, view, moved: false };
   let navigating = st.navigating, v = view;
   if (!navigating) {
-    if (pts.length < 2 && !(type === NAV_DOWN && (pen || readOnly))) return { st: { fingers, navigating: false, last: null, pen }, view, moved: false };
+    if (pts.length < 2 && !(landed && (pens.length > 0 || readOnly))) return { st: { fingers, navigating: false, last: null, pens }, view, moved: false };
     navigating = true;
     // start from the view the drawing on screen was drawn at, unless the fingers' own is newer
     if (drawn && v.seq <= drawn.seq) v = { s: drawn.view.s, cx: drawn.view.cx, cy: drawn.view.cy, seq: drawn.seq };
   }
-  const now = pinchOf(pts), was = st.last, next = { fingers, navigating, last: now, pen };
-  // a finger came or went: carry on from here, no jump
-  if (type !== NAV_MOVE || !now || !was || was.n !== now.n || !drawn) return { st: next, view: v, moved: false };
+  const now = pinchOf(pts), was = st.last, next = { fingers, navigating, last: now, pens };
+  // a finger came or went: carry on from here, no jump (and a Pencil's move alone moves no view)
+  if (type !== NAV_MOVE || !moved || !now || !was || was.n !== now.n || !drawn) return { st: next, view: v, moved: false };
   const to = navStep(v, was, now, drawn.W, drawn.H);
   return { st: next, view: { s: to.s, cx: to.cx, cy: to.cy, seq: v.seq + 1 }, moved: true };
 }

package/src/tools/dim.ts

@@ -23,6 +23,7 @@ import { fmtAng, fmtLen } from '../units';
 import { addOpeningDim } from './openings';
 import type { PEv } from './registry';
 import { keypadFresh, keypadOpen, keypadSetReading } from '../editor/keypad';
+import { advanceAfterReading } from '../editor/advance';
 import { cornerLines } from '../editor/selection';
 import { closeKeypad, kpTyped, openKeypad, showConflict, toast, updateCtx, updateHint, type KeypadSpec } from '../editor/ports';
 import { noScaleYet, pendingLabel, startingValue } from '../editor/scaleGate';
@@ -177,7 +178,11 @@ export function dimLine(lid: string, side?: 1 | -1): void {
       onPress: () => { face = ch.face!; spec.sub = lengthSub(sk, lid, face); show(); if (keypadFresh() && !noScaleYet()) keypadSetReading(len()); },
     })) : undefined,
     onClose: () => { ed.sel = was; updateCtx(); requestDraw(); },
-    onDone: (v, capture) => { if (v > 0) addLength(v, capture !== undefined ? { capture } : {}); },
+    onDone: (v, capture) => {
+      if (!(v > 0)) return;
+      // a laser reading's (it comes with its record) moves on to the next line clockwise; a typed one stays
+      if (addLength(v, capture !== undefined ? { capture } : {}) && capture !== undefined) advanceAfterReading(lid, side);
+    },
     // (or a length of the job's, from its list: the line takes it, linked to it)
     measurements: offersJobMeasurements() ? {
       kind: 'length', pick: t => {
@@ -188,21 +193,32 @@ export function dimLine(lid: string, side?: 1 | -1): void {
       },
     } : undefined,
   };
-  /** The line's length dimension, driving, measured where the keypad says (`extra`: what it's from). */
-  function addLength(v: number, extra: Partial<Constraint>): void {
+  /** The line's length dimension, driving, measured where the keypad says (`extra`: what it's from). Whether it took. */
+  function addLength(v: number, extra: Partial<Constraint>): boolean {
     pushHistory();
     const r = tryAddConstraint({ type: 'dist', a: l.a, b: l.b, kind: 'al', value: v, line: lid, driving: true, off: face ? (face * 30) / V().s : 0, ...(face ? { face } : {}), ...extra });
     // a measurement of the job drives a line, or nothing: not one whose length the drawing already sets
+    let took = r.ok;
     if (r.ok && r.ref && extra.measurementRef) {
       delete SK().cons[r.id!];
       dropHistory();
       toast(LENGTH_SET_ALREADY, { warn: true });
+      took = false;
     } else if (!r.ok) dropHistory();
     afterEdit();
+    return took;
   }
   openKeypad(spec);
 }
 
+/**
+ * Whether giving dimension `c` the value `v` replaces a value measured there: a driving one, entered (not a default
+ * nobody measured), changed by it. Not one linked to a measurement of the job: that's asked about anyway
+ * (askLinkedChange). What a host warns about before a reading overwrites (laserReadingOverwrites).
+ */
+export const replacesMeasured = (c: Constraint | undefined, v: number): boolean =>
+  !!c && c.driving !== false && !c.auto && !c.measurementRef && changesValue(c, v);
+
 /** Why a measurement of the job can't drive a line the drawing already sets the length of. */
 export const LENGTH_SET_ALREADY = 'The drawing already sets that line’s length. Free it first (make one of its dimensions a reference), then pick the measurement.';
 /** Why a measurement of the job can't drive an angle the drawing already sets. */
@@ -587,7 +603,15 @@ export function editDim(id: string, done?: () => void, modeless = false, pick?:
       label: ch.label!, on: onChoice(withFace(c, face), ch),
       onPress: () => { face = onChoice(c, ch) ? null : { ...ch, l2: face?.l2 ?? ch.l2 }; if (keypadFresh()) keypadSetReading(now()); },
     })),
-    onDone: (v, capture) => { setDimValue(id, v * k, face ?? undefined, { capture }); done?.(); },
+    onDone: (v, capture) => {
+      const took = setDimValue(id, v * k, face ?? undefined, { capture });
+      done?.();
+      // a laser reading's (it comes with its record) on a line's length or a curve's diameter moves on to the next
+      // line clockwise; a typed one, or one the drawing refused or asked about, stays
+      const of = c.type === 'dist' ? c.line : c.type === 'diam' ? c.c : undefined;
+      if (took && capture !== undefined && of) advanceAfterReading(of, pick?.face || undefined);
+    },
+    overwrites: v => replacesMeasured(SK().cons[id], v * k),
     // a line's length or an angle: or one of the job's, from its list — the dimension takes it, linked to it (a
     // dimension already linked to another, re-linked)
     measurements: ((c.type === 'dist' && c.line) || isAng) && offersJobMeasurements() ? {

package/src/ui/domPorts.ts

@@ -67,6 +67,8 @@ export const domPorts: EditorPorts = {
   toggleImageRotation: anchor => toggleRotation(anchor as HTMLElement | undefined),
   // (this interface has no link tiles: no host links)
   toggleTileSize: () => {},
+  // (the harness's page has no slider for it: its hosts' editor does)
+  toggleDimSize: () => {},
   editRoomName,
   setCursor: cursor => { cvs.cv.style.cursor = cursor; },
   // (this page's chrome stays put while a gesture moves)