@reekon-tools/boldr-cad 1.4.0 → 1.6.0

package/src/tools/modify.ts

@@ -1,20 +1,23 @@
-import { afterEdit, holdFaces, solveOrRevert, tryAddConstraint, undo } from '../app/edit';
-import { ed } from '../app/state';
-import { splitFaces } from '../model/faces';
-import { clamp, hyp, lineCircleT, norm2, projT, segInter } from '../model/geom';
+import { afterEdit, holdFaces, solveSketch, tryAddConstraint, undo } from '../app/edit';
+import { ed, type Preview } from '../app/state';
+import { faceKey, splitFaces } from '../model/faces';
+import { clamp, hyp, norm2, projT } from '../model/geom';
 import { dropHistory, pushHistory } from '../model/history';
 import { uid } from '../model/ids';
 import { findFace, maybeRoom, roomGeom } from '../model/rooms';
-import { addLine, addPoint } from '../model/sketch';
-import { SK } from '../model/store';
-import type { Constraint, Sketch } from '../model/types';
+import { addCons, addLine, addPoint } from '../model/sketch';
+import { replaceSK, SK } from '../model/store';
+import { distTo, nearestOn, pieceAt, pieceKey, pieceShape, trimItemAt, type Cut, type TrimItem, type TrimKind, type TrimPiece } from '../model/trim';
+import type { Constraint, Sketch, XY } from '../model/types';
 import { hitAny } from '../render/hit';
 import { outsideSide } from '../model/planGeom';
-import { mainT, requestDraw, s2w } from '../render/view';
+import { TH } from '../render/theme';
+import { mainT, requestDraw, requestOverlayDraw, S, s2w } from '../render/view';
 import { placeTargets, snapSlide } from '../editor/elevation';
 import { fmtArea, fmtLen } from '../units';
 import type { PEv } from './registry';
 import { openKeypad, toast } from '../editor/ports';
