@design-core/core 51.1.0 → 52.0.0

package/core/dimensions/dimensionBase.js

@@ -84,6 +84,17 @@ export class DimensionBase extends Entity {
       writable: true,
     });
 
+    // DXF Groupcode 70 bit 128 - user-positioned text flag, exposed as a property so a grip-drop
+    // commit can include it explicitly in the UpdateState snapshot, alongside points, for undo/redo
+    this.properties.add(Property.Names.USERPOSITIONEDTEXT, {
+      type: Property.Type.BOOLEAN,
+      visible: false,
+      get: (entity) => entity.dimType.hasUserPositionedText(),
+      set: (entity, value) => {
+        entity.dimType.userPositionedText = value;
+      },
+    });
+
     if (data) {
       if (data.hasOwnProperty('41')) {
         // DXF Groupcode 41 - Line Spacing Factor
@@ -350,6 +361,30 @@ export class DimensionBase extends Entity {
     return DesignCore.DimStyleManager.getItemByName(this.getProperty(Property.Names.DIMENSIONSTYLE));
   }
 
+  /**
+   * Get the grip points for interactive editing on the canvas.
+   * Only the text position (Pt11) is exposed - it's never a dependency for any other point.
+   * @return {Array<{point: Point, apply: Function}>} grips
+   */
+  getGrips() {
+    const Pt11 = this.getPointBySequence(this.points, 11);
+
+    if (!Pt11) {
+      return [];
+    }
+
+    const apply = (newPoint) => {
+      return this.points.map((point) => {
+        if (point.sequence === 11) {
+          return new Point(newPoint.x, newPoint.y, point.bulge, point.sequence);
+        }
+        return point;
+      });
+    };
+
+    return [{ point: Pt11, apply: apply }];
+  }
+
   /**
    * Get the point for the sequence number
    * @param {Array} points - array of points to search
@@ -430,15 +465,24 @@ export class DimensionBase extends Entity {
     return centreMark;
   }
 
+  /**
+   * Refresh the block geometry if it hasn't been built yet.
+   * Needed because block delegates (draw, boundingBox, within, touched, closestPoint)
+   * can run before the first draw() call (e.g. a window-select immediately after creation).
+   */
+  ensureRefreshed() {
+    if (this.block.entities.length === 0) {
+      this.refresh();
+    }
+  }
+
   /**
    * Draw the entity
    * @param {Object} renderer
    * @return {Array} block entities for the canvas to render recursively
    */
   draw(renderer) {
-    if (this.block.entities.length === 0) {
-      this.refresh();
-    }
+    this.ensureRefreshed();
 
     return this.block.entities;
   }
@@ -460,6 +504,7 @@ export class DimensionBase extends Entity {
    * @return {Array} - [Point, distance]
    */
   closestPoint(P) {
+    this.ensureRefreshed();
     return this.block.closestPoint(P);
   }
 
@@ -468,6 +513,7 @@ export class DimensionBase extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
+    this.ensureRefreshed();
     return this.block.boundingBox();
   }
 
@@ -477,6 +523,7 @@ export class DimensionBase extends Entity {
    * @return {boolean} true if within
    */
   within(selection) {
+    this.ensureRefreshed();
     return this.block.within(selection);
   }
 
@@ -486,6 +533,7 @@ export class DimensionBase extends Entity {
    * @return {boolean} true if touched
    */
   touched(selection) {
+    this.ensureRefreshed();
     return this.block.touched(selection);
   }
 
@@ -493,7 +541,22 @@ export class DimensionBase extends Entity {
    * Refresh the dimension geometry
    */
   refresh() {
-    const entities = this.buildDimension();
+    // buildDimension() can itself call setProperty() (e.g. LINEARDIMANGLE) which would
+    // otherwise re-enter refresh() recursively - skip while already refreshing
+    if (this.refreshing) {
+      return;
+    }
+
+    this.refreshing = true;
+    let entities;
+    try {
+      entities = this.buildDimension();
+    } catch (err) {
+      // geometry can't be built yet (e.g. incomplete points during interactive creation) - skip this refresh
+      return;
+    } finally {
+      this.refreshing = false;
+    }
 
     if (entities) {
       this.block.clearEntities();
@@ -513,7 +576,47 @@ export class DimensionBase extends Entity {
    */
   setProperty(property, value) {
     if (this.properties.has(property)) {
+      if (property === Property.Names.POINTS) {
+        // Dragging the Pt11 grip independently of the anchor points (Pt13/Pt14) - as opposed
+        // to a rigid whole-dimension Move/Rotate, which moves them together - means the user
+        // has explicitly repositioned the text; record that via the DXF bit 128 flag so
+        // buildDimension() uses Pt11 directly instead of auto-placing it (DIMJUST/DIMTAD)
+        const oldPt11 = this.getPointBySequence(this.points, 11);
+        const oldPt13 = this.getPointBySequence(this.points, 13);
+        const oldPt14 = this.getPointBySequence(this.points, 14);
+        const newPt11 = this.getPointBySequence(value, 11);
+        const newPt13 = this.getPointBySequence(value, 13);
+        const newPt14 = this.getPointBySequence(value, 14);
+
+        if (oldPt11 && newPt11 && oldPt13 && newPt13 && oldPt14 && newPt14) {
+          const pt11Moved = !oldPt11.isSame(newPt11);
+          const anchorsUnchanged = oldPt13.isSame(newPt13) && oldPt14.isSame(newPt14);
+          if (pt11Moved && anchorsUnchanged) {
+            this.dimType.userPositionedText = true;
+          }
+        }
+      }
+
+      if (property === Property.Names.POINTS && this.dimType.getBaseDimType() === 0) {
+        // Rotated dimension: LINEARDIMANGLE is a fixed angle independent of the points,
+        // so a rigid rotation of the points (e.g. via the Rotate tool) must also rotate
+        // this stored angle by the same amount - mirrors Hatch's points -> angle handling
+        const oldPt13 = this.getPointBySequence(this.points, 13);
+        const oldPt14 = this.getPointBySequence(this.points, 14);
+        const newPt13 = this.getPointBySequence(value, 13);
+        const newPt14 = this.getPointBySequence(value, 14);
+
+        if (oldPt13 && oldPt14 && newPt13 && newPt14) {
+          const theta = newPt13.angle(newPt14) - oldPt13.angle(oldPt14);
+          if (theta !== 0) {
+            this.setProperty(Property.Names.LINEARDIMANGLE, this.getProperty(Property.Names.LINEARDIMANGLE) + Utils.radians2degrees(theta));
+          }
+        }
+      }
       super.setProperty(property, value);
+      // geometry is derived from properties (points, style, angle, etc.) - rebuild it,
+      // e.g. so tools like Rotate/Move that update 'points' are reflected visually
+      this.refresh();
       return;
     }
     if (this.hasOwnProperty(property)) {

package/core/dimensions/linearDimensionBase.js

@@ -4,12 +4,12 @@ import { Text } from '../entities/text.js';
 import { Input, PromptOptions } from '../lib/inputManager.js';
 import { Logging } from '../lib/logging.js';
 import { DimensionBase } from './dimensionBase.js';
-import { Point } from '../entities/point.js';
 
 import { DesignCore } from '../designCore.js';
 import { Property } from '../properties/property.js';
 import { Utils } from '../lib/utils.js';
 import { RubberBand } from '../lib/auxiliary/rubberBand.js';
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
 
 /**
  * Aligned Dimension Entity Class
@@ -45,6 +45,8 @@ export class LinearDimensionBase extends DimensionBase {
       this.points.push(pt14);
 
       const op2 = new PromptOptions(Strings.Input.DIMENSION, [Input.Type.POINT]);
+      // avoid polar/ortho tracking a line from pt14 while placing the dimension
+      DesignCore.Scene.inputManager.inputPoint = null;
       const pt11 = await DesignCore.Scene.inputManager.requestInput(op2);
       pt11.sequence = 11;
       this.points.push(pt11);
@@ -76,6 +78,70 @@ export class LinearDimensionBase extends DimensionBase {
     }
   }
 
+  /**
+   * Get the grip points for interactive editing on the canvas.
+   * Pt10 (the dimension line's far end) is derived from Pt11 via getPointsFromSelection() -
+   * it must be recomputed, not left stale, when the Pt11 grip moves.
+   * @return {Array<{point: Point, apply: Function}>} grips
+   */
+  getGrips() {
+    const Pt13 = this.getPointBySequence(this.points, 13);
+    const Pt14 = this.getPointBySequence(this.points, 14);
+    const Pt11 = this.getPointBySequence(this.points, 11);
+
+    if (!Pt13 || !Pt14 || !Pt11) {
+      return [];
+    }
+
+    const apply = (newPoint) => {
+      const tempLine = new Line({ points: [Pt13, Pt14] });
+      const angle = this.getProperty(Property.Names.LINEARDIMANGLE);
+      return this.constructor.getPointsFromSelection([tempLine], newPoint, angle);
+    };
+
+    return [{ point: Pt11, apply: apply }];
+  }
+
+  /**
+   * Get the points where the extension lines meet the dimension line
+   * @return {Array<Point>} [Pt13e, Pt14e]
+   */
+  getDimensionLineEndPoints() {
+    const Pt10 = this.getPointBySequence(this.points, 10);
+    const Pt13 = this.getPointBySequence(this.points, 13);
+    const Pt14 = this.getPointBySequence(this.points, 14);
+
+    if (this.dimType.getBaseDimType() === 0) {
+      // Rotated dimension: the dimension line direction is a fixed, user-specified angle
+      // (LINEARDIMANGLE) independent of the measured points - project the extension
+      // line origin onto that fixed line, so it stays correct at any rotation, not just 0/90/180/270
+      const dimLineAngleRad = Utils.degrees2radians(this.getProperty(Property.Names.LINEARDIMANGLE));
+      const linePt2 = Pt10.project(dimLineAngleRad, 1);
+      return [Pt13.perpendicular(Pt10, linePt2), Pt10];
+    }
+
+    // Aligned dimension: the dimension line is parallel to the measured edge (Pt13 -> Pt14),
+    // derived dynamically from the points rather than a fixed angle
+    return [Pt13.project(Pt14.angle(Pt10), Pt14.distance(Pt10)), Pt10];
+  }
+
+  /**
+   * Get snap points
+   * @param {Point} mousePoint
+   * @param {number} delta
+   * @return {Array} - array of snap points
+   */
+  snaps(mousePoint, delta) {
+    const Pt10 = this.getPointBySequence(this.points, 10);
+    const Pt13 = this.getPointBySequence(this.points, 13);
+    const Pt14 = this.getPointBySequence(this.points, 14);
+
+    if (!Pt10 || !Pt13 || !Pt14) {
+      return [];
+    }
+
+    return this.getDimensionLineEndPoints().map((point) => new SnapPoint(point, SnapPoint.Type.END));
+  }
 
   /**
    * Build the dimension
@@ -86,7 +152,6 @@ export class LinearDimensionBase extends DimensionBase {
     let dimension = 0;
     const entities = [];
 
-    const Pt10 = this.getPointBySequence(this.points, 10);
     const Pt13 = this.getPointBySequence(this.points, 13);
     const Pt14 = this.getPointBySequence(this.points, 14);
     const Pt11 = this.getPointBySequence(this.points, 11);
@@ -113,38 +178,8 @@ export class LinearDimensionBase extends DimensionBase {
       return;
     }
 
-    let Pt13e = new Point();
-    const Pt14e = Pt10;
-
-    // generate the x and y delta values
-    const dx = Pt14.x - Pt13.x;
-    const dy = Pt14.y - Pt13.y;
-
-    // check if Line Pt13 -> P14 is perpendicular to Line Pt14 -> Pt10
-    const m1 = (Pt14.y - Pt13.y) / (Pt14.x - Pt13.x);
-    const m2 = (Pt14.y - Pt10.y) / (Pt14.x - Pt10.x);
-    const perpendicular = Number((m1 * m2).toFixed(1));
-
-    const isAligned = perpendicular !== -1.0 ? false : true;
-
-    if (isAligned || Utils.round(dx) === 0 || Utils.round(dy) === 0) {
-      Pt13e = Pt13.project(Pt14.angle(Pt10), Pt14.distance(Pt10));
-      dimension = Pt13.distance(Pt14);
-    } else {
-      // Not perpendicular to the selected line: get the primary axis (x or y) and calculate the dimension
-      const iX = ((Math.abs(Pt10.x - Pt13.x) + Math.abs(Pt14.x - Pt10.x)) - Math.abs(dx));
-      const iY = ((Math.abs(Pt10.y - Pt13.y) + Math.abs(Pt14.y - Pt10.y)) - Math.abs(dy));
-
-      if (iX >= iY && dy !== 0) {
-        Pt13e.x = Pt10.x;
-        Pt13e.y = Pt13.y;
-        dimension = dy;
-      } else if (iX < iY && dx !== 0) {
-        Pt13e.x = Pt13.x;
-        Pt13e.y = Pt10.y;
-        dimension = dx;
-      }
-    }
+    const [Pt13e, Pt14e] = this.getDimensionLineEndPoints();
+    dimension = this.dimType.getBaseDimType() === 0 ? Pt13e.distance(Pt14e) : Pt13.distance(Pt14);
 
     // ensure dimension is positive
     dimension = Math.abs(dimension);
@@ -155,9 +190,6 @@ export class LinearDimensionBase extends DimensionBase {
     const reverseDimLineAngle = Pt14e.angle(Pt13e);
     const midPoint = Pt13e.midPoint(Pt14e);
 
-    // set the dimension line angle. This is required for rotated dimension dxf definition
-    this.setProperty(Property.Names.LINEARDIMANGLE, Utils.radians2degrees(dimLineAngle));
-
     // Approximate text width based on height using the formatted dimension value i.e with units, precision and symbols
     const approxTextWidth = Text.getApproximateWidth(this.getDimensionValue(dimension), DIMTXT);
     const approxTextHalfWidth = approxTextWidth * 0.5;
@@ -221,6 +253,12 @@ export class LinearDimensionBase extends DimensionBase {
         break;
     }
 
+    // A grip-dragged text position overrides the DIMJUST auto-placement above with Pt11 as
+    // the anchor - DIMTAD's vertical offset below still applies on top, matching AutoCAD
+    if (this.dimType.hasUserPositionedText()) {
+      textPosition = Pt11;
+    }
+
     // Check if the text is aligned with the dimension line
     const textAndDimlineAligned = this.alignedOrOpposite(textRotation, dimLineAngle);
 

package/core/dimensions/radialDimension.js

@@ -14,7 +14,7 @@ export class RadialDimension extends CircularDimensionBase {
    */
   constructor(data) {
     super(data);
-    this.dimType.setDimType(4); // Radial dimension
+    this.dimType.setBaseType(4); // Radial dimension - preserve flags loaded from DXF group 70
   }
 
   /**
@@ -48,6 +48,31 @@ export class RadialDimension extends CircularDimensionBase {
     return points;
   }
 
+  /**
+   * Get the grip points for interactive editing on the canvas.
+   * Pt15 (the circle attach point) is derived from Pt11 via getPointsFromSelection() -
+   * must be recomputed from the unchanged centre (Pt10) and radius, not left stale.
+   * @return {Array<{point: Point, apply: Function}>} grips
+   */
+  getGrips() {
+    const Pt10 = this.getPointBySequence(this.points, 10); // centre
+    const Pt15 = this.getPointBySequence(this.points, 15); // point on circle
+    const Pt11 = this.getPointBySequence(this.points, 11); // text position
+
+    if (!Pt10 || !Pt15 || !Pt11) {
+      return [];
+    }
+
+    const radius = Pt10.distance(Pt15);
+
+    const apply = (newPoint) => {
+      const tempEntity = { points: [Pt10], getRadius: () => radius };
+      return this.constructor.getPointsFromSelection([tempEntity], newPoint);
+    };
+
+    return [{ point: Pt11, apply: apply }];
+  }
+
   /**
    * Write the entity to file in the dxf format
    * @param {DXFFile} file

package/core/dimensions/rotatedDimension.js

@@ -22,7 +22,7 @@ export class RotatedDimension extends LinearDimensionBase {
    */
   constructor(data) {
     super(data);
-    this.dimType.setDimType(0); // Rotated dimension
+    this.dimType.setBaseType(0); // Rotated dimension - preserve flags loaded from DXF group 70
   }
 
   /**
@@ -62,6 +62,8 @@ export class RotatedDimension extends LinearDimensionBase {
       this.points.push(pt14);
 
       const op2 = new PromptOptions(Strings.Input.DIMENSION, [Input.Type.POINT]);
+      // avoid polar/ortho tracking a line from pt14 while placing the dimension
+      DesignCore.Scene.inputManager.inputPoint = null;
       const pt11 = await DesignCore.Scene.inputManager.requestInput(op2);
       pt11.sequence = 11;
       this.points.push(pt11);
@@ -126,8 +128,9 @@ export class RotatedDimension extends LinearDimensionBase {
       const pt11 = DesignCore.Mouse.pointOnScene();
       pt11.sequence = 11;
       const tempLine = new Line({ points: [this.points[0], this.points[1]] });
-      const points = RotatedDimension.getPointsFromSelection([tempLine], pt11, this.getProperty(Property.Names.LINEARDIMANGLE));
-      DesignCore.Scene.previewEntities.create(this.type, { points: points, dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE) });
+      const angle = this.getProperty(Property.Names.LINEARDIMANGLE);
+      const points = RotatedDimension.getPointsFromSelection([tempLine], pt11, angle);
+      DesignCore.Scene.previewEntities.create(this.type, { points: points, dimensionStyle: this.getProperty(Property.Names.DIMENSIONSTYLE), linearDimAngle: angle });
     }
   }
 

package/core/entities/entity.js

@@ -109,6 +109,15 @@ export class Entity {
     this.properties.set(Property.Names.POINTS, value, this);
   }
 
+  /**
+   * Get the grip points for interactive editing on the canvas.
+   * Overridden by entities that expose editable grips (e.g. DimensionBase).
+   * @return {Array<{point: Point, apply: Function}>} grips - apply(newPoint) returns a new points array
+   */
+  getGrips() {
+    return [];
+  }
+
   /**
    * Normalise entity-level DXF group codes before construction.
    * Subclasses override this for geometric transformation; they receive data

package/core/lib/auxiliary/snapPoint.js

@@ -13,6 +13,7 @@ export class SnapPoint {
     TANGENT: 'tangent',
     NODE: 'node',
     PERPENDICULAR: 'perpendicular',
+    GRIP: 'grip',
   });
 
   /**
@@ -57,6 +58,14 @@ export class SnapPoint {
           new Point(x - size, y + size),
         ], { closed: true });
         break;
+      case SnapPoint.Type.GRIP: // filled square
+        renderer.drawShape([
+          new Point(x - size, y - size),
+          new Point(x + size, y - size),
+          new Point(x + size, y + size),
+          new Point(x - size, y + size),
+        ], { closed: true, fill: true });
+        break;
       case SnapPoint.Type.MID: // triangle
         renderer.drawShape([
           new Point(x, y + size),

package/core/lib/canvas.js

@@ -5,6 +5,7 @@ import { Point } from '../entities/point.js';
 import { Input } from './input.js';
 import { Logging } from './logging.js';
 import { PlotOptions } from './plotOptions.js';
+import { SnapPoint } from './auxiliary/snapPoint.js';
 // import { RendererBase } from './renderers/rendererBase.js';
 
 import { DesignCore } from '../designCore.js';
@@ -305,7 +306,9 @@ export class Canvas {
    */
   exportTo(renderer, plotOptions) {
     let area;
-    if (plotOptions.plotArea === PlotOptions.Area.DISPLAY) {
+    if (plotOptions.plotArea === PlotOptions.Area.WINDOW) {
+      area = new BoundingBox(plotOptions.windowArea.point1, plotOptions.windowArea.point2);
+    } else if (plotOptions.plotArea === PlotOptions.Area.DISPLAY) {
       const viewport = this.getSceneOffset();
       area = new BoundingBox(new Point(viewport.xmin, viewport.ymin), new Point(viewport.xmax, viewport.ymax));
     } else {
@@ -318,6 +321,7 @@ export class Canvas {
       pageWidth: plotOptions.pageWidth,
       pageHeight: plotOptions.pageHeight,
       plotScale: plotOptions.plotScale,
+      margin: plotOptions.margin,
     });
     if (!matrix) return false;
 
@@ -396,6 +400,11 @@ export class Canvas {
     const selectedEntities = DesignCore.Scene.selectionManager.selectedEntities;
     this.#paintEntities(selectedEntities, renderer, { colour: selectionHaloColour, lineWidthDelta: selectionLineWidthDelta });
 
+    // Paint grips for selected entities - only when idle (no active command)
+    if (DesignCore.Scene.inputManager.activeCommand === undefined) {
+      this.#paintGrips(selectedEntities, renderer, scale);
+    }
+
     // Paint the auxiliary scene items
     // auxiliary items include things like the selection window, snap points etc
     // these items have their own draw routine
@@ -459,6 +468,22 @@ export class Canvas {
     }
   }
 
+  /**
+   * Draw grip markers for every grip exposed by the given entities.
+   * @param {Array} entities - selected entities to draw grips for
+   * @param {Object} renderer - renderer instance
+   * @param {number} scale - current canvas scale
+   */
+  #paintGrips(entities, renderer, scale) {
+    for (const entity of entities) {
+      for (const grip of entity.getGrips()) {
+        renderer.save();
+        new SnapPoint(grip.point, SnapPoint.Type.GRIP).draw(renderer, scale);
+        renderer.restore();
+      }
+    }
+  }
+
   /**
    * Set the scene context on the renderer before drawing an entity.
    * @param {Object} item - entity to draw

package/core/lib/commandManager.js

@@ -12,7 +12,7 @@ import { Text } from '../entities/text.js';
 import { Block } from '../tables/block.js';
 import { Insert } from '../entities/insert.js';
 import { Hatch } from '../entities/hatch.js';
-/*
+
 import { Dimension } from '../dimensions/dimension.js';
 import { AlignedDimension } from '../dimensions/alignedDimension.js';
 import { AngularDimension } from '../dimensions/angularDimension.js';
@@ -20,7 +20,7 @@ import { LinearDimension } from '../dimensions/linearDimension.js';
 import { DiametricDimension } from '../dimensions/diametricDimension.js';
 import { RadialDimension } from '../dimensions/radialDimension.js';
 import { RotatedDimension } from '../dimensions/rotatedDimension.js';
-*/
+
 
 // import { Point } from "../entities/point.js"
 
@@ -43,6 +43,9 @@ import { Purge } from '../tools/purge.js';
 import { Pan } from '../tools/pan.js';
 import { Zoom } from '../tools/zoom.js';
 
+// Internal tools (not shown in any toolbar, invoked programmatically)
+import { WindowPick } from '../tools/windowPick.js';
+
 // Clipboard tools
 import { Copybase } from '../tools/copybase.js';
 import { Copyclip } from '../tools/copyclip.js';
@@ -67,7 +70,7 @@ const classes = {
   // Spline,
   ArcAlignedText,
   Text,
-  /*
+
   Dimension,
   AngularDimension,
   AlignedDimension,
@@ -75,7 +78,7 @@ const classes = {
   LinearDimension,
   RadialDimension,
   RotatedDimension,
-  */
+
   Block,
   Insert,
   Hatch,
@@ -99,6 +102,8 @@ const classes = {
   Zoom,
   Pan,
 
+  WindowPick,
+
   Copybase,
   Copyclip,
   Cutclip,

package/core/lib/dxf/dxf.js

@@ -388,8 +388,14 @@ export class DXF {
 
     const command = entity[0];
     if (DesignCore.CommandManager.isCommand(command)) {
-      const newEntity = DesignCore.CommandManager.createNew(command, entity);
-      DesignCore.Scene.entities.add(newEntity);
+      try {
+        const newEntity = DesignCore.CommandManager.createNew(command, entity);
+        DesignCore.Scene.entities.add(newEntity);
+      } catch (err) {
+        // a recognised command can still fail to build (e.g. unsupported dimension subtype) - skip it, don't abort the rest of the file
+        Logging.instance.warn(`${Strings.Message.UNKNOWNCOMMAND} ${command}: ${err}`);
+        this.unsupportedElements = true;
+      }
     } else {
       Logging.instance.warn(`${Strings.Message.UNKNOWNCOMMAND} ${command}`);
       this.unsupportedElements = true;

package/core/lib/inputManager.js

@@ -1,4 +1,5 @@
 import { Tool } from '../tools/tool.js';
+import { GripStretch } from '../tools/gripStretch.js';
 import { Snapping } from './snapping.js';
 
 import { DesignCore } from '../designCore.js';
@@ -39,6 +40,7 @@ export class InputManager {
     }
 
     this.promptOption = undefined;
+    DesignCore.Mouse.reset();
     DesignCore.Scene.reset();
     DesignCore.Canvas.setCursorForInputTypes([]);
   }
@@ -130,7 +132,9 @@ export class InputManager {
    * @param {string} command - command name or shortcut
    */
   startCommand(command) {
-    if (this.activeCommand !== undefined) {
+    if (this.activeCommand instanceof Tool) {
+      this.activeCommand.cancel();
+    } else if (this.activeCommand !== undefined) {
       this.reset();
     }
 
@@ -195,6 +199,17 @@ export class InputManager {
    * @param {Point} point
    */
   onLeftClick(point) {
+    // Grip hit-test takes priority over normal entity selection when idle, so clicking a grip
+    // starts GripStretch (which requests the stretch point itself) instead of reselecting it
+    if (this.activeCommand === undefined) {
+      const grabbedGrip = DesignCore.Scene.selectionManager.findGripUnderMouse(DesignCore.Mouse.pointOnScene());
+      if (grabbedGrip) {
+        this.activeCommand = new GripStretch(grabbedGrip.entityIndex, grabbedGrip.grip);
+        this.activeCommand.execute();
+        return;
+      }
+    }
+
     // left clicks are used for selection of entities and points
     // Selection of entities can only occur if there is no active snap available
     // Selection of entities can only occur if the mouse is over an entity
@@ -281,8 +296,14 @@ export class InputManager {
       this.activeCommand.preview();
     }
 
-    // Only show hover glow when no command preview is occupying previewEntities
-    if (!snapped && DesignCore.Scene.previewEntities.count() === 0) {
+    // a command preview can coexist with an active selection prompt (e.g. a dimension
+    // previewing a point-based result while still accepting a second entity selection)
+    const canSelectEntity = this.promptOption?.types.includes(Input.Type.SINGLESELECTION) ||
+      this.promptOption?.types.includes(Input.Type.SELECTIONSET);
+
+    // Only show hover glow when no command preview is occupying previewEntities,
+    // unless the active prompt also accepts an entity selection
+    if (!snapped && (DesignCore.Scene.previewEntities.count() === 0 || canSelectEntity)) {
       this.highlightEntityUnderMouse();
     }
 

package/core/lib/mouse.js

@@ -15,6 +15,16 @@ export class Mouse {
     this.lastButton = 0; // last button for double click check
   }
 
+  /**
+   * Clear button state - guards against a stuck button when a mouseUp
+   * never reaches the canvas (e.g. focus stolen by another window mid-click)
+   */
+  reset() {
+    this.buttonOneDown = false;
+    this.buttonTwoDown = false;
+    this.buttonThreeDown = false;
+  }
+
   /**
    * Returns the point on the design canvas
    * @return {Point}