@design-core/core 0.0.1 → 0.0.3

package/core/properties/propertyManager.js

@@ -1,17 +1,25 @@
-import {Strings} from '../lib/strings.js';
-import {DesignCore} from '../designCore.js';
+import { Strings } from '../lib/strings.js';
+import { DesignCore } from '../designCore.js';
+import { UpdateState } from '../lib/stateManager.js';
 
+/** Property Manager Class */
 export class PropertyManager {
+  /** Create Property Manager */
   constructor() {
     this.updateCallbackFunction; // set to external callback function
   }
 
+  /**
+   * Set the property callback function
+   * @param {Object} callback
+   */
   setPropertyCallbackFunction(callback) {
     // set the call
     this.updateCallbackFunction = callback;
   }
 
 
+  /** Signal the selection set has changed */
   selectionSetChanged() {
     // If a callback is set - signal that a change has been made
     if (this.updateCallbackFunction) {
@@ -19,29 +27,55 @@ export class PropertyManager {
     }
   }
 
-  setItemProperties(property, newPropertyValue) {
-    for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+  /**
+   * Set item properties
+   * @param {string} property
+   * @param {any} newPropertyValue
+   * @param {string} itemType
+   */
+  setItemProperties(property, newPropertyValue, itemType='All') {
+    const stateChanges = [];
+    for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+      const index = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
+
+      const item = DesignCore.Scene.entities.get(index);
+
+      // check if the item is of the selected type
+      if (itemType !== 'All' && item.type !== itemType) {
+        continue;
+      }
+
       // check if the item has the selected property
-      if (!DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].hasOwnProperty(property)) {
+      if (!item.hasOwnProperty(property)) {
         continue;
       }
 
-      if (typeof(DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]][property]) !== typeof(newPropertyValue)) {
+      if (typeof (item[property]) !== typeof (newPropertyValue)) {
         DesignCore.Core.notify(Strings.Error.INPUT);
       } else {
-        DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]][property] = newPropertyValue;
-        DesignCore.Scene.selectionManager.reloadSelectedItems();
+        // update the item property
+        const update = {};
+        update[property] = newPropertyValue;
+        const stateChange = new UpdateState(item, update);
+        stateChanges.push(stateChange);
       }
     }
+    DesignCore.Scene.commit(stateChanges);
+    DesignCore.Scene.selectionManager.reloadSelectedItems();
   }
 