+import { noScaleYet, waitForScale } from '../editor/scaleGate';
 
 /** Hover helper: highlight only geometry of the given types. */
 const hoverOnly = (types: string[]) => (ev: PEv) => {
@@ -23,82 +26,216 @@ const hoverOnly = (types: string[]) => (ev: PEv) => {
   requestDraw();
 };
 
+/*
+  Trim (T; the rail, after Arc — on a phone, under Draw to shape): tap a piece of a line, wall, arc or circle and it
+  goes, cut back to where something crosses it or meets it on either side (model/trim.ts); drag across several and
+  each one the stroke crosses goes when it lifts. What's about to go is shown in red. One undo step a tap or a stroke.
+*/
+
+/** A piece a tap or a stroke took: where on what it's of (in the drawing), and the piece then. */
+interface TrimMark { at: XY; pc: TrimPiece; key: string }
+
+/** How near (inches) a point is to count as on what's trimmed, and cuts to count as one: a couple of pixels. */
+const cutTol = (): number => Math.min(0.5, 2 / mainT().s);
+
+/** The piece under screen point (sx, sy). */
+function trimMarkAt(sx: number, sy: number, touch: boolean): TrimMark | null {
+  const [x, y] = s2w(sx, sy), sk = SK();
+  const it = trimItemAt(sk, { x, y }, (touch ? 20 : 10) / mainT().s);
+  if (!it) return null;
+  // (where on it: found again there as it's cut, on it or on a piece an earlier cut split off)
+  const at = nearestOn(sk, it, { x, y }), pc = pieceAt(sk, it, at, cutTol());
+  return { at, pc, key: pieceKey(pc) };
+}
+
+/** What's about to be cut away, drawn over the drawing in red. */
+const trimPreview = (pcs: TrimPiece[]): Preview => (c, T) => {
+  const sk = SK();
+  c.save();
+  c.strokeStyle = TH.red; c.lineWidth = 4; c.lineCap = 'round'; c.globalAlpha = 0.85;
+  for (const pc of pcs) {
+    const g = pieceShape(sk, pc);
+    if (!g) continue;
+    c.beginPath();
+    if ('a' in g) { const [x1, y1] = S(T, g.a.x, g.a.y), [x2, y2] = S(T, g.b.x, g.b.y); c.moveTo(x1, y1); c.lineTo(x2, y2); }
+    else { const [x, y] = S(T, g.o.x, g.o.y); c.arc(x, y, g.r * T.s, -g.t0, -g.t1, true); }
+    c.stroke();
+  }
+  c.restore();
+};
+
+const freshTrim = () => ({ down: null as XY | null, last: null as XY | null, stroke: false, marks: [] as TrimMark[] });
+
 export const trimTool = {
-  reset() { ed.hover = null; },
-  hover: hoverOnly(['line', 'circle']),
-  down(ev: PEv) { this.hover(ev); },
-  move(ev: PEv) { this.hover(ev); },
+  st: freshTrim(),
+  reset() { this.st = freshTrim(); ed.hover = null; ed.preview = null; requestOverlayDraw(); },
+  show(marks: TrimMark[]) { ed.preview = marks.length ? trimPreview(marks.map(m => m.pc)) : null; requestOverlayDraw(); },
+  hover(ev: PEv) { const m = trimMarkAt(ev.sx, ev.sy, ev.touch); this.show(m ? [m] : []); },
+  down(ev: PEv) {
+    const m = trimMarkAt(ev.sx, ev.sy, ev.touch);
+    this.st = { down: { x: ev.sx, y: ev.sy }, last: { x: ev.sx, y: ev.sy }, stroke: false, marks: m ? [m] : [] };
+    this.show(this.st.marks);
+  },
+  move(ev: PEv) {
+    const st = this.st;
+    if (!st.down) { this.hover(ev); return; }
+    if (!st.stroke && hyp(ev.sx - st.down.x, ev.sy - st.down.y) < 12) return;
+    st.stroke = true;
+    // every few pixels of the way since the last move, so a quick stroke doesn't skip a short piece
+    const from = st.last!, n = Math.max(1, Math.ceil(hyp(ev.sx - from.x, ev.sy - from.y) / 6));
+    for (let i = 1; i <= n; i++) {
+      const m = trimMarkAt(from.x + ((ev.sx - from.x) * i) / n, from.y + ((ev.sy - from.y) * i) / n, ev.touch);
+      if (m && !st.marks.some(k => k.key === m.key)) st.marks.push(m);
+    }
+    st.last = { x: ev.sx, y: ev.sy };
+    this.show(st.marks);
+  },
   up(ev: PEv) {
-    const h = hitAny(ev.sx, ev.sy, { touch: ev.touch, only: 'geom' });
-    if (!h) return;
-    const [wx, wy] = s2w(ev.sx, ev.sy);
-    if (h.type === 'line') trimLine(h.id, wx, wy);
-    else if (h.type === 'circle') { pushHistory(); delete SK().circles[h.id]; afterEdit(); }
+    const st = this.st, tap = trimMarkAt(ev.sx, ev.sy, ev.touch);
+    const marks = st.stroke ? st.marks : tap ? [tap] : [];
+    this.reset();
+    if (marks.length) trimMarks(marks);
   },
-  hint() { return 'Tap the part of a line to remove. It cuts back to the nearest crossing and keeps the rest constrained.'; },
+  hint() { return 'Tap the piece to cut away, or drag across several. Each cuts back to where something crosses or meets it.'; },
 };
 
-/** Cut a line back to the nearest crossings around (wx, wy). Unlike SolveSpace, constraints carry over. */
-export function trimLine(lid: string, wx: number, wy: number): void {
-  const sk = SK(), l = sk.lines[lid];
-  const A = { ...sk.points[l.a] }, B = { ...sk.points[l.b] };
-  const tc = projT(A, B, { x: wx, y: wy });
-  const ts: { t: number; line?: string; circle?: string }[] = [];
-  for (const id in sk.lines) {
-    if (id === lid) continue;
-    const o = sk.lines[id];
-    const r = segInter(A, B, sk.points[o.a], sk.points[o.b]);
-    if (r && r.t > 1e-6 && r.t < 1 - 1e-6) ts.push({ t: r.t, line: id });
-  }
-  for (const id in sk.circles) { const ci = sk.circles[id]; for (const t of lineCircleT(A, B, sk.points[ci.c], ci.r)) ts.push({ t, circle: id }); }
+/**
+ * Cut away a tap's or a stroke's pieces, as one undo step. Each is found again as it's cut — on what it was of, or on a
+ * piece an earlier cut split off — so cutting one doesn't upset the next. If the drawing can't solve after, it's put
+ * back as it was and says so.
+ */
+export function trimMarks(marks: TrimMark[]): void {
+  const sk = SK(), was = JSON.stringify(sk), tol = cutTol(), near = 3 * tol;
   pushHistory();
-  if (!ts.length) { delete sk.lines[lid]; afterEdit(); toast('Line removed — nothing crossed it.'); return; }
-  ts.sort((a, b) => a.t - b.t);
-  let lo: (typeof ts)[number] | null = null, hi: (typeof ts)[number] | null = null;
-  for (const r of ts) { if (r.t < tc) lo = r; else if (!hi) hi = r; }
-  const mk = (r: (typeof ts)[number]) => {
-    const id = addPoint(sk, A.x + (B.x - A.x) * r.t, A.y + (B.y - A.y) * r.t);
-    if (r.line) tryAddConstraint({ type: 'online', p: id, l: r.line }, { silent: true });
-    if (r.circle) tryAddConstraint({ type: 'oncircle', p: id, c: r.circle }, { silent: true });
+  const made: TrimItem[] = [];
+  let cut = 0, whole: TrimKind | null = null;
+  for (const m of marks) {
+    const it = [m.pc.item, ...made].find(c => distTo(sk, c, m.at) <= near);
+    if (!it) continue;
+    const pc = pieceAt(sk, it, m.at, tol);
+    if (!pc.lo && !pc.hi) whole = it.kind;
+    made.push(...trimPiece(sk, pc));
+    cut++;
+  }
+  if (!cut) { dropHistory(); return; }
+  if (!solveSketch().ok) {
+    replaceSK(JSON.parse(was) as Sketch);
+    dropHistory();
+    afterEdit();
+    toast('Can’t trim that — it conflicts with other constraints.', { warn: true });
+    return;
+  }
+  afterEdit();
+  // (a tap that took a whole thing: nothing crossed it, so there was nothing to cut back to)
+  if (marks.length === 1 && whole) toast((whole === 'line' ? 'Line' : whole === 'arc' ? 'Arc' : 'Circle') + ' removed — ' + (whole === 'circle' ? 'it takes two crossings to cut a piece out.' : 'nothing crossed it.'));
+}
+
+/**
+ * Cut piece `pc` away. A line or wall is shortened from an end, or split in two around a middle piece that goes (the
+ * two kept in line); an arc the same (the two one circle still); a circle opens into an arc round the rest; with no cut
+ * either side, the whole thing goes. Where a cut is a point already there, the new end is that point, so what meets
+ * there stays joined; a crossing makes a new point, held on what it crosses. Constraints carry over (product rule 9):
+ * a length, a midpoint or Equal on a cut line no longer say what they did and go. Edits the sketch only: the caller
+ * pushes history, solves and runs afterEdit. Returns what it made (a split's second piece).
+ */
+export function trimPiece(sk: Sketch, pc: TrimPiece): TrimItem[] {
+  const { item, lo, hi } = pc, made: TrimItem[] = [];
+  /** A cut's point: the one there, or a new one, held on what crosses there. */
+  const at = (c: Cut): string => {
+    if (c.pt) return c.pt;
+    const id = addPoint(sk, c.x, c.y);
+    if (c.line) addCons(sk, { type: 'online', p: id, l: c.line });
+    if (c.curve) addCons(sk, { type: 'oncircle', p: id, c: c.curve });
     return id;
   };
-  const oldA = l.a, oldB = l.b, L = hyp(B.x - A.x, B.y - A.y);
-  const isHV = (c: Constraint) => (c.type === 'h' || c.type === 'v') && ((c.a === oldA && c.b === oldB) || (c.a === oldB && c.b === oldA));
-  const retarget = (na: string, nb: string) => {
+  if (item.kind === 'line') trimLinePiece(sk, item.id, lo, hi, at, made);
+  else if (item.kind === 'arc') {
+    const a = sk.arcs[item.id];
+    if (!lo && !hi) delete sk.arcs[item.id];
+    else if (!lo) a.a = at(hi!);
+    else if (!hi) a.b = at(lo);
+    else {
+      const p1 = at(lo), p2 = at(hi), oldB = a.b, nid = uid('ar');
+      a.b = p1;
+      sk.arcs[nid] = { ...a, a: p2, b: oldB };
+      // one circle still; a tangent at its old end goes with the piece that ends there now
+      addCons(sk, { type: 'eqr', c1: item.id, c2: nid });
+      for (const c of Object.values(sk.cons)) if (c.type === 'tan' && c.c === item.id) { const l = sk.lines[c.l!]; if (l && (l.a === oldB || l.b === oldB)) c.c = nid; }
+      made.push({ kind: 'arc', id: nid });
+    }
+  } else {
+    const ci = sk.circles[item.id];
+    if (!lo || !hi) delete sk.circles[item.id];
+    else {
+      // what's left runs from the cut after the piece round to the one before: an arc, with the circle's id, so what
+      // refers to it (its size, a tangent, Concentric) refers to the arc
+      const { c, constr, kind, thick } = ci, a = at(hi), b = at(lo);
+      delete sk.circles[item.id];
+      sk.arcs[item.id] = { c, a, b, ...(constr ? { constr } : {}), ...(kind ? { kind } : {}), ...(thick ? { thick } : {}) };
+    }
+  }
+  // a point held on a line or an arc that's that line's or arc's end now: an end is on it already
+  const ids = new Set([item.id, ...made.map(m => m.id)]);
+  for (const id in sk.cons) {
+    const c = sk.cons[id], l = c.l ? sk.lines[c.l] : undefined, a = c.c ? sk.arcs[c.c] : undefined;
+    if (c.type === 'online' && !c.face && l && ids.has(c.l!) && (l.a === c.p || l.b === c.p)) delete sk.cons[id];
+    else if (c.type === 'oncircle' && a && ids.has(c.c!) && (a.a === c.p || a.b === c.p)) delete sk.cons[id];
+  }
+  return made;
+}
+
+function trimLinePiece(sk: Sketch, lid: string, lo: Cut | null, hi: Cut | null, at: (c: Cut) => string, made: TrimItem[]): void {
+  const l = sk.lines[lid];
+  if (!lo && !hi) { delete sk.lines[lid]; return; }
+  const A = sk.points[l.a], B = sk.points[l.b], L = hyp(B.x - A.x, B.y - A.y), oldA = l.a, oldB = l.b;
+  // its length, its middle, Equal to another: they no longer say what they did
+  for (const id in sk.cons) {
+    const c = sk.cons[id];
+    if ((c.type === 'dist' && c.line === lid) || (c.type === 'mid' && c.l === lid) || (c.type === 'eq' && (c.l1 === lid || c.l2 === lid))) delete sk.cons[id];
+  }
+  if (lo && hi) {
+    // a middle piece: split at both cuts (splitLineAt carries constraints, spaces, doors and windows, and what's on its
+    // faces) and the piece between goes; the two left stay in line
+    const p1 = at(lo), p2 = at(hi), mid = splitLineAt(sk, lid, p1), rest = mid && splitLineAt(sk, mid, p2);
+    if (!mid || !rest) return;
+    delete sk.lines[mid];
     for (const id in sk.cons) {
       const c = sk.cons[id];
-      if (isHV(c)) { c.a = na; c.b = nb; }
-      if (c.type === 'dist' && c.line === lid) delete sk.cons[id];
-      if (c.type === 'mid' && c.l === lid) delete sk.cons[id];
+      const across = (c.type === 'h' || c.type === 'v') && ((c.a === p1 && c.b === p2) || (c.a === p2 && c.b === p1));
+      if (across || (c.type === 'online' && c.p === p2 && c.l === lid)) delete sk.cons[id];
     }
-  };
+    addCons(sk, { type: 'col', l1: lid, l2: rest });
+    made.push({ kind: 'line', id: rest });
+    return;
+  }
+  const hv = (c: Constraint) => (c.type === 'h' || c.type === 'v') && ((c.a === oldA && c.b === oldB) || (c.a === oldB && c.b === oldA));
   if (!lo) {
-    const p = mk(hi!);
+    // from its start: it starts at the cut now, and what's measured from its start is measured from there
+    const p = at(hi!), s = hi!.at * L;
     l.a = p;
-    retarget(p, oldB);
-    for (const id in sk.openings) { const o = sk.openings[id]; if (o.line === lid) o.at -= hi!.t * L; }
-  } else if (!hi) {
-    const p = mk(lo);
-    l.b = p;
-    retarget(oldA, p);
+    for (const c of Object.values(sk.cons)) if (hv(c)) { c.a = p; c.b = oldB; }
+    for (const id in sk.openings) { const o = sk.openings[id]; if (o.line !== lid) continue; if (o.at < s) delete sk.openings[id]; else o.at -= s; }
+    shiftWallFace(sk, lid, -1, -s);
+    for (const side of [1, -1]) for (const e of sk.elev?.[lid + '|' + side] ?? []) { e.a[0] -= s; e.b[0] -= s; }
   } else {
-    const p1 = mk(lo), p2 = mk(hi);
-    l.b = p1;
-    const nid = addLine(sk, p2, oldB, { kind: l.kind, constr: l.constr, thick: l.thick });
-    const copies: Constraint[] = [];
-    for (const id in sk.cons) {
-      const c = sk.cons[id];
-      if ((c.type === 'par' || c.type === 'perp' || c.type === 'col') && (c.l1 === lid || c.l2 === lid)) copies.push(Object.assign({}, c, c.l1 === lid ? { l1: nid } : { l2: nid }));
-      if (isHV(c)) copies.push({ type: c.type, a: p2, b: oldB });
-    }
-    retarget(oldA, p1);
-    for (const c of copies) tryAddConstraint(c, { silent: true });
-    tryAddConstraint({ type: 'online', p: p2, l: lid }, { silent: true });
-    tryAddConstraint({ type: 'par', l1: lid, l2: nid }, { silent: true });
-    for (const id in sk.openings) { const o = sk.openings[id]; if (o.line === lid && o.at > hi.t * L) { o.line = nid; o.at -= hi.t * L; } }
+    // to its end: it ends at the cut now
+    const p = at(lo), s = lo.at * L;
+    l.b = p;
+    for (const c of Object.values(sk.cons)) if (hv(c)) { c.a = oldA; c.b = p; }
+    for (const id in sk.openings) { const o = sk.openings[id]; if (o.line === lid && o.at > s) delete sk.openings[id]; }
+    shiftWallFace(sk, lid, 1, s - L);
   }
-  solveOrRevert();
-  afterEdit();
+}
+
+/**
+ * What's drawn on one face of wall `lid`, moved across it by dx: the face's x runs from the wall's start seen from side
+ * −1, and from its end seen from side 1 (see splitFaces), so a trim moving that end moves it.
+ */
+function shiftWallFace(sk: Sketch, lid: string, side: 1 | -1, dx: number): void {
+  const face = sk.faces?.[faceKey(lid, side)];
+  if (!face || !dx) return;
+  delete face.wall; // (its corners are recounted at its next placing)
+  for (const p of Object.values(face.points)) if (!p.anchor) p.x += dx;
 }
 
 export const offsetTool = {
@@ -118,6 +255,8 @@ export const offsetTool = {
 };
 
 export function offsetPrompt(lid: string, side: number): void {
+  // (a distance typed is real: nothing drawn says what it is in a sketch without its scale yet — editor/scaleGate.ts)
+  if (waitForScale()) return;
   ed.sel = [{ type: 'line', id: lid }];
   requestDraw();
   openKeypad({ title: 'Offset distance', sub: 'Copies the line, kept parallel', initial: '', onDone: v => { if (!v) return; offsetLine(lid, v * side); } });
@@ -185,7 +324,8 @@ export const roomTool = {
     if (!id) { dropHistory(); toast('That area is too small for a space.', { warn: true }); return; }
     ed.sel = [];
     afterEdit();
-    toast(sk.rooms[id].name + ' — ' + fmtArea(roomGeom(sk, sk.rooms[id]).area));
+    // (its area once the drawing has its scale: before, only a placeholder)
+    toast(sk.rooms[id].name + (noScaleYet() ? '' : ' — ' + fmtArea(roomGeom(sk, sk.rooms[id]).area)));
   },
   hint() { return 'Tap inside a closed shape to make a space. Area is measured to the inside face of walls.'; },
 };

package/src/tools/registry.ts

@@ -1,6 +1,7 @@
 import { tryAddConstraint } from '../app/edit';
 import { ed, type Snap } from '../app/state';
 import { hyp } from '../model/geom';
+import { edgeOf } from '../model/planGeom';
 import { settings } from '../model/settings';
 import { addPoint, WALL_THICK } from '../model/sketch';
 import { SK } from '../model/store';
@@ -10,6 +11,7 @@ import { requestDraw, S, type Xform } from '../render/view';
 import { fmtLen } from '../units';
 import { onSessionReset } from '../model/session';
 import { updateCtx, updateHint, updateRail } from '../editor/ports';
+import { noScaleYet, toolWaitsForScale, waitForScale } from '../editor/scaleGate';
 import type { KeyIn } from '../editor/keys';
 import type { DrawCtx } from '../render/ctx';
 import { TH } from '../render/theme';
@@ -36,6 +38,11 @@ export interface Tool {
   hint?(): string;
   /** something half-done that Esc should cancel first (a line in progress, a picked first point…) */
   busy?(): boolean;
+  /**
+   * whether a finger or pencil pressed and moving is placing or dragging something, for a device's magnifier
+   * (render/lens.ts). Unset: whenever one is (a drawing tool places at it all the time).
+   */
+  magnify?(): boolean;
 }
 
 export const tools: Record<string, Tool> = {};
@@ -53,6 +60,8 @@ export function cancelTool(): void {
 }
 
 export function setTool(t: string): void {
+  // (doors, windows, cabinets and offsets have real sizes: they wait for the page's first length — editor/scaleGate.ts)
+  if (toolWaitsForScale(t) && waitForScale()) return;
   if (t === ed.tool && t !== 'select' && t !== 'aselect') { cancelTool(); updateCtx(); updateHint(); return; }
   cancelTool();
   ed.tool = t;
@@ -73,9 +82,16 @@ export function commitPoint(s: Snap): { id: string; cons: Constraint[] } {
   else if (s.kind === 'online') cons.push({ type: 'online', p: id, l: s.ref! });
   else if (s.kind === 'oncircle') cons.push({ type: 'oncircle', p: id, c: s.ref! });
   else if (s.kind === 'inter' && s.refs) cons.push({ type: 'online', p: id, l: s.refs[0] }, { type: 'online', p: id, l: s.refs[1] });
+  else cons.push(...faceSnapCons(s, id));
   return { id, cons };
 }
 
+/** A snap onto a wall's face, or where two faces meet: point `p` on that face (on each), not on the wall's centreline. */
+export function faceSnapCons(s: Snap, p: string): Constraint[] {
+  const edges = s.kind === 'onface' && s.ref ? [s.ref] : s.kind === 'facecorner' && s.refs ? s.refs : [];
+  return edges.map(e => { const [l, face] = edgeOf(e); return { type: 'online', p, l, face }; });
+}
+
 export function applyPending(list: Constraint[]): void {
   if (!settings.autoCons) return;
   for (const c of list) tryAddConstraint(c, { silent: true });
@@ -88,7 +104,8 @@ export function rememberHover(s: Snap | null): void {
 export function lengthPreview(c: DrawCtx, T: Xform, a: XY, b: XY, col?: string): void {
   const [x1, y1] = S(T, a.x, a.y), [x2, y2] = S(T, b.x, b.y);
   const L = hyp(b.x - a.x, b.y - a.y);
-  if (L * T.s < 6) return;
+  // (not on a page without its scale: the length is only a placeholder)
+  if (L * T.s < 6 || noScaleYet()) return;
   chip(c, fmtLen(L), (x1 + x2) / 2, (y1 + y2) / 2 - 16, { bg: '#fff', fg: '#0066FF', border: [col || '#0066FF', 1.5] });
 }