@design-core/core 0.0.1 → 0.0.3

package/core/entities/text.js

@@ -1,15 +1,25 @@
-import {Point} from './point.js';
-import {Utils} from '../lib/utils.js';
-import {Strings} from '../lib/strings.js';
-import {Entity} from './entity.js';
-import {Input, PromptOptions} from '../lib/inputManager.js';
-import {Logging} from '../lib/logging.js';
-import {DXFFile} from '../lib/dxf/dxfFile.js';
-import {BoundingBox} from '../lib/boundingBox.js';
-
-import {DesignCore} from '../designCore.js';
-
+import { Point } from './point.js';
+import { Utils } from '../lib/utils.js';
+import { Strings } from '../lib/strings.js';
+import { Entity } from './entity.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { BoundingBox } from '../lib/boundingBox.js';
+import { Flags } from '../properties/flags.js';
+import { Property } from '../properties/property.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Text Entity Class
+ * @extends Entity
+ */
 export class Text extends Entity {
+  /**
+   * Create a Text Entity
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
     this.string = '';
@@ -18,8 +28,7 @@ export class Text extends Entity {
     this.verticalAlignment = 0;
     this.styleName = 'STANDARD';
 
-
-    // hide inherited propertys
+    // hide inherited properties
     // needs to be enumerable=false to not appear in the object props
     Object.defineProperty(this, 'lineType', {
       enumerable: false,
@@ -39,13 +48,13 @@ export class Text extends Entity {
 
     // needs to be non-enumerable as to not appear in the object props
     Object.defineProperty(this, 'boundingRect', {
-      value: {width: 10, height: 10},
+      value: { width: 10, height: 10 },
       writable: true,
     });
 
     // needs to be non-enumerable as to not appear in the object props
     Object.defineProperty(this, 'flags', {
-      value: 0,
+      value: new Flags(),
       writable: true,
     });
 
@@ -67,67 +76,94 @@ export class Text extends Entity {
     });
 
     if (data) {
-      if (data.string || data[1]) {
-        // DXF Groupcode 1 - Default Value
-        // The string of the text entity
-        this.string = String(data.string || data[1]);
-      }
-
-      if (data.styleName || data[7]) {
-        // DXF Groupcode 7 - Text Style Name
-        this.styleName = data.styleName || data[7];
+      // DXF Groupcode 11,21,31 - Second alignment point (optional, used for aligned, middle, or fit text)
+      if (data?.points?.length > 1) {
+        if (data.points[1].sequence == 11) {
+          this.points = [];
+          this.points.push(new Point(data.points[1].x, data.points[1].y));
+        }
       }
+    }
 
-      if (data.height || data[40]) {
-        // DXF Groupcode 40 - Text Height
-        this.height = data.height || data[40];
-      }
+    // DXF Groupcode 1 - Text String
+    this.string = Property.loadValue([data?.string, data?.[1]], '');
+    // DXF Groupcode 7 - Text Style Name
+    this.styleName = Property.loadValue([data?.styleName, data?.[7]], 'STANDARD');
+    // DXF Groupcode 40 - Text Height
+    this.height = Property.loadValue([data?.height, data?.[40]], 2.5);
 
-      if (data.rotation || data[50]) {
+    if (data) {
+      if (data.hasOwnProperty('rotation') || data.hasOwnProperty('50')) {
         // DXF Groupcode 50 - Text Rotation, angle in degrees
         // if we get rotation data store this as a point[1] at an angle from point[0]
         // this allows all the entities to be rotated by rotating the points i.e. not all entities have a rotation property
-
-        const rotation = data.rotation || data[50];
-        this.setRotation(rotation);
+        this.setRotation(Property.loadValue([data.rotation, data[50]], 0));
       } else {
         // create points[1] used to determine the text rotation
-        this.points[1] = data.points[0].add(new Point(this.height, 0));
+        if (this.points.length && this.height !== undefined) {
+          this.points[1] = this.points[0].add(new Point(this.height, 0));
+        }
       }
+    }
 
-      if (data.horizontalAlignment || data[72]) {
-        // DXF Groupcode 72 - Horizontal Alignment
-        // 0 = Left; 1= Center; 2 = Right
-        // 3 = Aligned (if vertical alignment = 0)
-        // 4 = Middle (if vertical alignment = 0)
-        // 5 = Fit (if vertical alignment = 0)
-        this.horizontalAlignment = data.horizontalAlignment || data[72];
-      }
+    // DXF Groupcode 72 - Horizontal Alignment
+    // 0 = Left
+    // 1 = Center
+    // 2 = Right
+    // 3 = Aligned (if vertical alignment = 0) not supported, treated as center aligned
+    // 4 = Middle (if vertical alignment = 0) not supported, treated as center aligned
+    // 5 = Fit (if vertical alignment = 0) not supported, treated as center aligned
+    this.horizontalAlignment = Property.loadValue([data?.horizontalAlignment, data?.[72]], 0);
+
+    if (this.horizontalAlignment > 2) {
+      this.horizontalAlignment = 1; // unsupported alignment types treated as center aligned
+    }
 
-      if (data.verticalAlignment || data[73]) {
-        // DXF Groupcode 73 - Vertical Alignment
-        // 0 = Baseline; 1 = Bottom; 2 = Middle; 3 = Top
-        this.verticalAlignment = data.verticalAlignment || data[73];
-      }
+    // DXF Groupcode 73 - Vertical Alignment
+    // 0 = Baseline; 1 = Bottom; 2 = Middle; 3 = Top
+    this.verticalAlignment = Property.loadValue([data?.verticalAlignment, data?.[73]], 0);
 
-      if (data.flags || data[71]) {
-        // DXF Groupcode 71 - flags (bit-coded values):
-        // 2 = Text is backward (mirrored in X).
-        // 4 = Text is upside down (mirrored in Y).
-        this.flags = data.flags || data[71];
-      }
-    }
+    // DXF Groupcode 71 - flags (bit-coded values):
+    // 2 = Text is backward (mirrored in X).
+    // 4 = Text is upside down (mirrored in Y).
+    this.flags.setFlagValue(Property.loadValue([data?.flags, data?.[71]], 0));
   }
 
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
   static register() {
-    const command = {command: 'Text', shortcut: 'DT', type: 'Entity'};
+    const command = { command: 'Text', shortcut: 'DT', type: 'Entity' };
     return command;
   }
 
+  /**
+   * Get the approximate width of the text
+   * @param {string} string - text string
+   * @param {number} textHeight - text height
+   * @return {number} - approximate width of the text
+   * This is a rough estimate based on the string length and height
+   * Actual width depends on the font and style used
+   */
+  static getApproximateWidth(string, textHeight) {
+    // Approximate width of the text based on the string length and height
+    // This is a rough estimate, as actual width depends on the font and style
+    return string.length * textHeight * 0.6; // 0.6 is an approximation factor for average character width
+  }
+
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to create an entity
+   */
   async execute() {
     try {
       const op = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
       const pt1 = await DesignCore.Scene.inputManager.requestInput(op);
+      if (pt1 === undefined) return;
       this.points.push(pt1);
 
       // set the text style to the current style
@@ -135,27 +171,41 @@ export class Text extends Entity {
       this.styleName = currentStyle;
 
       // get properties from style
-      const style = DesignCore.StyleManager.getStyleByName(this.styleName);
-      if (style.textHeight) {
+      const style = DesignCore.StyleManager.getItemByName(this.styleName);
+      if (style?.textHeight) {
         this.height = style.textHeight;
       }
 
       this.backwards = style.backwards;
       this.upsideDown = style.upsideDown;
 
-      // Get the font size when standard style is used
-      if (this.styleName.toUpperCase() === 'STANDARD') {
-        const op2 = new PromptOptions(`${Strings.Input.HEIGHT} <${this.height}>`, [Input.Type.NUMBER]);
-        const height = await DesignCore.Scene.inputManager.requestInput(op2);
-        this.height = height;
+      // Get the font size when the style has a variable height (textHeight === 0)
+      if (!style?.textHeight) {
+        const op2 = new PromptOptions(Strings.Input.HEIGHT, [Input.Type.NUMBER], [], this.height);
+        while (true) {
+          const height = await DesignCore.Scene.inputManager.requestInput(op2);
+          if (height === undefined) return;
+          if (height <= 0) {
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.NONZERO}`);
+            continue;
+          }
+          this.height = height;
+          break;
+        }
       }
 
-      const op3 = new PromptOptions(`${Strings.Input.ROTATION} <0>`, [Input.Type.NUMBER]);
+      const op3 = new PromptOptions(Strings.Input.ROTATION, [Input.Type.NUMBER], [], 0);
       const rotation = await DesignCore.Scene.inputManager.requestInput(op3);
+      if (rotation === undefined) return;
       this.setRotation(rotation);
 
       const op4 = new PromptOptions(Strings.Input.STRING, [Input.Type.STRING, Input.Type.NUMBER]);
       const string = await DesignCore.Scene.inputManager.requestInput(op4);
+      if (string === undefined) return;
+      if (String(string).trim().length === 0) {
+        DesignCore.Scene.inputManager.reset();
+        return;
+      }
       this.string = String(string);
 
       DesignCore.Scene.inputManager.executeCommand(this);
@@ -164,6 +214,9 @@ export class Text extends Entity {
     }
   }
 
+  /**
+   * Preview the entity during creation
+   */
   preview() {
     if (this.points.length >= 1) {
       if (DesignCore.Scene.inputManager.promptOption.types.includes(Input.Type.STRING)) {
@@ -171,14 +224,15 @@ export class Text extends Entity {
           points: this.points,
           height: this.height,
           rotation: this.rotation,
+          styleName: this.styleName,
           string: DesignCore.CommandLine.command,
         };
 
-        DesignCore.Scene.createTempItem(this.type, data);
+        DesignCore.Scene.tempEntities.create(this.type, data);
       } else {
         const mousePoint = DesignCore.Mouse.pointOnScene();
         const points = [this.points.at(-1), mousePoint];
-        DesignCore.Scene.createTempItem('Line', {points: points});
+        DesignCore.Scene.tempEntities.create('Line', { points: points });
       }
     }
   }
@@ -194,7 +248,7 @@ export class Text extends Entity {
       return;
     }
 
-    if (this.height > 0 && angle !== 0) {
+    if (this.height > 0) {
       this.points[1] = this.points[0].project(Utils.degrees2radians(angle), this.height);
     }
   }
@@ -214,11 +268,11 @@ export class Text extends Entity {
 
   /**
    * Get the backwards value
-   * @returns {boolean} true if the text is flipped horizontally
+   * @return {boolean} true if the text is flipped horizontally
    */
   getBackwards() {
     // Backwards value is bitmasked in flags as value 2
-    return Boolean(this.flags & 2);
+    return this.flags.hasFlag(2);
   }
 
   /**
@@ -228,20 +282,20 @@ export class Text extends Entity {
   setBackwards(bool) {
     if (bool) {
       // Add flag
-      this.flags = (this.flags | 2);
+      this.flags.addValue(2);
     } else {
       // remove flag
-      this.flags = (this.flags ^ (this.flags & 2));
+      this.flags.removeValue(2);
     }
   }
 
   /**
    * Get the upside down value
-   * @returns {boolean} true if the text is flipped vertically
+   * @return {boolean} true if the text is flipped vertically
    */
   getUpsideDown() {
     // Upside down value is bitmasked in flags as value 4
-    return Boolean(this.flags & 4);
+    return this.flags.hasFlag(4);
   }
 
   /**
@@ -251,16 +305,16 @@ export class Text extends Entity {
   setUpsideDown(bool) {
     if (bool) {
       // Add flag
-      this.flags = (this.flags | 4);
+      this.flags.addValue(4);
     } else {
       // remove flag
-      this.flags = (this.flags ^ (this.flags & 4));
+      this.flags.removeValue(4);
     }
   }
 
   /**
    * Get a string describing the horizontal text alignment
-   * @returns {string}
+   * @return {string}
    */
   getHorizontalAlignment() {
     /* DXF Data
@@ -290,7 +344,7 @@ export class Text extends Entity {
 
   /**
    * Get a string describing the vertical text alignment
-   * @returns {string}
+   * @return {string}
    */
   getVerticalAlignment() {
     /* DXF Data
@@ -313,177 +367,266 @@ export class Text extends Entity {
     }
   }
 
+  /**
+   * Get the texts bounding rectangle
+   * @return {Object}
+   */
   getBoundingRect() {
-    const rect = {width: Number(this.boundingRect.width), height: Number(this.boundingRect.height), x: this.points[0].x, y: this.points[0].y};
+    const rect = { width: Number(this.boundingRect.width), height: Number(this.boundingRect.height), x: this.points[0].x, y: this.points[0].y };
     return rect;
   }
 
+  /**
+   * Draw the entity
+   * @param {Object} ctx - context
+   * @param {number} scale
+   */
   draw(ctx, scale) {
-    ctx.save();
+    if (this.string.length === 0) {
+      return;
+    }
+
+    ctx.save(); // save current context before scale and translate
     ctx.scale(1, -1);
-    ctx.translate(this.points[0].x, -this.points[0].y);
+    const corners = this.getTextFrameCorners();
+    const bottomLeft = corners[0];
+    ctx.translate(bottomLeft.x, -bottomLeft.y);
 
-    const style = DesignCore.StyleManager.getStyleByName(this.styleName);
-    // style.textHeight
+    const style = DesignCore.StyleManager.getItemByName(this.styleName);
+    const rotation = Utils.degrees2radians(this.rotation);
+    ctx.rotate(-rotation);
 
     if (this.upsideDown) {
+      const upsideDownOffset = corners[0].distance(corners[3]);
+      ctx.translate(0, -upsideDownOffset);
       ctx.scale(1, -1);
     }
 
     if (this.backwards) {
+      const backwardsOffset = corners[0].distance(corners[1]);
+      ctx.translate(backwardsOffset, 0);
       ctx.scale(-1, 1);
     }
 
-    const rotation = Utils.degrees2radians(this.rotation);
-
-    if (this.backwards || this.upsideDown) {
-      ctx.rotate(rotation);
-    } else {
-      ctx.rotate(-rotation);
-    }
-
     try { // HTML
-      ctx.textAlign = this.getHorizontalAlignment();
-      ctx.textBaseline = this.getVerticalAlignment();
-      ctx.font = this.height + 'pt Arial'; // +DesignCore.StyleManager.getStyleByName(this.styleName).font.toString();
+      ctx.font = this.height + 'pt ' + style.font;
       ctx.fillText(this.string, 0, 0);
-      this.boundingRect = ctx.measureText(String(this.string));
       // TODO: find a better way to define the boundingRect
-      this.boundingRect.height = this.height;
+      const metrics = ctx.measureText(String(this.string));
+      this.boundingRect = { width: metrics.width, height: this.height };
     } catch { // Cairo
-      ctx.setFontSize(this.height);
       ctx.selectFontFace(style.font, null, null); // (FontName, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL);
-      this.boundingRect = ctx.textExtents(String(this.string));
-
-      // console.log(this.boundingRect);
-
-      let x = 0;
-      let y = 0;
-      switch (this.horizontalAlignment) {
-        case 0: // 0 = Left;
-          x = -this.boundingRect.xBearing;
-          break;
-        case 1: // 1= Center;
-          x = -this.boundingRect.xBearing-this.boundingRect.width / 2;
-          break;
-        case 2: // 2 = Right
-          x = -this.boundingRect.xBearing-this.boundingRect.width;
-          break;
-      }
-
-      switch (this.verticalAlignment) {
-        case 0: // 0 = Baseline;
-          y = 0;
-          break;
-        case 1: // 1 = Bottom;
-          y = -this.boundingRect.yBearing - this.boundingRect.height;
-          break;
-        case 2: // 2 = Middle
-          y = -this.boundingRect.yBearing - this.boundingRect.height / 2;
-          break;
-        case 3: // 3 = Top
-          y = -this.boundingRect.yBearing;
-          break;
-      }
 
+      // Hack to test the text height vs bounding box height to find a scale factor to make the drawn text match the specified height.
+      // This is needed because Cairo's font size is not the same as the actual drawn text height, and can vary based on the font used.
+      // This is a rough approximation and may not be accurate for all fonts or sizes.
+      ctx.setFontSize(this.height);
+      const drawTextRect = ctx.textExtents(String(this.string));
+
+      /* GJS Cairo needs additional support for font handling
+      https://www.cairographics.org/tutorial/#L1understandingtext
+      https://www.cairographics.org/manual/cairo-cairo-scaled-font-t.html#cairo-font-extents-t
+
+      This needs to be implemented in GJS:
+      https://gitlab.gnome.org/GNOME/gjs/-/blob/master/modules/cairo-context.cpp?ref_type=heads#L773
+      https://gitlab.gnome.org/GNOME/gjs/-/blob/master/modules/cairo-context.cpp?ref_type=heads#L780
+      */
+      // Adjust the font size by the ratio of the desired height to the drawn height to get closer to the desired text height.
+      ctx.setFontSize(this.height * this.height / drawTextRect.height);
+      this.boundingRect = ctx.textExtents(String(this.string));
 
-      ctx.moveTo(x, y);
       ctx.showText(String(this.string));
     }
+
     ctx.stroke();
-    ctx.restore();
+    ctx.restore(); // restore context before scale and translate
 
-    // Draw Bounding Box to test the getBoundingRect()
     /*
-        ctx.strokeStyle = colour;
-        ctx.lineWidth = 1 / scale;
-        ctx.beginPath()
-        ctx.moveTo(rect.x, rect.y);
-        ctx.lineTo(rect.x + rect.width, rect.y);
-        ctx.lineTo(rect.x + rect.width, rect.y + rect.height);
-        ctx.lineTo(rect.x, rect.y + rect.height);
-        ctx.lineTo(rect.x, rect.y);
-        ctx.stroke()
-        */
+    // debug draw the bounding box
+    const bb = this.boundingBox();
+    ctx.moveTo(bb.xMin, bb.yMin);
+    ctx.lineTo(bb.xMax, bb.yMin);
+    ctx.lineTo(bb.xMax, bb.yMax);
+    ctx.lineTo(bb.xMin, bb.yMax);
+    ctx.lineTo(bb.xMin, bb.yMin);
+    ctx.stroke();
+
+    // debug draw the text frame
+    const frameCorners = this.getTextFrameCorners();
+    ctx.moveTo(frameCorners[0].x, frameCorners[0].y);
+    ctx.lineTo(frameCorners[1].x, frameCorners[1].y);
+    ctx.lineTo(frameCorners[2].x, frameCorners[2].y);
+    ctx.lineTo(frameCorners[3].x, frameCorners[3].y);
+    ctx.lineTo(frameCorners[0].x, frameCorners[0].y);
+    ctx.stroke();
+    */
   }
 
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
   dxf(file) {
     file.writeGroupCode('0', 'TEXT');
-    file.writeGroupCode('5', file.nextHandle(), DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     file.writeGroupCode('8', this.layer);
     file.writeGroupCode('100', 'AcDbText', DXFFile.Version.R2000);
-    file.writeGroupCode('10', this.points[0].x);
-    file.writeGroupCode('20', this.points[0].y);
+
+    const frameCorners = this.getTextFrameCorners();
+    const bottomLeft = frameCorners[0];
+
+    file.writeGroupCode('10', bottomLeft.x);
+    file.writeGroupCode('20', bottomLeft.y);
     file.writeGroupCode('30', '0.0');
+
     file.writeGroupCode('40', this.height);
     file.writeGroupCode('1', this.string);
     file.writeGroupCode('50', this.rotation);
     // file.writeGroupCode('7', 'STANDARD'); // TEXT STYLE
-    file.writeGroupCode('71', this.flags); // Text generation flags
+    file.writeGroupCode('71', this.flags.getFlagValue()); // Text generation flags
     file.writeGroupCode('72', this.horizontalAlignment); // Horizontal alignment
+
+    if (this.horizontalAlignment > 0 || this.verticalAlignment > 0) {
+      file.writeGroupCode('11', this.points[0].x);
+      file.writeGroupCode('21', this.points[0].y);
+      file.writeGroupCode('31', '0.0');
+    }
+
     file.writeGroupCode('100', 'AcDbText', DXFFile.Version.R2000);
-    file.writeGroupCode('73', this.verticalAlignment); // Vertical alignment
+    if (this.verticalAlignment !== 0) {
+      file.writeGroupCode('73', this.verticalAlignment); // Vertical alignment
+    }
   }
 
+  /**
+   * Get snap points
+   * @param {Point} mousePoint
+   * @param {number} delta
+   * @return {Array} - array of snap points
+   */
   snaps(mousePoint, delta) {
-    const rect = this.getBoundingRect();
-
-    const botLeft = new Point(rect.x, rect.y);
-    const botRight = new Point(rect.x + rect.width, rect.y);
-    const topLeft = new Point(rect.x, rect.y + rect.height);
-    const topRight = new Point(rect.x + rect.width, rect.y + rect.height);
-    const mid = new Point(rect.x + rect.width / 2, rect.y + rect.height / 2);
-
-    const snaps = [botLeft, botRight, topLeft, topRight, mid];
+    const frameCorners = this.getTextFrameCorners();
+    const mid = frameCorners[0].midPoint(frameCorners[2]);
+    const snaps = [...frameCorners, mid];
+
+    // add insertion point if not already in snaps
+    // this adds an extra snap point when alignment != 0.
+    if (!snaps.some((point) => point.isSame(this.points[0]))) {
+      snaps.push(this.points[0]);
+    }
 
     return snaps;
   }
 
+  /**
+   * Get closest point on entity
+   * @param {Point} P
+   * @return {Array} - [Point, distance]
+   */
   closestPoint(P) {
-    // TODO: Support rotation
-    const rect = this.getBoundingRect();
-    const botLeft = new Point(rect.x, rect.y);
-    const topRight = new Point(rect.x + rect.width, rect.y + rect.height);
-    const mid = new Point(rect.x + rect.width / 2, rect.y + rect.height / 2);
+    const frameCorners = this.getTextFrameCorners();
+    const A = frameCorners[0];
+    const B = frameCorners[1];
+    const C = frameCorners[2];
+    const D = frameCorners[3];
 
+    const mid = A.midPoint(C);
     let distance = P.distance(mid);
 
-    // if P is inside the bounding box return distance 0
-    if (P.x > botLeft.x &&
-            P.x < topRight.x &&
-            P.y > botLeft.y &&
-            P.y < topRight.y
-    ) {
+    if (P.isInRectangle(A, B, C, D)) {
       distance = 0;
     }
 
     return [mid, distance];
   }
 
-  boundingBox() {
+  /**
+   * Get the corner points of a frame around the text (Tight bounding box)
+   * @return {Array} - array of 4 Points defining the text frame corners. Ordered: [bottomLeft, bottomRight, topRight, topLeft]
+   */
+  getTextFrameCorners() {
     const rect = this.getBoundingRect();
 
-    const xmin = rect.x;
-    const xmax = rect.x + rect.width;
-    const ymin = rect.y;
-    const ymax = rect.y + rect.height;
+    let offsetX = 0;
+    switch (this.horizontalAlignment) {
+      case 0: // left
+        offsetX = 0;
+        break;
+      case 1: // center
+        offsetX = -rect.width / 2;
+        break;
+      case 2: // right
+        offsetX = -rect.width;
+        break;
+      case 3: // aligned - not supported
+      case 4: // middle - not supported
+      case 5: // fit - not supported
+      default:
+        offsetX = 0;
+    }
 
-    const topLeft = new Point(xmin, ymax);
-    const bottomRight = new Point(xmax, ymin);
+    let offsetY = 0;
+    switch (this.verticalAlignment) {
+      case 0: // baseline
+        offsetY = 0; // see comments in draw method
+        break;
+      case 1: // bottom
+        offsetY = 0;
+        break;
+      case 2: // middle
+        offsetY = -rect.height / 2;
+        break;
+      case 3: // top
+        offsetY = -rect.height;
+        break;
+      default:
+        offsetY = 0;
+    }
 
-    return new BoundingBox(topLeft, bottomRight);
-  }
+    // apply offsets to insertion point
+    const x0 = rect.x + offsetX;
+    const y0 = rect.y + offsetY;
+
+    // compute min/max depending on backwards/upsideDown (text direction)
+    const xmin = Math.min(x0, this.backwards ? x0 - rect.width : x0 + rect.width);
+    const xmax = Math.max(x0, this.backwards ? x0 - rect.width : x0 + rect.width);
+    const ymin = Math.min(y0, this.upsideDown ? y0 - rect.height : y0 + rect.height);
+    const ymax = Math.max(y0, this.upsideDown ? y0 - rect.height : y0 + rect.height);
+
+    let bottomLeft = new Point(xmin, ymin);
+    let bottomRight = new Point(xmax, ymin);
+    let topLeft = new Point(xmin, ymax);
+    let topRight = new Point(xmax, ymax);
+
+    if (this.rotation !== 0) {
+      const angle = Utils.degrees2radians(this.rotation);
+      bottomLeft = bottomLeft.rotate(this.points[0], angle);
+      bottomRight = bottomRight.rotate(this.points[0], angle);
+      topLeft = topLeft.rotate(this.points[0], angle);
+      topRight = topRight.rotate(this.points[0], angle);
+    }
 
-  intersectPoints() {
-    const rect = this.getBoundingRect();
+    return [bottomLeft, bottomRight, topRight, topLeft];
+  }
 
-    const botLeft = new Point(rect.x, rect.y);
-    const topRight = new Point(rect.x + rect.width, rect.y + rect.height);
+  /**
+   * Return boundingbox for entity
+   * @return {BoundingBox}
+   */
+  boundingBox() {
+    const bb = BoundingBox.fromPoints(this.getTextFrameCorners());
+    return bb;
+  }
 
-    return {
-      start: botLeft,
-      end: topRight,
-    };
+  /**
+   * Return a list of points representing a polyline version of this entity
+   * @return {Array}
+   */
+  toPolylinePoints() {
+    const corners = this.getTextFrameCorners();
+    // Close the rectangle
+    corners.push(corners[0].clone());
+    return corners;
   }
 }