+  /**
+   * Get the types of items selected
+   * @return {Array}
+   */
   getItemTypes() {
     // Loop through the items and get a list of item types.
     const itemTypes = [];
 
     if (DesignCore.Scene.selectionManager.selectionSet.selectionSet.length > 0) {
-      for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        const itemType = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].type;
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+        const item = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
+        const itemType = item.type;
 
         if (itemTypes.indexOf(itemType, 0) === -1) {
           itemTypes.push(itemType);
@@ -57,11 +91,16 @@ export class PropertyManager {
     return itemTypes;
   }
 
+  /**
+   * Get a list of common propertie
+   * @param {string} itemType
+   * @return {Array}
+   */
   getItemProperties(itemType) {
     // Loop through the items and get a list of common properties.
 
     // check for valid itemType and selectionSet
-    if (itemType === undefined || itemType === null ||DesignCore.Scene.selectionManager.selectionSet.selectionSet.length <= 0) {
+    if (itemType === undefined || itemType === null || DesignCore.Scene.selectionManager.selectionSet.selectionSet.length <= 0) {
       return;
     }
 
@@ -69,7 +108,7 @@ export class PropertyManager {
 
     // create subset array of selectionSet
     DesignCore.Scene.selectionManager.selectionSet.selectionSet.forEach((index) => {
-      subset.push(DesignCore.Scene.items[index]);
+      subset.push(DesignCore.Scene.entities.get(index));
     });
 
     // get a subset of the selectionSet
@@ -81,11 +120,11 @@ export class PropertyManager {
 
     subset.forEach((el) => {
       // get list of keys
-      Object.keys(el).forEach( (key) => {
+      Object.keys(el).forEach((key) => {
         // check if the key is already in the propertiesList
         if (propertiesList.includes(key) === false) {
-        // check if all subset items contain the key
-          if (subset.every((el) => el.hasOwnProperty(key))) {
+          // check if all subset items contain the key and the key is enumberable
+          if (subset.every((el) => el.hasOwnProperty(key) && Object.getOwnPropertyDescriptor(el, key).enumerable)) {
             propertiesList.push(key);
           }
         }
@@ -96,19 +135,26 @@ export class PropertyManager {
   }
 
 
+  /**
+   * Get a list the property values
+   * @param {string} itemType
+   * @param {string} property
+   * @return {Array}
+   */
   getItemPropertyValue(itemType, property) {
     // Loop through the items and get a list the property values
     const propertiesValueList = [];
     if (DesignCore.Scene.selectionManager.selectionSet.selectionSet.length > 0) {
-      for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        if (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].type === itemType || itemType === 'All') {
-          const prop = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]][property];
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+        if (DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]).type === itemType || itemType === 'All') {
+          const prop = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i])[property];
           propertiesValueList.push(prop);
         }
       }
     }
 
-    if (propertiesValueList.every(function(prop) {
+    // Check if every item in the selection set has the same value for the property
+    if (propertiesValueList.every((prop) => {
       return prop === propertiesValueList[0];
     })) {
       return propertiesValueList[0];

package/core/tables/appId.js

@@ -0,0 +1,31 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Property } from '../properties/property.js';
+
+/** AppID Class */
+export class AppID {
+  /**
+   * Create an AppID
+   * @param {Object} data
+   */
+  constructor(data) {
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    // DXF Groupcode 2 - Name
+    this.name = Property.loadValue([data?.name, data?.[2]], '');
+    // DXF Groupcode 70 - Flags
+    this.flags = Property.loadValue([data?.flags, data?.[70]], 0);
+  }
+
+  /**
+   * Write the item to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'APPID', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbRegAppTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name, DXFFile.Version.R2000);
+    file.writeGroupCode('70', this.flags.toString(), DXFFile.Version.R2000);
+  }
+}

package/core/tables/appIdManager.js

@@ -0,0 +1,44 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { TableManagerBase } from './tableManagerBase.js';
+import { AppID } from './appId.js';
+
+/**
+ * AppIDManager Class
+ * @extends TableManagerBase
+ */
+export class AppIDManager extends TableManagerBase {
+  /** Create an AppIDManager */
+  constructor() {
+    super();
+
+    this.indelibleItems.push('ACAD');
+    this.itemProperty = 'appid';
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return AppID;
+  }
+
+  /** Add standard items */
+  addStandardItems() {
+    this.addItem({ 'name': 'ACAD' });
+  }
+
+  /**
+   * Write the table to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'TABLE', DXFFile.Version.R2000);
+    file.writeGroupCode('2', 'APPID', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
+
+    for (let i = 0; i < this.itemCount(); i++) {
+      this.getItemByIndex(i).dxf(file);
+    }
+
+    file.writeGroupCode('0', 'ENDTAB', DXFFile.Version.R2000);
+  }
+}

package/core/tables/block.js

@@ -0,0 +1,323 @@
+import { Point } from '../entities/point.js';
+import { Entity } from '../entities/entity.js';
+import { EndBlock } from './endblk.js';
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { BoundingBox } from '../lib/boundingBox.js';
+import { Strings } from '../lib/strings.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Flags } from '../properties/flags.js';
+import { Property } from '../properties/property.js';
+import { AddState, RemoveState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+import { Utils } from '../lib/utils.js';
+
+/**
+ * Block Entity Class
+ * @extends Entity
+ */
+export class Block extends Entity {
+  /**
+   * Create a Block Entity
+   * @param {Array} data
+   */
+  constructor(data) {
+    super(data);
+    this.name = '';
+    this.points = [new Point()];
+    // Store the block record handle and endblk handle for use when writing to dxf file
+    this.blockRecordHandle = data?.blockRecordHandle;
+    this.endblkHandle = data?.endblkHandle;
+
+    Object.defineProperty(this, 'flags', {
+      value: new Flags(),
+      writable: true,
+    });
+
+    Object.defineProperty(this, 'items', {
+      value: [],
+      writable: true,
+    });
+
+    if (data) {
+      if (data.hasOwnProperty('name') || data.hasOwnProperty('2')) {
+        // DXF Groupcode 2 - Block Name
+        this.name = data.name || data[2];
+      }
+
+      if (data.hasOwnProperty('items')) {
+        this.items = data.items;
+      }
+
+      if (data.hasOwnProperty('flags') || data.hasOwnProperty('70')) {
+        // DXF Groupcode 70 - Block-type flags (bit-coded):
+        // 0 = Indicates none of the following flags apply
+        // 1 = This is an anonymous block generated by hatching, associative dimensioning, other internal operations, or an application
+        // 2 = This block has non-constant attribute definitions (this bit is not set if the block has any attribute definitions that are constant, or has no attribute definitions at all)
+        // 4 = This block is an external reference (xref)
+        // 8 = This block is an xref overlay
+        // 16 = This block is externally dependent
+        // 32 = This is a resolved external reference, or dependent of an external reference (ignored on input)
+        // 64 = This definition is a referenced external reference (ignored on input)
+
+        this.flags.setFlagValue(Property.loadValue([data.flags, data[70]], 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: 'Block', shortcut: 'B' };
+    return command;
+  }
+
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to create an entity
+   */
+  async execute() {
+    try {
+      // set a name
+      const defaultName = `Block-${DesignCore.Scene.blockManager.itemCount()}`;
+      const nameOp = new PromptOptions(Strings.Input.NAME, [Input.Type.STRING], [], defaultName);
+      const selectedName = await DesignCore.Scene.inputManager.requestInput(nameOp);
+
+      // get the insertion point
+      const op2 = new PromptOptions(Strings.Input.BASEPOINT, [
+        Input.Type.POINT,
+      ]);
+      const insertPoint = await DesignCore.Scene.inputManager.requestInput(op2);
+
+      // get the block entities
+      const op = new PromptOptions(Strings.Input.SELECTIONSET, [
+        Input.Type.SELECTIONSET,
+      ]);
+
+      if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
+        await DesignCore.Scene.inputManager.requestInput(op);
+      }
+
+      // create block
+      const block = DesignCore.Scene.blockManager.addItem({ name: selectedName });
+      // get a copy of the selection set
+      const selections = DesignCore.Scene.selectionManager.selectionSet.selectionSet.slice();
+      // sort the selection in descending order
+      selections.sort((a, b) => b - a);
+      // array to hold state changes
+      const stateChanges = [];
+
+      // move selected items from scene to block
+      selections.forEach((index) => {
+        const item = DesignCore.Scene.entities.get(index);
+        // remove item from scene
+        const copyofitem = Utils.cloneObject(item);
+        // adjust the items points to reflect the insert point
+        const delta = new Point(-insertPoint.x, -insertPoint.y);
+        if (item.hasOwnProperty('points')) {
+          const points = copyofitem.points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).add(delta));
+          copyofitem.setProperty('points', points);
+        }
+        block.items.push(copyofitem);
+        const stateChangeRemove = new RemoveState(item);
+        stateChanges.push(stateChangeRemove);
+      });
+
+      // define insert data
+      const insertData = {
+        type: 'Insert',
+        points: [new Point(insertPoint.x, insertPoint.y)],
+        blockName: selectedName,
+      };
+
+      const insert = DesignCore.CommandManager.createNew(insertData.type, insertData);
+      const stateChangeAdd = new AddState(insert);
+      stateChanges.push(stateChangeAdd);
+
+      // commit the changes to the scene
+      DesignCore.Scene.commit(stateChanges);
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the entity during creation
+   */
+  preview() { }
+
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'BLOCK');
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
+    file.writeGroupCode('8', this.layer);
+    file.writeGroupCode('100', 'AcDbBlockBegin', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name);
+    file.writeGroupCode('70', this.flags.getFlagValue());
+    file.writeGroupCode('10', this.points[0].x);
+    file.writeGroupCode('20', this.points[0].y);
+    file.writeGroupCode('30', 0.0);
+    file.writeGroupCode('3', this.name); // Name again
+    file.writeGroupCode('1', '');
+
+    for (let i = 0; i < this.items.length; i++) {
+      this.items[i].dxf(file);
+    }
+
+    const endblk = new EndBlock({ handle: this.endblkHandle });
+    endblk.dxf(file);
+  }
+
+  /**
+   * Clear items from the block
+   */
+  clearItems() {
+    this.items = [];
+  }
+
+  /**
+   * Add an item to the block
+   * @param {Object} item
+   */
+  addItem(item) {
+    this.items.push(item);
+  }
+
+  /**
+   * Draw the entity
+   * @param {Object} ctx - context
+   * @param {number} scale
+   * @param {Object} insert - insert entity
+   */
+  draw(ctx, scale, insert = undefined) {
+    if (!this.items.length) {
+      // nothing to draw
+      return;
+    }
+
+    this.items.forEach((item) => {
+      ctx.save();
+      // Use the current item and block insert to set the context
+      // insert required for colour ByBlock
+      DesignCore.Canvas.setContext(item, ctx, insert);
+
+      item.draw(ctx, scale);
+      ctx.restore();
+    });
+
+    /*
+        //////////////////////////////////////////
+        // draw test point for location
+        ctx.strokeStyle = Colours.rgbToString(colour);
+        ctx.lineWidth = 1 / scale;
+        ctx.beginPath()
+        ctx.moveTo(this.points[0].x, this.points[0].y);
+        ctx.arc(this.points[0].x, this.points[0].y, 5 / scale, radians2degrees(0), radians2degrees(360), false);
+        ctx.stroke();
+        //////////////////////////////////////////
+        */
+  }
+
+  /**
+   * Get snap points
+   * @param {Point} mousePoint
+   * @param {number} delta
+   * @return {Array} - array of snap points
+   */
+  snaps(mousePoint, delta) {
+    const snaps = [];
+
+    if (!this.items.length) {
+      // nothing to draw
+      return snaps;
+    }
+
+    for (let item = 0; item < this.items.length; item++) {
+      // collect the child item snaps
+      const itemSnaps = this.items[item].snaps(mousePoint, delta);
+      snaps.push(...itemSnaps);
+    }
+
+    return snaps;
+  }
+
+  /**
+   * Get closest point on entity
+   * @param {Point} P
+   * @return {Array} - [Point, distance]
+   */
+  closestPoint(P) {
+    let distance = Infinity;
+    let minPnt = P;
+
+    if (!this.items.length) {
+      // nothing to draw
+      return [minPnt, distance];
+    }
+
+    for (let idx = 0; idx < this.items.length; idx++) {
+      const itemClosestPoint = this.items[idx].closestPoint(P);
+      const itemPnt = itemClosestPoint[0];
+      const itemDist = itemClosestPoint[1];
+
+      if (itemDist < distance) {
+        distance = itemDist;
+        minPnt = itemPnt;
+      }
+    }
+
+    return [minPnt, distance];
+  }
+
+  /**
+   * Return boundingbox for entity
+   * @return {BoundingBox}
+   */
+  boundingBox() {
+    let xmin = Infinity;
+    let xmax = -Infinity;
+    let ymin = Infinity;
+    let ymax = -Infinity;
+
+    for (let idx = 0; idx < this.items.length; idx++) {
+      const itemBoundingBox = this.items[idx].boundingBox();
+
+      xmin = Math.min(xmin, itemBoundingBox.xMin);
+      xmax = Math.max(xmax, itemBoundingBox.xMax);
+      ymin = Math.min(ymin, itemBoundingBox.yMin);
+      ymax = Math.max(ymax, itemBoundingBox.yMax);
+    }
+
+    const topLeft = new Point(xmin, ymax);
+    const bottomRight = new Point(xmax, ymin);
+
+    return new BoundingBox(topLeft, bottomRight);
+  }
+
+  /**
+   * Determine if the entity is touch the selection window
+   * @param {Object} selection - {min: Point, max: Point}
+   * @return {boolean} true if touched
+   */
+  touched(selection) {
+    for (let idx = 0; idx < this.items.length; idx++) {
+      const touched = this.items[idx].touched(selection);
+      if (touched) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

package/core/tables/blockManager.js

@@ -0,0 +1,48 @@
+// import {DesignCore} from '../designCore.js';
+// import {Strings} from '../lib/strings.js';
+import { TableManagerBase } from './tableManagerBase.js';
+import { Block } from './block.js';
+import { DesignCore } from '../designCore.js';
+
+/**
+ * BlockManager Class
+ * @extends TableManagerBase
+ */
+export class BlockManager extends TableManagerBase {
+  /** Create a BlockManager */
+  constructor() {
+    super();
+    this.itemProperty = 'block';
+    this.indelibleItems.push('*Model_Space', '*Paper_Space');
+  }
+
+  /** Get the item class */
+  get itemClass() {
+    return Block;
+  }
+
+  /**
+   * Add standard blocks
+   */
+  addStandardItems() {
+    this.addItem({ 'name': '*Model_Space' });
+    this.addItem({ 'name': '*Paper_Space' });
+  }
+
+  /**
+   * Add a block to the list of items and assign a block record handle
+   * @param {Object} item
+   * @param {boolean} overwrite
+   * @return {Object}
+   */
+  addItem(item, overwrite = false) {
+    const newItem = super.addItem(item, overwrite);
+    if (newItem.blockRecordHandle === undefined) {
+      newItem.blockRecordHandle = DesignCore.HandleManager.next();
+    }
+    if (newItem.endblkHandle === undefined) {
+      newItem.endblkHandle = DesignCore.HandleManager.next();
+    }
+    return newItem;
+  }
+}

package/core/tables/blockRecord.js

@@ -0,0 +1,29 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { Property } from '../properties/property.js';
+
+/** BlockRecord Class */
+export class BlockRecord {
+  /**
+   * Create a BlockRecord
+   * @param {Object} data
+   */
+  constructor(data) {
+    // DXF Groupcode 5 - Handle
+    this.handle = Property.loadValue([data?.handle, data?.[5]]);
+    // DXF Groupcode 2 - Name
+    this.name = Property.loadValue([data?.name, data?.[2]], '');
+  }
+
+  /**
+   * Write the item to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    file.writeGroupCode('0', 'BLOCK_RECORD', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbBlockTableRecord', DXFFile.Version.R2000);
+    file.writeGroupCode('2', this.name, DXFFile.Version.R2000);
+    file.writeGroupCode('340', '0', DXFFile.Version.R2000);
+  }
+}

package/core/tables/blockRecordManager.js

@@ -0,0 +1,37 @@
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { BlockRecord } from './blockRecord.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * BlockRecordManager Class
+ * Writes BLOCK_RECORD table entries based on the scene's block manager
+ */
+export class BlockRecordManager {
+  /** Create a BlockRecordManager */
+  constructor() {
+    this.handle = DesignCore.HandleManager.next();
+  }
+
+  /**
+   * Write the table to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    const blocks = DesignCore.Scene.blockManager.items;
+
+    file.writeGroupCode('0', 'TABLE', DXFFile.Version.R2000);
+    file.writeGroupCode('2', 'BLOCK_RECORD', DXFFile.Version.R2000);
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000);
+    file.writeGroupCode('100', 'AcDbSymbolTable', DXFFile.Version.R2000);
+    file.writeGroupCode('70', blocks.length.toString(), DXFFile.Version.R2000);
+
+    for (let i = 0; i < blocks.length; i++) {
+      // Temp hack for block record handle
+      const record = new BlockRecord({ name: blocks[i].name, handle: blocks[i].blockRecordHandle });
+      record.dxf(file);
+    }
+
+    file.writeGroupCode('0', 'ENDTAB', DXFFile.Version.R2000);
+  }
+}