@design-core/core 0.0.1 → 0.0.3

package/core/lib/promptOptions.js

@@ -0,0 +1,133 @@
+import { DesignCore } from '../designCore.js';
+import { Strings } from './strings.js';
+import { Input } from './input.js';
+
+/** PromptOptions Class */
+export class PromptOptions {
+  /**
+   * Create PromptOptions
+   * @param {string} promptMessage
+   * @param {Array} types
+   * @param {Array} options
+   * @param {any} defaultValue
+   * @param {string|null} cursor
+   */
+  constructor(promptMessage = 'error', types = [], options = [], defaultValue = undefined, cursor = null) {
+    this.promptMessage = promptMessage;
+    this.types = types;
+    this.options = options;
+    this.defaultValue = defaultValue;
+    this.cursor = cursor;
+    this.resolve = undefined;
+    this.reject = undefined;
+  }
+
+  /**
+   * Check if the input matches the accepted types
+   * @param {any} input
+   * @return {boolean}
+   */
+  acceptsInput(input) {
+    const inputType = Input.getType(input);
+    if (this.types.includes(inputType)) return true;
+    if (this.types.includes(Input.Type.DYNAMIC) && !isNaN(input)) return true;
+    return false;
+  }
+
+  /**
+   * Create a new promise for this prompt
+   * @return {Promise}
+   */
+  createPromise() {
+    return new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+
+  /**
+   * Return data to the input request
+   * @param {any} input
+   * @return {boolean} true if input was accepted
+   */
+  respond(input) {
+    if (this.acceptsInput(input)) {
+      this.resolve(input);
+      return true;
+    }
+
+    const matchedOption = this.parseInputToOption(input);
+    if (matchedOption !== undefined) {
+      this.resolve(matchedOption);
+      return true;
+    }
+
+    DesignCore.Core.notify(`${Strings.Error.INPUT}: ${this.promptMessage}`);
+    return false;
+  }
+
+  /**
+   * Match the input to a command option
+   * @param {any} input
+   * @return {string} undefined or the matched option
+   */
+  parseInputToOption(input) {
+    // no options to match
+    if (this.options.length === 0) {
+      return;
+    }
+
+    // can't match non-string values to options
+    if (typeof input !== 'string') {
+      return;
+    }
+
+    // loop through options to find a match
+    for (let i = 0; i < this.options.length; i++) {
+      const option = this.options[i];
+      // convert the option to uppercase and substring to the input length for comparison
+      const optionSubstring = option.toUpperCase().substring(0, input.length);
+      if (optionSubstring === input.toUpperCase()) {
+        return option;
+      }
+    }
+
+    return;
+  }
+
+  /**
+   * Cancel the input request by resolving with undefined
+   */
+  cancel() {
+    if (this.resolve) {
+      this.resolve(undefined);
+    }
+  }
+
+  /**
+   * Return the prompt for the input request
+   * @return {string}
+   */
+  getPrompt() {
+    let msg = `${this.promptMessage}`;
+    if (this.options.length) {
+      // Add \u0332 after the first letter of each option to include underscore
+      const optionsWithShortcut = this.options.map((option) => this.getOptionWithShortcut(option));
+      msg = `${this.promptMessage} ${Strings.Strings.OR} [${optionsWithShortcut}]`;
+    }
+    if (this.defaultValue !== undefined) {
+      msg = `${msg} <${this.defaultValue}>`;
+    }
+    return msg;
+  }
+
+  /**
+   * Underline the shortcut key for the prompt option
+   * @param {string} option
+   * @return {string} option with shortcut underlined
+   */
+  getOptionWithShortcut(option) {
+    const optionWithShortcut = `${option.substring(0, 1)}\u0332${option.substring(1, option.length)}`;
+    return optionWithShortcut;
+  }
+}

package/core/lib/scene.js

@@ -1,80 +1,76 @@
-import {SelectionManager} from './selectionManager.js';
-import {Logging} from './logging.js';
-import {Strings} from './strings.js';
-import {InputManager} from './inputManager.js';
-import {DXFFile} from './dxf/dxfFile.js';
-import {BoundingBox} from './boundingBox.js';
-import {Point} from '../entities/point.js';
-
-import {DesignCore} from '../designCore.js';
-
+import { SelectionManager } from './selectionManager.js';
+import { Logging } from './logging.js';
+import { Strings } from './strings.js';
+import { InputManager } from './inputManager.js';
+import { BoundingBox } from './boundingBox.js';
+import { EntityManager } from './entityManager.js';
+import { Headers } from './headers.js';
+
+import { DesignCore } from '../designCore.js';
+import { BlockManager } from '../tables/blockManager.js';
+import { AddState, StateManager, UpdateState } from './stateManager.js';
+
+/**
+ * Scene Class
+ * Holds all entity instances
+ */
 export class Scene {
+  /** Create a Scene */
   constructor() {
     // initialise the scene variables
     this.saved = false;
 
-    this.items = []; // Main array that stores all the geometry
-    this.tempItems = []; // Temporary Array to store items while input is being gathered
-    this.auxiliaryItems = []; // Auxiliary items such as the selection window and snap points
-
     this.selectionManager = new SelectionManager();
     this.inputManager = new InputManager();
+    this.blockManager = new BlockManager();
+
+    this.entities = new EntityManager();
+    this.tempEntities = new EntityManager(false);
+    this.auxiliaryEntities = new EntityManager(false);
 
-    // store the version of dxf that is currently being used
-    this.dxfVersion = 'R2018';
+    this.stateManager = new StateManager();
+
+    this.headers = new Headers();
   }
 
   /**
-   * Reset the scene
+   * Sets the save state following scene changes
    */
+  get isModified() {
+    return this.stateManager.isModified;
+  }
+
+
+  /** Clear the scene of all items */
+  clear() {
+    this.entities.clear();
+    this.tempEntities.clear();
+    this.auxiliaryEntities.clear();
+  }
+
+  /** Reset the scene */
   reset() {
-    this.tempItems = [];
-    this.auxiliaryItems = [];
+    this.tempEntities.clear();
+    this.auxiliaryEntities.clear();
     this.selectionManager.reset();
     DesignCore.Canvas.requestPaint();
   }
 
   /**
    * Get the scene bounding box
-   * @returns scene bounding box
+   * @return {BoundingBox} scene bounding box
    */
   boundingBox() {
-    let xmin; let xmax; let ymin; let ymax;
-
-    if (this.items.length === 0) {
-      return;
-    }
-
-    for (let i = 0; i < this.items.length; i++) {
-      const itemBoundingBox = this.items[i].boundingBox();
-
-      xmin = Math.min(xmin || Infinity, itemBoundingBox.xMin);
-      xmax = Math.max(xmax || -Infinity, itemBoundingBox.xMax);
-      ymin = Math.min(ymin || Infinity, itemBoundingBox.yMin);
-      ymax = Math.max(ymax || -Infinity, itemBoundingBox.yMax);
-    }
-
-    // if all values are zero return undefined
-    if (xmin === 0 && xmax === 0, ymin === 0, ymax === 0) {
-      return;
-    }
-
-    return new BoundingBox(new Point(xmin, ymin), new Point(xmax, ymax));
-  }
-
-  /**
-   * Sets the save state following scene changes
-   */
-  saveRequired() {
-    this.saved = false; // Changes have occured. A save may be required.
+    const boundingBox = BoundingBox.fromEntities(this.entities.getAll());
+    return boundingBox;
   }
 
   /**
    * Create and add new items to the scene
    * @param {string} type - entity type
-   * @param {object} data - object of entity parameters
+   * @param {Object} data - object of entity parameters
    * @param {number} index - integer of item to replace
-   * @returns - index of created item
+   * @return {number} - index of created item
    */
   addItem(type, data, index) {
     // TODO: validate data is valid for type
@@ -92,12 +88,15 @@ export class Scene {
     const item = DesignCore.CommandManager.createNew(type, data);
 
     if (typeof index === 'undefined') {
-      // add to end of array
-      this.items.push(item); // add item to the scene
-      index = this.items.length - 1;
+      // add item to the scene
+      const stateChange = new AddState(item);
+      this.commit([stateChange]);
+      index = this.entities.count() - 1;
     } else {
       // replace item at index
-      this.items.splice(index, 1, item);
+      const existingItem = this.entities.get(index);
+      const stateChange = new UpdateState(existingItem, data);
+      this.commit([stateChange]);
     }
 
     // return the index of the added item
@@ -105,136 +104,34 @@ export class Scene {
   }
 
   /**
-   * Find items in scene
-   * @param {string} type - entity type
-   * @param {string} prop - object of entity parameters
-   * @param {any} value - value of the property
-   * @returns - index of items
-   */
-  findItem(type, prop, value) {
-    const filteredItems = [];
-
-    this.items.forEach((item, index) => {
-      if (item.type.toUpperCase() === type.toUpperCase() && item.hasOwnProperty(prop) && item[prop] === value) {
-        filteredItems.push(index);
-      }
-    });
-
-    return filteredItems;
-  }
-
-  /**
-   * Get Item
-   * @param {number} type - items index
-   * @returns - item
+   * Commit state changes to the scene
+   * @param {Array} stateChanges
    */
-  getItem(index) {
-    return this.items[index];
+  commit(stateChanges) {
+    this.stateManager.commit(this.entities, stateChanges);
   }
 
   /**
-   * Remove Item
-   * @param {number} type - items index
-   * @returns - success status
+   * Undo the last action
    */
-  removeItem(index) {
-    const count = this.items.length;
-    this.items.splice(index, 1);
-
-    if (this.items.length < count) {
-      return true;
+  undo() {
+    if (this.stateManager.canUndo()) {
+      this.stateManager.undo();
+      DesignCore.Canvas.requestPaint();
+    } else {
+      DesignCore.Core.notify(Strings.Message.NOUNDO);
     }
-
-    return false;
-  }
-
-  /**
-   * Add items to the scenes tempItems
-   * @param {object} item
-   */
-  addToTempItems(item) {
-    this.tempItems.push(item); // Add it to the tempItems Array
-  }
-
-  /**
-   * Add items to the scenes auxiliary items
-   * @param {object} item
-   */
-  addToAuxiliaryItems(item) {
-    this.auxiliaryItems.push(item); // Add it to the auxiliary Array
   }
 
   /**
-   * Create a new temp item and add to scenes tempItems
-   * @param {string} type - entity type
-   * @param {object} data - object of entity parameters
+   * Redo the last undone action
    */
-  createTempItem(type, data) {
-    const helper = DesignCore.CommandManager.createNew(type, data);
-    this.addToTempItems(helper);
-  }
-
-  dxf(file) {
-    let width = 0;
-    let height = 0;
-    let viewCenterX = 0;
-    let viewCenterY = 0;
-    let ratio = 0;
-
-    const extents = this.boundingBox();
-
-    if (extents) {
-      width = extents.xLength;
-      height = extents.yLength;
-      viewCenterX = extents.xMin + width / 2;
-      viewCenterY = extents.yMin + height / 2;
-      ratio = width / height;
+  redo() {
+    if (this.stateManager.canRedo()) {
+      this.stateManager.redo();
+      DesignCore.Canvas.requestPaint();
+    } else {
+      DesignCore.Core.notify(Strings.Message.NOREDO);
     }
-
-    file.writeGroupCode('0', 'TABLE');
-    file.writeGroupCode('2', 'VPORT'); // Table Name
-    file.writeGroupCode('5', file.nextHandle(), DXFFile.Version.R2000); // Handle
-    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
-    file.writeGroupCode('70', '1'); // Number of entries in table
-    file.writeGroupCode('0', 'VPORT');
-    file.writeGroupCode('5', file.nextHandle(), DXFFile.Version.R2000); // Handle
-    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
-    file.writeGroupCode('100', 'AcDbViewportTableRecord', DXFFile.Version.R2000);
-    file.writeGroupCode('2', '*ACTIVE');
-    file.writeGroupCode('70', '0'); // vport flags
-    file.writeGroupCode('10', '0.0'); // lower left corner x pos
-    file.writeGroupCode('20', '0.0'); // lower left corner y pos
-    file.writeGroupCode('11', '1.0'); // upper right corner x pos
-    file.writeGroupCode('21', '1.0'); // upper right corner y pos
-    file.writeGroupCode('12', viewCenterX); // view centre x pos
-    file.writeGroupCode('22', viewCenterY); // view centre y pos
-    file.writeGroupCode('13', '0.0'); // snap base point x
-    file.writeGroupCode('23', '0.0'); // snap base point y
-    file.writeGroupCode('14', '10.0'); // snap spacing x
-    file.writeGroupCode('24', '10.0'); // snap spacing y
-    file.writeGroupCode('15', '10.0'); // grid spacing x
-    file.writeGroupCode('25', '10.0'); // grid spacing y
-    file.writeGroupCode('16', '0.0'); // view direction (x) from target point
-    file.writeGroupCode('26', '0.0'); // view direction (y) from target point
-    file.writeGroupCode('36', '1.0'); // view direction (z) from target point
-    file.writeGroupCode('17', '0.0'); // view target point x
-    file.writeGroupCode('27', '0.0'); // view target point y
-    file.writeGroupCode('37', '0.0'); // view target point z
-    file.writeGroupCode('40', height); // VPort Height
-    file.writeGroupCode('41', ratio); // Vport height/width ratio
-    file.writeGroupCode('42', '50.0'); // Lens Length
-    file.writeGroupCode('43', '0.0');// Front Clipping Plane
-    file.writeGroupCode('44', '0.0'); // Back Clipping Plane
-    file.writeGroupCode('50', '0.0'); // Snap Rotation Angle
-    file.writeGroupCode('51', '0.0'); // View Twist Angle
-    file.writeGroupCode('71', '0.0'); // Viewmode (System constiable)
-    file.writeGroupCode('72', '1000'); // Circle sides
-    file.writeGroupCode('73', '1'); // fast zoom setting
-    file.writeGroupCode('74', '3');// UCSICON Setting
-    file.writeGroupCode('75', '0'); // snap on/off
-    file.writeGroupCode('76', '1'); // grid on/off
-    file.writeGroupCode('77', '0'); // snap style
-    file.writeGroupCode('78', '0'); // snap isopair
-    file.writeGroupCode('0', 'ENDTAB');
   }
 }

package/core/lib/selectionManager.js

@@ -1,23 +1,41 @@
-import {Utils} from './utils.js';
-import {SelectionWindow} from './selectionWindow.js';
-import {DesignCore} from '../designCore.js';
+import { Utils } from './utils.js';
+import { Point } from '../entities/point.js';
+import { SelectionWindow } from './selectionWindow.js';
+import { DesignCore } from '../designCore.js';
 
+/** SingleSelection Class */
 export class SingleSelection {
+  /**
+   * Create a SingleSelection
+   * @param {number} index
+   * @param {Point} point
+   */
   constructor(index, point) {
     this.selectedItemIndex = index;
     this.selectedPoint = point;
   }
 }
 
+/** SelectionSet Class */
 export class SelectionSet {
+  /** Create SelectionSet */
   constructor() {
     this.accepted = false;
     this.selectionSet = [];
   }
+
+  /**
+   * Remove the last selection from the selectionSet
+   */
+  removeLastSelection() {
+    this.selectionSet.pop();
+  }
 }
 
 // TODO: Refactor class.
+/** Selection Manager Class */
 export class SelectionManager {
+  /** Create a SelectionManager */
   constructor() {
     this.selectionSet = new SelectionSet(); // store a list of selected items indices
     this.selectedItems = []; // store a copy of selected items
@@ -32,6 +50,15 @@ export class SelectionManager {
     this.selectionSetChanged();
   }
 
+  /**
+   * Remove the last selection from the selected items
+   */
+  removeLastSelection() {
+    this.selectedItems.pop();
+    this.selectionSet.removeLastSelection();
+    this.selectionSetChanged();
+  }
+
   /**
    * Handle selection set changes
    */
@@ -52,7 +79,7 @@ export class SelectionManager {
       points: selectionPoints,
     };
 
-    DesignCore.Scene.addToAuxiliaryItems(new SelectionWindow(data));
+    DesignCore.Scene.auxiliaryEntities.add(new SelectionWindow(data));
   }
 
   /**
@@ -60,19 +87,19 @@ export class SelectionManager {
    */
   windowSelect() {
     const selectionRect = this.getSelectionRect();
-    const crossingSelect = DesignCore.Mouse.pointOnScene().y >DesignCore.Mouse.transformToScene(DesignCore.Mouse.mouseDownCanvasPoint).y;
+    const crossingSelect = DesignCore.Mouse.pointOnScene().y > DesignCore.Mouse.transformToScene(DesignCore.Mouse.mouseDownCanvasPoint).y;
 
     if (selectionRect !== undefined) {
-    // Loop through all the entities and see if it should be selected
-      for (let i = 0; i <DesignCore.Scene.items.length; i++) {
-      // check if the item is within the selection rect
-        if (DesignCore.Scene.items[i].within(selectionRect)) {
+      // Loop through all the entities and see if it should be selected
+      for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
+        // check if the item is within the selection rect
+        if (DesignCore.Scene.entities.get(i).within(selectionRect)) {
           this.addToSelectionSet(i);
         }
 
         if (crossingSelect) {
-        // check if the item is touched / crossed by the selection rect
-          if (DesignCore.Scene.items[i].touched(selectionRect)) {
+          // check if the item is touched / crossed by the selection rect
+          if (DesignCore.Scene.entities.get(i).touched(selectionRect)) {
             this.addToSelectionSet(i);
           }
         }
@@ -85,24 +112,23 @@ export class SelectionManager {
 
   /**
    * Get the rectangle points formed between mouseDown and current mouse location
-   * @return {array} selectionRect - [x1, x2, y1, y2]
+   * @return {Object} selectionRect - {min: Point, max: Point}
    */
   getSelectionRect() {
-    // TODO: It would be nice if this returned an object {xmin: xmin, ymin:ymin ...}
-    const xmin = Math.min(DesignCore.Mouse.transformToScene(DesignCore.Mouse.mouseDownCanvasPoint).x, DesignCore.Mouse.pointOnScene().x);
-    const xmax = Math.max(DesignCore.Mouse.transformToScene(DesignCore.Mouse.mouseDownCanvasPoint).x, DesignCore.Mouse.pointOnScene().x);
-    const ymin = Math.min(DesignCore.Mouse.transformToScene(DesignCore.Mouse.mouseDownCanvasPoint).y, DesignCore.Mouse.pointOnScene().y);
-    const ymax = Math.max(DesignCore.Mouse.transformToScene(DesignCore.Mouse.mouseDownCanvasPoint).y, DesignCore.Mouse.pointOnScene().y);
+    const p1 = DesignCore.Mouse.transformToScene(DesignCore.Mouse.mouseDownCanvasPoint);
+    const p2 = DesignCore.Mouse.pointOnScene();
 
-    const selectionRect = [xmin, xmax, ymin, ymax];
-
-    return selectionRect;
+    return {
+      min: new Point(Math.min(p1.x, p2.x), Math.min(p1.y, p2.y)),
+      max: new Point(Math.max(p1.x, p2.x), Math.max(p1.y, p2.y)),
+    };
   }
 
 
   /**
    * Select the item closest to the mouse and add it to the selection set
-   * @returns {SingleSelection} - return single selection
+   * @param {Point} point
+   * @return {SingleSelection} - return single selection
    */
   singleSelect(point) {
     const closestItemIndex = this.findClosestItem(point);
@@ -120,34 +146,15 @@ export class SelectionManager {
   /**
    * Find closest item to point
    * @param  {Point} point
-   * @returns {Integer} - return index of closest item or undefined
+   * @return {number} - return index of closest item or undefined
    */
   findClosestItem(point) {
-    let delta = 1.65 /DesignCore.Core.canvas.getScale(); // find a more suitable starting value
-    let closestItemIndex;
-
-    for (let i = 0; i <DesignCore.Scene.items.length; i++) {
-      // check the items layer is selectable - i.e. on, thawed, etc...
-      const layer = DesignCore.LayerManager.getStyleByName(DesignCore.Scene.items[i].layer);
-
-      if (!layer.isSelectable) {
-        continue;
-      }
-
-      const distance = DesignCore.Scene.items[i].closestPoint(point)[1]; // ClosestPoint()[1] returns a distance to the closest point
-
-      if (distance < delta) {
-        delta = distance;
-        closestItemIndex = i;
-      }
-    }
-
-    return closestItemIndex;
+    return DesignCore.Scene.entities.findClosest(point);
   }
 
   /**
   * Remove the item at index from the selectionSet and selectedItems
-  * @param  {Integer} index - index of the item in scene.items
+  * @param  {number} index - index of the item
   */
   removeFromSelectionSet(index) {
     const itemIndex = this.selectionSet.selectionSet.indexOf(index);
@@ -159,7 +166,7 @@ export class SelectionManager {
 
   /**
   * Add the item at index to the selectionSet and selectedItems
-  * @param  {Integer} index
+  * @param  {number} index
   */
   addToSelectionSet(index) {
     if (index === undefined) {
@@ -174,12 +181,10 @@ export class SelectionManager {
 
   /**
    * Duplicate the item at index and add to selectedItems
-   * @param  {Integer} index
+   * @param  {number} index
    */
   addToSelectedItems(index) {
-    const copyofitem = Utils.cloneObject(DesignCore.Scene.items[index]);
-    copyofitem.colour = DesignCore.Core.settings.selecteditemscolour.toString();
-    copyofitem.lineWidth = copyofitem.lineWidth * 2;
+    const copyofitem = Utils.cloneObject(DesignCore.Scene.entities.get(index));
     this.selectedItems.push(copyofitem);
   }
 
@@ -196,4 +201,25 @@ export class SelectionManager {
 
     DesignCore.Core.canvas.requestPaint();
   }
+
+  /**
+   * Select all items on the canvas
+   */
+  selectAll() {
+    // Clear current selection
+    this.reset();
+
+    // Add all selectable items to the selection
+    for (let i = 0; i < DesignCore.Scene.entities.count(); i++) {
+      const layer = DesignCore.LayerManager.getItemByName(DesignCore.Scene.entities.get(i).layer);
+
+      // Only select items on selectable layers
+      if (layer?.isSelectable) {
+        this.addToSelectionSet(i);
+      }
+    }
+
+    this.selectionSetChanged();
+    DesignCore.Core.canvas.requestPaint();
+  }
 }