@design-core/core 51.2.0 → 52.0.0

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';
@@ -399,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
@@ -462,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"
 
@@ -70,7 +70,7 @@ const classes = {
   // Spline,
   ArcAlignedText,
   Text,
-  /*
+
   Dimension,
   AngularDimension,
   AlignedDimension,
@@ -78,7 +78,7 @@ const classes = {
   LinearDimension,
   RadialDimension,
   RotatedDimension,
-  */
+
   Block,
   Insert,
   Hatch,

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';
@@ -131,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();
     }
 
@@ -196,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
@@ -282,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/renderers/pdfRenderer.js

@@ -1,6 +1,16 @@
 import { RendererBase } from './rendererBase.js';
 import { Text } from '../../entities/text.js';
 
+// Unicode code points mapped to WinAnsi bytes 0x80-0x9F (the range where WinAnsi differs from Latin-1)
+const WIN_ANSI_EXTRAS = new Map([
+  [0x20ac, 0x80], [0x201a, 0x82], [0x0192, 0x83], [0x201e, 0x84], [0x2026, 0x85],
+  [0x2020, 0x86], [0x2021, 0x87], [0x02c6, 0x88], [0x2030, 0x89], [0x0160, 0x8a],
+  [0x2039, 0x8b], [0x0152, 0x8c], [0x017d, 0x8e], [0x2018, 0x91], [0x2019, 0x92],
+  [0x201c, 0x93], [0x201d, 0x94], [0x2022, 0x95], [0x2013, 0x96], [0x2014, 0x97],
+  [0x02dc, 0x98], [0x2122, 0x99], [0x0161, 0x9a], [0x203a, 0x9b], [0x0153, 0x9c],
+  [0x017e, 0x9e], [0x0178, 0x9f],
+]);
+
 /**
  * Pure-JS PDF renderer.
  * Implements the RendererBase interface by accumulating a PDF content stream in memory.
@@ -361,6 +371,12 @@ export class PdfRenderer extends RendererBase {
     return str
         .replace(/\\/g, '\\\\')
         .replace(/\(/g, '\\(')
-        .replace(/\)/g, '\\)');
+        .replace(/\)/g, '\\)')
+        // Keep output ASCII: map Unicode to WinAnsi (Windows-1252) bytes, unsupported characters become '?'
+        .replace(/[^\x00-\x7f]/g, (c) => {
+          const code = c.charCodeAt(0);
+          const byte = WIN_ANSI_EXTRAS.get(code) ?? (code >= 0xa0 && code <= 0xff ? code : 0x3f);
+          return '\\' + byte.toString(8).padStart(3, '0');
+        });
   }
 }

package/core/lib/scene.js

@@ -139,6 +139,7 @@ export class Scene {
   undo() {
     if (this.stateManager.canUndo()) {
       this.stateManager.undo();
+      this.selectionManager.reloadSelectedEntities();
       DesignCore.Canvas.requestPaint();
     } else {
       DesignCore.Core.notify(Strings.Message.NOUNDO);
@@ -151,6 +152,7 @@ export class Scene {
   redo() {
     if (this.stateManager.canRedo()) {
       this.stateManager.redo();
+      this.selectionManager.reloadSelectedEntities();
       DesignCore.Canvas.requestPaint();
     } else {
       DesignCore.Core.notify(Strings.Message.NOREDO);

package/core/lib/selectionManager.js

@@ -156,6 +156,34 @@ export class SelectionManager {
     return DesignCore.Scene.entities.findClosest(point);
   }
 
+  /**
+   * Find the grip closest to point, within tolerance, across all selected entities.
+   * Hit-tests against the real scene entities (not the selectedEntities preview clones) so a
+   * grip's apply() always recomputes from the last-committed geometry.
+   * @param {Point} point
+   * @return {Object|undefined} { entityIndex, grip } or undefined if no grip is close enough
+   */
+  findGripUnderMouse(point) {
+    const gripAperture = 25; // capture radius in pixels (screen space), matches Snapping's snapAperture
+    const delta = gripAperture / DesignCore.Canvas.getScale();
+
+    let closestGrip;
+    let closestDistance = delta;
+
+    for (const entityIndex of this.selectionSet.selectionSet) {
+      const entity = DesignCore.Scene.entities.get(entityIndex);
+      for (const grip of entity.getGrips()) {
+        const distance = grip.point.distance(point);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          closestGrip = { entityIndex, grip };
+        }
+      }
+    }
+
+    return closestGrip;
+  }
+
   /**
   * Remove the item at index from the selectionSet and selectedEntities
   * @param  {number} index - index of the item

package/core/lib/strings.js

@@ -116,5 +116,6 @@ export class Strings {
     SCALEFACTOR: 'Specify scale factor',
     REFERENCELENGTH: 'Specify reference length',
     NEWLENGTH: 'Specify new length',
+    STRETCHPOINT: 'Specify stretch point',
   };
 };

package/core/properties/dimType.js

@@ -99,6 +99,20 @@ export class DimType {
     this.userPositionedText = (dimType & 128) !== 0;
   }
 
+  /**
+   * Set only the base dimension type (0-6), leaving the block reference, ordinate and
+   * user-positioned-text flags untouched - used by subclass constructors to pin their type
+   * without clobbering flags already loaded from a DXF group 70 value
+   * @param {number} baseType
+   */
+  setBaseType(baseType) {
+    if (!DimType.isValidDimensionType(baseType)) {
+      baseType = 0;
+    }
+
+    this.dimType = DimType.getBaseType(baseType);
+  }
+
   /**
    * Check if the dimension has a block reference
    * @return {boolean} true if the dimension has a block reference

package/core/properties/property.js

@@ -112,6 +112,7 @@ export class Property {
     LEADERLENGTH: 'leaderLength',
     LINEARDIMANGLE: 'linearDimAngle',
     TEXTOVERRIDE: 'textOverride',
+    USERPOSITIONEDTEXT: 'userPositionedText',
   });
 
   /**

package/core/tables/dimStyle.js

@@ -1,5 +1,6 @@
 
 import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { DesignCore } from '../designCore.js';
 import { Logging } from '../lib/logging.js';
 import { Flags } from '../properties/flags.js';
 import { Property } from '../properties/property.js';
@@ -383,6 +384,8 @@ export class DimStyle {
 
     // DXF Groupcode 340 - (handle of referenced STYLE)
     this.DIMTXSTY = Property.loadValue([data.DIMTXSTY, data[340]], 'Standard');
+    // internal - true when DIMTXSTY holds a style handle (loaded from group 340) rather than a style name
+    this.DIMTXSTYISHANDLE = Property.loadValue([data.DIMTXSTYISHANDLE, data.DIMTXSTY === undefined && data[340] !== undefined], false);
 
     // DXF Groupcode 341 - (handle of referenced BLOCK)
     this.DIMLDRBLK = Property.loadValue([data.DIMLDRBLK, data[341]], 'ClosedFilled');
@@ -475,6 +478,9 @@ export class DimStyle {
 
     if (this.hasOwnProperty(valueName)) {
       this[valueName] = value;
+      if (valueName === 'DIMTXSTY') {
+        this.DIMTXSTYISHANDLE = false;
+      }
     } else {
       const err = `Setting Value - Property does not exist: ${valueName}`;
       Logging.instance.warn(`${this.type} - ${err}`);
@@ -544,6 +550,23 @@ export class DimStyle {
     this.DIMCENVALUE = Math.abs(value);
   }
 
+  /**
+   * Get the handle of the text style referenced by DIMTXSTY
+   * DIMTXSTY holds a style name, or a style handle when DIMTXSTYISHANDLE is set (loaded from a dxf file)
+   * @return {string} handle or undefined if no matching style exists
+   */
+  getTextStyleHandle() {
+    const styles = DesignCore.StyleManager.getItems();
+    const reference = String(this.DIMTXSTY).toUpperCase();
+
+    const style = styles.find((item) => this.DIMTXSTYISHANDLE ?
+      String(item.handle).toUpperCase() === reference :
+      item.name.toUpperCase() === reference) ??
+      styles.find((item) => item.name.toUpperCase() === 'STANDARD');
+
+    return style?.handle;
+  }
+
   /**
    * Write the entity to file in the dxf format
    * @param {DXFFile} file
@@ -616,8 +639,15 @@ export class DimStyle {
     file.writeGroupCode('287', this.DIMFIT);
     file.writeGroupCode('288', this.DIMUPT, DXFFile.Version.R13);
     file.writeGroupCode('289', this.DIMATFIT, DXFFile.Version.R2000);
-    file.writeGroupCode('340', this.DIMTXSTY, DXFFile.Version.R13);
-    file.writeGroupCode('341', this.DIMLDRBLK, DXFFile.Version.R2000);
+    // 340 and 341 are handles - writing a name leaves AutoCAD unable to resolve the text style (dimension text is not shown)
+    const textStyleHandle = this.getTextStyleHandle();
+    if (textStyleHandle !== undefined) {
+      file.writeGroupCode('340', textStyleHandle, DXFFile.Version.R13);
+    }
+    // 'ClosedFilled' is the default leader arrowhead and has no block handle, omitting the group selects it
+    if (this.DIMLDRBLK !== 'ClosedFilled') {
+      file.writeGroupCode('341', this.DIMLDRBLK, DXFFile.Version.R2000);
+    }
     // file.writeGroupCode('342', this.DIMBLK);
     // file.writeGroupCode('343', this.DIMBLK1);
     // file.writeGroupCode('344', this.DIMBLK2);