@reekon-tools/boldr-cad 0.1.0 → 1.1.0

package/src/tools/elevation.ts

@@ -3,7 +3,7 @@ import { openingHeights, wallHeight } from '../model/elevation';
 import { pushHistory } from '../model/history';
 import { uid } from '../model/ids';
 import { driveCheck, edgeS, openingSpan, refS, rerootLock, sameRef } from '../model/openings';
-import { SK } from '../model/store';
+import { planSK as SK } from '../model/store';
 import type { Opening, OpeningDim, OpeningEdge, OpeningRef } from '../model/types';
 import { fmtLen } from '../units';
 import { editPlacedOpeningDim, fits, overDefined } from './openings';
@@ -25,7 +25,7 @@ export function editSill(opId: string): void {
   if (!l) return;
   const { sill, head } = openingHeights(o), h = head - sill, H = wallHeight(l);
   openKeypad({
-    title: Name(o) + ' sill height', sub: 'Floor to the bottom of the ' + nameOf(o) + ' — locks its height above the floor', initial: fmtLen(sill), selectAll: true, laser: true,
+    title: Name(o) + ' sill height', sub: 'Floor to the bottom of the ' + nameOf(o) + ' — locks its height above the floor', initial: fmtLen(sill), value: sill, selectAll: true, laser: true,
     onDone: v => {
       if (v < 0) return;
       if (v + h > H + 1e-6) {
@@ -46,7 +46,7 @@ export function editOpeningHeight(opId: string): void {
   if (!l) return;
   const { sill, head } = openingHeights(o), H = wallHeight(l);
   openKeypad({
-    title: Name(o) + ' height', sub: 'Bottom to top of the ' + nameOf(o), initial: fmtLen(head - sill), selectAll: true, laser: true,
+    title: Name(o) + ' height', sub: 'Bottom to top of the ' + nameOf(o), initial: fmtLen(head - sill), value: head - sill, selectAll: true, laser: true,
     onDone: v => {
       if (v <= 0) return;
       if (sill + v > H + 1e-6) {
@@ -67,7 +67,7 @@ export function editWallHeight(lid: string): void {
   if (!l) return;
   const tallest = Math.max(0, ...Object.values(sk.openings).filter(o => o.line === lid).map(o => openingHeights(o).head));
   openKeypad({
-    title: 'Wall height', sub: 'Floor to ceiling, this wall only', initial: fmtLen(wallHeight(l)), selectAll: true, laser: true,
+    title: 'Wall height', sub: 'Floor to ceiling, this wall only', initial: fmtLen(wallHeight(l)), value: wallHeight(l), selectAll: true, laser: true,
     onDone: v => {
       if (v <= 0) return;
       if (v < tallest - 1e-6) { toast('A door or window here reaches ' + fmtLen(tallest) + '. Enter ' + fmtLen(tallest) + ' or more, or lower it first.', { warn: true }); return; }
@@ -96,7 +96,7 @@ export function editElevationPosition(opId: string, edge: OpeningEdge, ref: Open
   const d: OpeningDim = { id: uid('od'), edge, ref, value: cur, sign: e >= r ? 1 : -1, driving: true };
   openKeypad({
     title, sub: 'Locks the ' + nameOf(o) + '’s position',
-    initial: fmtLen(cur), selectAll: true, laser: true,
+    initial: fmtLen(cur), value: cur, selectAll: true, laser: true,
     onDone: v => {
       if (v < 0) return;
       if (!fits(o, d, v)) return;

package/src/tools/fillet.ts

@@ -0,0 +1,82 @@
+import { afterEdit, tryAddConstraint } from '../app/edit';
+import { ed } from '../app/state';
+import { dropHistory, pushHistory } from '../model/history';
+import { uid } from '../model/ids';
+import { addPoint } from '../model/sketch';
+import { replaceSK, SK } from '../model/store';
+import type { Sketch } from '../model/types';
+import { requestDraw } from '../render/view';
+import { solver } from '../solver';
+import { fmtLen } from '../units';
+import { openKeypad, toast, updateCtx } from '../editor/ports';
+import { cornerAt, cutCorner } from './corner';
+
+/*
+  Fillet: round off a corner where two lines (or walls) meet. The corner becomes an arc tangent to both, the lines
+  stop where it starts (tools/corner.ts), and a driving radius holds it. Two walls get a curved wall of the same
+  thickness, and a space around the corner follows the curve.
+*/
+
+/** The corner's two lines, if it can be rounded off. */
+export function filletable(sk: Sketch, pid: string): [string, string] | null {
+  const k = cornerAt(sk, pid);
+  return k ? [k.l1, k.l2] : null;
+}
+
+/** The biggest radius that fits the corner (the arc would reach the end of the shorter line). */
+export function maxFillet(sk: Sketch, pid: string): number {
+  const k = cornerAt(sk, pid);
+  return k ? Math.min(k.len1, k.len2) * Math.tan(k.th / 2) : 0;
+}
+
+/** The Fillet action: the keypad for the radius, then the corner is rounded off. */
+export function filletPrompt(pid: string): void {
+  const sk = SK();
+  if (!cornerAt(sk, pid)) { toast('Select a corner where two lines meet to round it off.', { warn: true }); return; }
+  const most = maxFillet(sk, pid), start = Math.min(6, most * 0.5);
+  openKeypad({
+    title: 'Fillet radius', sub: 'Up to ' + fmtLen(most) + ' fits this corner', initial: fmtLen(Math.round(start * 16) / 16), value: Math.round(start * 16) / 16, selectAll: true, laser: true,
+    onDone: r => { filletCorner(pid, r); },
+  });
+}
+
+/** Round off corner `pid` with an arc of radius `r`. Returns the arc's id, or null (and says why) if it can't. */
+export function filletCorner(pid: string, r: number): string | null {
+  const sk = SK(), k = cornerAt(sk, pid);
+  if (!k) { toast('Select a corner where two lines meet to round it off.', { warn: true }); return null; }
+  if (!(r > 0)) return null;
+  const d = r / Math.tan(k.th / 2);
+  if (d >= k.len1 - 1e-6 || d >= k.len2 - 1e-6) {
+    toast('That radius doesn’t fit this corner: ' + fmtLen(maxFillet(sk, pid)) + ' at most.', { warn: true });
+    return null;
+  }
+  pushHistory();
+  const before = JSON.stringify(sk), L1 = sk.lines[k.l1], L2 = sk.lines[k.l2], P = { ...k.P };
+  // the centre on the bisector, the radius away from both lines
+  const bx = k.u1.x + k.u2.x, by = k.u1.y + k.u2.y, bl = Math.hypot(bx, by) || 1, far = r / Math.sin(k.th / 2);
+  const c = addPoint(sk, P.x + (bx / bl) * far, P.y + (by / bl) * far), wall = L1.kind === 'wall' && L2.kind === 'wall';
+  const cut = cutCorner(sk, k, d, d, (t1, t2) => {
+    const id = uid('ar'), C = sk.points[c], A = sk.points[t1], B = sk.points[t2];
+    // counter-clockwise from its start to its end: the short way round, from one line to the other
+    const ccw = (A.x - C.x) * (B.y - C.y) - (A.y - C.y) * (B.x - C.x) > 0;
+    sk.arcs[id] = { c, a: ccw ? t1 : t2, b: ccw ? t2 : t1, constr: L1.constr && L2.constr, ...(wall ? { kind: 'wall' as const, thick: L1.thick } : {}) };
+    return id;
+  });
+  // tangent to both lines (on the side the centre is), and the radius
+  const side = (lid: string) => { const l = sk.lines[lid], A = sk.points[l.a], B = sk.points[l.b], o = sk.points[c]; return (B.x - A.x) * (o.y - A.y) - (B.y - A.y) * (o.x - A.x) < 0 ? -1 : 1; };
+  for (const cn of [...cut.cons, { type: 'tan' as const, l: k.l1, c: cut.edge, sign: side(k.l1) }, { type: 'tan' as const, l: k.l2, c: cut.edge, sign: side(k.l2) }]) tryAddConstraint(cn, { silent: true });
+  // its radius, the leader out through the middle of the arc (toward the old corner)
+  tryAddConstraint({ type: 'diam', c: cut.edge, value: 2 * r, driving: true, rad: true, ang: Math.atan2(P.y - sk.points[c].y, P.x - sk.points[c].x) }, { silent: true });
+  if (!solver.solve(sk).ok) {
+    replaceSK(JSON.parse(before) as Sketch);
+    dropHistory();
+    toast('That corner can’t be rounded off with the constraints it has.', { warn: true });
+    afterEdit();
+    return null;
+  }
+  ed.sel = [{ type: 'arc', id: cut.edge }];
+  afterEdit();
+  updateCtx(); requestDraw();
+  toast('Corner rounded off: ' + fmtLen(r) + ' radius');
+  return cut.edge;
+}

package/src/tools/freehand.ts

@@ -1,6 +1,6 @@
 import { afterEdit, tryAddConstraint } from '../app/edit';
 import { ed } from '../app/state';
-import type { PEv } from './registry';
+import { wallBand, type PEv } from './registry';
 import { hyp } from '../model/geom';
 import { dropHistory, pushHistory } from '../model/history';
 import { maybeRoom } from '../model/rooms';
@@ -8,10 +8,12 @@ import { settings } from '../model/settings';
 import { addLine, addPoint } from '../model/sketch';
 import { deg, JOIN_PX, simplifyStroke, SQUARE_DEG, squareUp, turn } from '../model/stroke';
 import { SK } from '../model/store';
-import type { Constraint, XY } from '../model/types';
+import type { Constraint, LineKind, XY } from '../model/types';
 import { TH } from '../render/theme';
-import { mainT, requestDraw, S, s2w } from '../render/view';
+import { mainT, requestDraw, requestOverlayDraw, S, s2w } from '../render/view';
 import { toast } from '../editor/ports';
+import { intoWall } from '../editor/elevation';
+import { drawsWalls } from '../editor/mode';
 
 /*
   Draw to shape: sketch freehand, and on release the stroke becomes the line segments it most likely meant —
@@ -25,7 +27,7 @@ import { toast } from '../editor/ports';
  * Turn a stroke (world points) into lines in the current sketch, as one edit the caller wraps in history.
  * Returns the new line ids, or null if the stroke was too small to mean anything.
  */
-export function strokeToLines(stroke: XY[], opts: { constr?: boolean } = {}): { lines: string[]; closed: boolean } | null {
+export function strokeToLines(stroke: XY[], opts: { constr?: boolean; kind?: LineKind } = {}): { lines: string[]; closed: boolean } | null {
   const sk = SK(), T = mainT(), simp = simplifyStroke(stroke, T.s);
   if (!simp) return null;
   const closed = simp.closed, pts = squareUp(simp.pts, closed);
@@ -37,7 +39,7 @@ export function strokeToLines(stroke: XY[], opts: { constr?: boolean } = {}): {
   };
   const ids = pts.map((p, i) => (!closed && (i === 0 || i === pts.length - 1) && near(p)) || addPoint(sk, p.x, p.y));
   const segs = closed ? ids.length : ids.length - 1, lines: string[] = [];
-  for (let i = 0; i < segs; i++) lines.push(addLine(sk, ids[i], ids[(i + 1) % ids.length], { constr: !!opts.constr }));
+  for (let i = 0; i < segs; i++) lines.push(addLine(sk, ids[i], ids[(i + 1) % ids.length], { kind: opts.kind, constr: !!opts.constr }));
   if (settings.autoCons) {
     // level / plumb segments, then square corners that aren't already square by H + V
     const axis: ('h' | 'v' | null)[] = [];
@@ -65,7 +67,7 @@ export const freehandTool = {
   busy() { return !!this.st; },
   hover() {},
   down(ev: PEv) {
-    const [x, y] = s2w(ev.sx, ev.sy);
+    const [x, y] = intoWall(...s2w(ev.sx, ev.sy)); // (in the wall view, inside the wall)
     this.st = { pts: [{ x, y }], last: [ev.sx, ev.sy] };
     this.prev();
   },
@@ -73,32 +75,34 @@ export const freehandTool = {
     if (!this.st) return;
     if (hyp(ev.sx - this.st.last[0], ev.sy - this.st.last[1]) < 2) return;
     this.st.last = [ev.sx, ev.sy];
-    const [x, y] = s2w(ev.sx, ev.sy);
+    const [x, y] = intoWall(...s2w(ev.sx, ev.sy));
     this.st.pts.push({ x, y });
     this.prev();
   },
   prev() {
     const pts = this.st!.pts;
     ed.preview = (c, T) => {
-      c.save(); c.strokeStyle = ed.drawConstr ? TH.constr : TH.ink; c.lineWidth = 2.5; c.lineCap = 'round'; c.lineJoin = 'round';
-      if (ed.drawConstr) c.setLineDash([6, 5]);
-      c.beginPath();
-      pts.forEach((p, i) => { const [x, y] = S(T, p.x, p.y); i ? c.lineTo(x, y) : c.moveTo(x, y); });
+      const wall = drawsWalls(), trace = () => pts.forEach((p, i) => { const [x, y] = S(T, p.x, p.y); i ? c.lineTo(x, y) : c.moveTo(x, y); });
+      if (wall) wallBand(c, T, trace);
+      c.save(); c.strokeStyle = ed.drawConstr && !wall ? TH.constr : TH.ink; c.lineWidth = 2.5; c.lineCap = 'round'; c.lineJoin = 'round';
+      if (ed.drawConstr && !wall) c.setLineDash([6, 5]);
+      c.beginPath(); trace();
       c.stroke(); c.restore();
     };
-    requestDraw();
+    requestOverlayDraw();
   },
   up() {
     if (!this.st) return;
     const pts = this.st.pts;
     this.reset();
     pushHistory();
-    const r = strokeToLines(pts, { constr: ed.drawConstr });
+    // (walls with the Walls toggle on; a wall is never a guide)
+    const wall = drawsWalls(), r = strokeToLines(pts, wall ? { kind: 'wall' } : { constr: ed.drawConstr });
     if (!r) { dropHistory(); requestDraw(); return; }
-    ed.sel = r.lines.map(id => ({ type: 'line' as const, id }));
+    ed.sel = [];
     afterEdit();
-    const n = r.lines.length;
-    toast((r.closed ? 'Closed shape, ' : '') + n + ' line' + (n > 1 ? 's' : '') + '. Drag points or add constraints to adjust — select a line and tap + for its length.');
+    const n = r.lines.length, what = wall ? 'wall' : 'line';
+    toast((r.closed ? 'Closed shape, ' : '') + n + ' ' + what + (n > 1 ? 's' : '') + '. Drag points or add constraints to adjust — select a ' + what + ' and tap + for its length.');
   },
   hint() { return 'Draw freehand. When you lift, it becomes straight lines — then adjust with constraints and lengths.'; },
 };

package/src/tools/index.ts

@@ -1,4 +1,7 @@
-import { makeAselectTool, withHandles, arrowTool, calibTool, cloudTool, penTool, textTool } from './annotate';
+import {
+  makeAselectTool, withHandles, arrowTool, calibTool, cloudTool, markCircleTool, markLineTool, markRectTool, markTriangleTool,
+  penTool, textTool,
+} from './annotate';
 import { dimTool } from './dim';
 import { freehandTool } from './freehand';
 import { makeLineTool, type LineTool } from './line';
@@ -7,6 +10,7 @@ import { ed } from '../app/state';
 import { tools } from './registry';
 import { selectTool } from './select';
 import { arcTool, circleTool, rectTool } from './shapes';
+import { cabinetTool, heightTool, wallDoorTool, wallWindowTool } from '../editor/elevation';
 
 export { tools, setTool, cancelTool } from './registry';
 export type { LineTool } from './line';
@@ -15,9 +19,8 @@ export type { LineTool } from './line';
 export function registerTools(): void {
   Object.assign(tools, {
     select: selectTool,
-    line: makeLineTool('line'),
+    line: makeLineTool(),
     freehand: freehandTool,
-    wall: makeLineTool('wall'),
     rect: rectTool,
     circle: circleTool,
     arc: arcTool,
@@ -33,9 +36,19 @@ export function registerTools(): void {
     pen: withHandles(penTool),
     arrow: withHandles(arrowTool),
     cloud: withHandles(cloudTool),
+    // the markup shapes (Arrow's group on the rail): 'm' for markup, apart from Draft's Line, Rectangle and Circle
+    mline: withHandles(markLineTool),
+    mrect: withHandles(markRectTool),
+    mtri: withHandles(markTriangleTool),
+    mcircle: withHandles(markCircleTool),
     text: textTool,
     calib: calibTool,
+    // the wall view's own
+    wdoor: wallDoorTool,
+    wwindow: wallWindowTool,
+    cabinet: cabinetTool,
+    height: heightTool,
   });
 }
 
-export const lineTool = (t: string): LineTool | null => (t === 'line' || t === 'wall' ? (tools[t] as LineTool) : null);
+export const lineTool = (t: string): LineTool | null => (t === 'line' ? (tools[t] as LineTool) : null);

package/src/tools/line.ts

@@ -5,15 +5,18 @@ import { pushHistory } from '../model/history';
 import { roomGeom, maybeRoom } from '../model/rooms';
 import { settings } from '../model/settings';
 import { addLine, gc, pinnedPoints } from '../model/sketch';
-import { SK } from '../model/store';
+import { SK, store } from '../model/store';
 import type { LineKind } from '../model/types';
 import { TH } from '../render/theme';
-import { snapAt } from '../render/snap';
-import { requestDraw, S } from '../render/view';
+import { shiftSnap, snap45, snapAt } from '../render/snap';
+import { requestDraw, requestOverlayDraw, S } from '../render/view';
 import { fmtArea } from '../units';
-import { commitPoint, applyPending, lengthPreview, PT, rememberHover, type PEv, type Tool } from './registry';
+import { commitPoint, applyPending, lengthPreview, PT, rememberHover, wallBand, type PEv, type Tool } from './registry';
 import { openKeypad, toast, updateCtx, updateHint } from '../editor/ports';
 import type { KeyIn } from '../editor/keys';
+import { intoWall, PAST_WALL } from '../editor/elevation';
+import { drawsWalls } from '../editor/mode';
+import { splitWallsAtEnds } from './modify';
 
 export interface LineState {
   start: string | null;
@@ -21,6 +24,8 @@ export interface LineState {
   prev: string | null;
   chain: string[];
   down: { sx: number; sy: number } | null;
+  /** where a press that may drag out the first segment snapped (the segment's start, if it drags) */
+  downSnap: Snap | null;
   dir: [number, number];
 }
 
@@ -31,9 +36,13 @@ export interface LineTool extends Tool {
   finish(): void;
 }
 
-/** Line and wall tools: tap-tap chains, drag for one segment, type a length, close back to the start. */
-export function makeLineTool(kind: LineKind): LineTool {
-  const fresh = (dir: [number, number]): LineState => ({ start: null, first: null, prev: null, chain: [], down: null, dir });
+/**
+ * The Line tool: tap-tap chains, drag for one segment, type a length, close back to the start. With the rail's Walls
+ * toggle on it draws walls (along their centre), as every drawing tool does.
+ */
+export function makeLineTool(): LineTool {
+  const kindNow = (): LineKind => (drawsWalls() ? 'wall' : 'line');
+  const fresh = (dir: [number, number]): LineState => ({ start: null, first: null, prev: null, chain: [], down: null, downSnap: null, dir });
   const t = {
     st: fresh([1, 0]),
     reset() {
@@ -41,44 +50,65 @@ export function makeLineTool(kind: LineKind): LineTool {
       if (had) pinnedPoints.delete(had);
       this.st = fresh(this.st ? this.st.dir : [1, 0]);
       ed.snapState = null; ed.preview = null;
-      if (had) { gc(SK()); analyze(); requestDraw(); }
+      // tidy the drawing it was building on — unless a new session cleared it (left the editor mid-chain)
+      if (had && store.project) { gc(SK()); analyze(); requestDraw(); }
       updateCtx(); updateHint();
     },
     busy() { return !!this.st.start; },
     opts(ev: PEv) { return { from: this.st.start, prevLine: this.st.prev, touch: ev.touch }; },
-    hover(ev: PEv) { ed.snapState = snapAt(ev.sx, ev.sy, this.opts(ev)); rememberHover(ed.snapState); this.setPreview(); requestDraw(); },
-    setPreview() {
+    /** where the pointer snaps to (with Shift, from the line's start: level, plumb or 45°) */
+    at(ev: PEv): Snap {
+      const s = snapAt(ev.sx, ev.sy, this.opts(ev)), from = this.st.start ? null : this.dragFrom(ev);
+      if (!ev.shift) return s;
+      if (this.st.start) return shiftSnap(this.st.start, s);
+      if (from) { const q = snap45(from, s); return { x: q.x, y: q.y, kind: 'free', guides: [] }; }
+      return s;
+    },
+    /** dragging out the first segment: where it starts (null for a press that hasn't moved, or a hover) */
+    dragFrom(ev: PEv): Snap | null {
+      const st = this.st;
+      return st.down && st.downSnap && hyp(ev.sx - st.down.sx, ev.sy - st.down.sy) > 12 ? st.downSnap : null;
+    },
+    hover(ev: PEv) { ed.snapState = this.at(ev); rememberHover(ed.snapState); this.setPreview(this.st.start ? null : this.dragFrom(ev)); requestOverlayDraw(); },
+    /** the segment being drawn: from the last point (or, dragging out the first one, from where the drag began) */
+    setPreview(from: Snap | null = null) {
       const st = this.st;
-      if (!st.start || !ed.snapState) { ed.preview = null; return; }
-      const a = PT(st.start), b = { x: ed.snapState.x, y: ed.snapState.y };
+      if ((!st.start && !from) || !ed.snapState) { ed.preview = null; return; }
+      const a = st.start ? PT(st.start) : { x: from!.x, y: from!.y }, b = { x: ed.snapState.x, y: ed.snapState.y };
       if (hyp(b.x - a.x, b.y - a.y) > 1e-6) st.dir = norm2(b.x - a.x, b.y - a.y);
       ed.preview = (c, T) => {
-        const [x1, y1] = S(T, a.x, a.y), [x2, y2] = S(T, b.x, b.y);
+        const [x1, y1] = S(T, a.x, a.y), [x2, y2] = S(T, b.x, b.y), wall = kindNow() === 'wall';
+        if (wall) wallBand(c, T, () => { c.moveTo(x1, y1); c.lineTo(x2, y2); });
         c.save(); c.lineCap = 'butt';
-        if (kind === 'wall') { c.strokeStyle = 'rgba(0,102,255,.25)'; c.lineWidth = 4.5 * T.s; c.beginPath(); c.moveTo(x1, y1); c.lineTo(x2, y2); c.stroke(); }
         c.strokeStyle = TH.blue; c.lineWidth = 2;
-        if (ed.drawConstr) c.setLineDash([6, 5]);
+        if (ed.drawConstr && !wall) c.setLineDash([6, 5]);
         c.beginPath(); c.moveTo(x1, y1); c.lineTo(x2, y2); c.stroke(); c.restore();
         lengthPreview(c, T, a, b);
       };
     },
-    down(ev: PEv) { this.st.down = { sx: ev.sx, sy: ev.sy }; this.hover(ev); },
+    down(ev: PEv) {
+      this.st.down = { sx: ev.sx, sy: ev.sy };
+      this.st.downSnap = this.st.start ? null : snapAt(ev.sx, ev.sy, { touch: ev.touch });
+      this.hover(ev);
+    },
     move(ev: PEv) { this.hover(ev); },
     up(ev: PEv) {
       const st = this.st;
       const dragged = !!st.down && hyp(ev.sx - st.down.sx, ev.sy - st.down.sy) > 12;
       if (!st.start) {
         pushHistory();
-        const s0 = dragged ? snapAt(st.down!.sx, st.down!.sy, { touch: ev.touch }) : snapAt(ev.sx, ev.sy, { touch: ev.touch });
+        const s0 = dragged ? st.downSnap ?? snapAt(st.down!.sx, st.down!.sy, { touch: ev.touch }) : snapAt(ev.sx, ev.sy, { touch: ev.touch });
         const a = commitPoint(s0);
         applyPending(a.cons);
         st.start = a.id; st.first = a.id; st.chain = [a.id];
+        // (drawing: nothing left highlighted — neither what was selected before nor, as it goes, what's drawn)
+        ed.sel = [];
         pinnedPoints.clear(); pinnedPoints.add(a.id);
-        if (dragged) this.segmentTo(snapAt(ev.sx, ev.sy, this.opts(ev)));
+        if (dragged) this.segmentTo(this.at(ev));
         afterEdit(); this.hover(ev); updateCtx(); updateHint();
         return;
       }
-      const s = snapAt(ev.sx, ev.sy, this.opts(ev));
+      const s = this.at(ev);
       if (s.kind === 'point' && s.ref === st.start) { this.finish(); return; }
       pushHistory(); this.segmentTo(s); afterEdit();
       if (this.st.start) this.hover(ev);
@@ -87,10 +117,16 @@ export function makeLineTool(kind: LineKind): LineTool {
       const st = this.st;
       const a = PT(st.start!);
       if (hyp(s.x - a.x, s.y - a.y) < 1e-6) return;
+      // in the wall view: not past the wall (a typed length that would run out of it)
+      const [ix, iy] = intoWall(s.x, s.y);
+      if (Math.abs(ix - s.x) > 1e-6 || Math.abs(iy - s.y) > 1e-6) { toast(PAST_WALL, { warn: true }); return; }
       const b = commitPoint(s);
       if (b.id === st.start) return;
-      const lid = addLine(SK(), st.start!, b.id, { kind, constr: ed.drawConstr });
+      // walls are always solid (the construction-lines toggle is for lines)
+      const kind = kindNow(), lid = addLine(SK(), st.start!, b.id, { kind, constr: kind !== 'wall' && ed.drawConstr });
       applyPending(b.cons);
+      // (a wall ending partway along another wall splits that one there)
+      splitWallsAtEnds(SK(), lid);
       if (settings.autoCons) {
         for (const g of s.guides || []) {
           if (g.kind === 'H') tryAddConstraint({ type: 'h', a: g.from, b: b.id }, { silent: true });
@@ -105,7 +141,7 @@ export function makeLineTool(kind: LineKind): LineTool {
       if (closed) {
         const loop = st.chain.slice(0, -1);
         const sk = SK();
-        const rid = kind === 'wall' || !ed.drawConstr ? maybeRoom(sk, loop) : null;
+        const rid = kindNow() === 'wall' || !ed.drawConstr ? maybeRoom(sk, loop) : null;
         this.reset();
         if (rid) toast(sk.rooms[rid].name + ' added — ' + fmtArea(roomGeom(sk, sk.rooms[rid]).area));
       }
@@ -150,8 +186,8 @@ export function makeLineTool(kind: LineKind): LineTool {
       return false;
     },
     hint() {
-      if (this.st.start) return ed.lastPointerTouch ? 'Tap the next point. Tap <b>Type length</b> to enter an exact value.' : 'Click the next point, or just type a length and press Enter. Esc finishes.';
-      return kind === 'wall' ? 'Draw wall centerlines. Tap to start — walls are 4 1/2" thick; change it after.' : 'Tap to place points. Drawing back to the start closes the shape.';
+      if (this.st.start) return ed.lastPointerTouch ? 'Tap the next point. Tap the last point again to finish, or the first to close the shape.' : 'Click the next point (hold Shift for level, plumb or 45°), or just type a length and press Enter. Esc finishes.';
+      return kindNow() === 'wall' ? 'Draw wall centerlines. Tap to start — walls are 4 1/2" thick; change it after.' : 'Tap to place points. Drawing back to the start closes the shape.';
     },
   };
   return t;

package/src/tools/modify.ts

@@ -1,15 +1,17 @@
-import { afterEdit, solveOrRevert, tryAddConstraint } from '../app/edit';
+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 { 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 } from '../model/types';
+import type { Constraint, Sketch } from '../model/types';
 import { hitAny } from '../render/hit';
 import { outsideSide } from '../model/planGeom';
 import { mainT, requestDraw, 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';
@@ -141,20 +143,31 @@ export const openingTool = {
   move(ev: PEv) { this.hover(ev); },
   up(ev: PEv) {
     const h = hitAny(ev.sx, ev.sy, { touch: ev.touch, only: 'geom' });
-    if (!h || h.type !== 'line') { toast('Tap a wall to place it.'); return; }
+    if (!h || h.type !== 'line') { toast('Tap a wall to place it.', { warn: true }); return; }
     const sk = SK(), l = sk.lines[h.id], A = sk.points[l.a], B = sk.points[l.b];
+    // doors and windows are a wall's: not on a guide; a plain line becomes a wall to take one
+    if (l.constr) { toast('Doors and windows go in walls — that’s a construction line.', { warn: true }); return; }
+    const toWall = l.kind !== 'wall';
     const [wx, wy] = s2w(ev.sx, ev.sy);
     const L = hyp(B.x - A.x, B.y - A.y), w = 36;
-    if (L < w + 2) { toast('That wall is too short for a ' + fmtLen(w) + ' ' + ed.openingType + '.', { warn: true }); return; }
-    const at = clamp(projT(A, B, { x: wx, y: wy }) * L, w / 2, L - w / 2);
+    if (L < w + 2) { toast('That ' + (toWall ? 'line' : 'wall') + ' is too short for a ' + fmtLen(w) + ' ' + ed.openingType + '.', { warn: true }); return; }
+    // (snapped, as one slid along the wall is: an edge to the wall's ends, its corners, another door's or window's edge)
+    const at0 = projT(A, B, { x: wx, y: wy }) * L;
+    const at = clamp(at0 + snapSlide(at0, w, 0, placeTargets(sk, h.id), (ev.touch ? 16 : 10) / mainT().s), w / 2, L - w / 2);
     const side = (B.x - A.x) * (wy - A.y) - (B.y - A.y) * (wx - A.x) >= 0;
     pushHistory();
+    if (toWall) { l.kind = 'wall'; l.thick = l.thick || 4.5; }
     const id = uid('o');
-    sk.openings[id] = { line: h.id, at, w, type: ed.openingType, flip: !side };
-    ed.sel = [{ type: 'opening', id }];
+    sk.openings[id] = { line: h.id, at, w, wSet: false, type: ed.openingType, flip: !side };
+    // (placed, not selected: tap it to size it, flip it or slide it)
+    ed.sel = [];
+    // (a line made a wall: what's measured on the faces of the walls it meets holds)
+    if (toWall) holdFaces();
     afterEdit();
+    // (one undo step takes back both)
+    if (toWall) toast('Made that line a wall for the ' + ed.openingType + '.', { action: { label: 'Undo', fn: undo } });
   },
-  hint() { return 'Tap a wall to place a 3\'-0" ' + ed.openingType + '. Slide it along the wall with Select.'; },
+  hint() { return 'Tap a wall to place a 3\'-0" ' + ed.openingType + ' (a line you tap becomes a wall). Slide it along the wall with Select.'; },
 };
 
 export const roomTool = {
@@ -169,8 +182,8 @@ export const roomTool = {
     if (!face) { toast('Tap inside a closed shape. That spot isn’t enclosed by lines.', { warn: true }); return; }
     pushHistory();
     const id = maybeRoom(sk, face.loop, face.edges);
-    if (!id) { dropHistory(); toast('That area is too small for a space.'); return; }
-    ed.sel = [{ type: 'room', id }];
+    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));
   },
@@ -185,44 +198,93 @@ export const roomTool = {
 export function splitLine(lid: string): string | null {
   const sk = SK(), l = sk.lines[lid];
   if (!l) return null;
+  const A = sk.points[l.a], B = sk.points[l.b];
+  if (hyp(B.x - A.x, B.y - A.y) < 1e-6) return null;
+  pushHistory();
+  const nid = splitLineAt(sk, lid, addPoint(sk, (A.x + B.x) / 2, (A.y + B.y) / 2));
+  ed.sel = nid ? [{ type: 'line', id: lid }, { type: 'line', id: nid }] : [];
+  afterEdit();
+  toast('Split into two lines. Drag the middle point to move the split.');
+  return nid;
+}
+
+/**
+ * Split line `lid` at point `pid`, which lies on it between its ends: it runs to pid, and a new line (returned) runs on
+ * from there to its old end — the same kind, thickness and height. The two stay collinear and keep its constraints
+ * (see splitLine), its spaces, its doors and windows (each on the piece it's on, measured from where it was) and what's
+ * drawn on its faces. Part of an edit: the caller pushes history and runs afterEdit.
+ */
+export function splitLineAt(sk: Sketch, lid: string, pid: string): string | null {
+  const l = sk.lines[lid], P = sk.points[pid];
+  if (!l || !P) return null;
   const A = sk.points[l.a], B = sk.points[l.b], L = hyp(B.x - A.x, B.y - A.y);
   if (L < 1e-6) return null;
-  pushHistory();
-  const oldA = l.a, oldB = l.b, side = outsideSide(sk, lid);
-  const m = addPoint(sk, (A.x + B.x) / 2, (A.y + B.y) / 2);
-  l.b = m;
-  const nid = addLine(sk, m, oldB, { kind: l.kind, constr: l.constr, thick: l.thick });
+  const s = clamp(projT(A, B, P), 0, 1) * L, oldA = l.a, oldB = l.b, side = outsideSide(sk, lid);
+  l.b = pid;
+  const nid = addLine(sk, pid, oldB, { kind: l.kind, constr: l.constr, thick: l.thick });
+  if (l.height != null) sk.lines[nid].height = l.height;
   const copies: Constraint[] = [];
   for (const id in sk.cons) {
     const c = sk.cons[id];
     const onAB = (c.a === oldA && c.b === oldB) || (c.a === oldB && c.b === oldA);
-    if ((c.type === 'h' || c.type === 'v') && onAB) { c.a = oldA; c.b = m; copies.push({ type: c.type, a: m, b: oldB }); }
+    if ((c.type === 'h' || c.type === 'v') && onAB) { c.a = oldA; c.b = pid; copies.push({ type: c.type, a: pid, b: oldB }); }
     else 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 }));
     else if (c.type === 'dist' && c.line === lid) {
       // still the full end-to-end distance; moved out beside the wall so the new middle point stays reachable
       c.line = null;
       if (!c.off) c.off = (30 / mainT().s) * side * (c.a === oldA ? 1 : -1);
+      // (one measured on the wall's face no longer has one wall to be measured along: end to end, as it is now)
+      if (c.face) { delete c.face; if (c.driving !== false) c.value = L; }
     }
     else if (c.type === 'mid' && c.l === lid) delete sk.cons[id]; // "midpoint of" no longer means the same line
+    // (the point it's split at is an end of both pieces now, not on the line)
+    else if (c.type === 'online' && c.p === pid && c.l === lid) delete sk.cons[id];
   }
   for (const c of copies) tryAddConstraint(c, { silent: true });
   tryAddConstraint({ type: 'col', l1: lid, l2: nid }, { silent: true });
-  // rooms: put the new point into any loop that ran along this line
+  // rooms: put the split point into any loop that ran along this line
   for (const id in sk.rooms) {
     const r = sk.rooms[id], loop = r.loop;
     for (let i = 0; i < loop.length; i++) {
       const p = loop[i], q = loop[(i + 1) % loop.length];
       if (r.edges ? r.edges[i] !== lid : !((p === oldA && q === oldB) || (p === oldB && q === oldA))) continue;
-      loop.splice(i + 1, 0, m);
-      // edges follow the walk direction: oldA→m is the original line, m→oldB the new one
+      loop.splice(i + 1, 0, pid);
+      // edges follow the walk direction: oldA→pid is the original line, pid→oldB the new one
       if (r.edges) r.edges.splice(i, 1, ...(p === oldA ? [lid, nid] : [nid, lid]));
       break;
     }
   }
-  // doors/windows past the split move to the second piece
-  for (const id in sk.openings) { const o = sk.openings[id]; if (o.line === lid && o.at > L / 2) { o.line = nid; o.at -= L / 2; } }
-  ed.sel = [{ type: 'line', id: lid }, { type: 'line', id: nid }];
-  afterEdit();
-  toast('Split into two lines. Drag the middle point to move the split.');
+  for (const id in sk.openings) {
+    const o = sk.openings[id];
+    // doors/windows past the split move to the second piece
+    if (o.line === lid && o.at > s) { o.line = nid; o.at -= s; }
+    // and what's measured from the far corner of the wall is measured from that corner still — the new piece's
+    for (const d of o.dims ?? []) if ('face' in d.ref && d.ref.line === lid && d.ref.face === 'b') d.ref = { ...d.ref, line: nid };
+  }
+  // and so does what's drawn on the wall's faces past it
+  splitFaces(sk, lid, nid, s);
   return nid;
 }
+
+/**
+ * A wall drawn to (or from) partway along another wall splits that one there, so they meet at a corner they share — as
+ * three walls meeting at a point do. Lines never split anything, and nothing splits a line. Part of an edit.
+ */
+export function splitWallsAtEnds(sk: Sketch, lid: string): void {
+  const l = sk.lines[lid];
+  if (!l || l.kind !== 'wall' || l.constr) return;
+  for (const pid of [l.a, l.b]) {
+    const P = sk.points[pid];
+    if (!P) continue;
+    for (const [wid, w] of Object.entries(sk.lines)) {
+      if (wid === lid || w.kind !== 'wall' || w.constr || w.a === pid || w.b === pid) continue;
+      const A = sk.points[w.a], B = sk.points[w.b], L = hyp(B.x - A.x, B.y - A.y);
+      if (!A || !B || L < 1e-6) continue;
+      const t = projT(A, B, P), off = Math.abs((P.x - A.x) * (B.y - A.y) - (P.y - A.y) * (B.x - A.x)) / L;
+      // (on it, and an inch or more from either end)
+      if (off > 1e-3 || t * L < 1 || (1 - t) * L < 1) continue;
+      splitLineAt(sk, wid, pid);
+      break;
+    }
+  }
+}