@vitrosoftware/common-ui-ts 1.1.121 → 1.1.123

package/lib/dxf-viewer/parser/entities/leader.js

@@ -0,0 +1,84 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'LEADER';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value, vertices: [] },
+        numberOfVertices = 0;
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 76:
+            numberOfVertices = curr.value;
+            break;
+        case 10: // X coordinate of point
+            entity.vertices = parseLWPolylineVertices(numberOfVertices, scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};
+
+function parseLWPolylineVertices(n, scanner) {
+    if(!n || n <= 0) throw Error('n must be greater than 0 verticies');
+    var vertices = [], i;
+    var vertexIsStarted = false;
+    var vertexIsFinished = false;
+    var curr = scanner.lastReadGroup;
+
+    for(i = 0; i < n; i++) {
+        var vertex = {};
+        while(curr !== 'EOF') {
+            if(curr.code === 0 || vertexIsFinished) break;
+
+            switch(curr.code) {
+            case 10: // X
+                if(vertexIsStarted) {
+                    vertexIsFinished = true;
+                    continue;
+                }
+                vertex.x = curr.value;
+                vertexIsStarted = true;
+                break;
+            case 20: // Y
+                vertex.y = curr.value;
+                break;
+            case 30: // Z
+                vertex.z = curr.value;
+                break;
+            case 40: // start width
+                vertex.startWidth = curr.value;
+                break;
+            case 41: // end width
+                vertex.endWidth = curr.value;
+                break;
+            case 42: // bulge
+                if(curr.value != 0) vertex.bulge = curr.value;
+                break;
+            default:
+                // if we do not hit known code return vertices.  Code might belong to entity
+                if (vertexIsStarted) {
+                    vertices.push(vertex);
+                }
+                scanner.rewind();
+                return vertices;
+            }
+            curr = scanner.next();
+        }
+        // See https://groups.google.com/forum/#!topic/comp.cad.autocad/9gn8s5O_w6E
+        vertices.push(vertex);
+        vertexIsStarted = false;
+        vertexIsFinished = false;
+    }
+    scanner.rewind();
+    return vertices;
+};

package/lib/dxf-viewer/parser/entities/line.js

@@ -0,0 +1,34 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'LINE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value, vertices: [] };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10: // X coordinate of point
+            entity.vertices.unshift(helpers.parsePoint(scanner));
+            break;
+        case 11:
+            entity.vertices.push(helpers.parsePoint(scanner));
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        case 100:
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        
+        curr = scanner.next();
+    }
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/lwpolyline.js

@@ -0,0 +1,100 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'LWPOLYLINE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value, vertices: [] },
+        numberOfVertices = 0;
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 38:
+            entity.elevation = curr.value;
+            break;
+        case 39:
+            entity.depth = curr.value;
+            break;
+        case 70: // 1 = Closed shape, 128 = plinegen?, 0 = default
+            entity.shape = ((curr.value & 1) === 1);
+            entity.hasContinuousLinetypePattern = ((curr.value & 128) === 128);
+            break;
+        case 90:
+            numberOfVertices = curr.value;
+            break;
+        case 10: // X coordinate of point
+            entity.vertices = parseLWPolylineVertices(numberOfVertices, scanner);
+            break;
+        case 43:
+            if(curr.value !== 0) entity.width = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};
+
+function parseLWPolylineVertices(n, scanner) {
+    if(!n || n <= 0) throw Error('n must be greater than 0 verticies');
+    var vertices = [], i;
+    var vertexIsStarted = false;
+    var vertexIsFinished = false;
+    var curr = scanner.lastReadGroup;
+
+    for(i = 0; i < n; i++) {
+        var vertex = {};
+        while(curr !== 'EOF') {
+            if(curr.code === 0 || vertexIsFinished) break;
+
+            switch(curr.code) {
+            case 10: // X
+                if(vertexIsStarted) {
+                    vertexIsFinished = true;
+                    continue;
+                }
+                vertex.x = curr.value;
+                vertexIsStarted = true;
+                break;
+            case 20: // Y
+                vertex.y = curr.value;
+                break;
+            case 30: // Z
+                vertex.z = curr.value;
+                break;
+            case 40: // start width
+                vertex.startWidth = curr.value;
+                break;
+            case 41: // end width
+                vertex.endWidth = curr.value;
+                break;
+            case 42: // bulge
+                if(curr.value != 0) vertex.bulge = curr.value;
+                break;
+            default:
+                // if we do not hit known code return vertices.  Code might belong to entity
+                if (vertexIsStarted) {
+                    vertices.push(vertex);
+                }
+                scanner.rewind();
+                return vertices;
+            }
+            curr = scanner.next();
+        }
+        // See https://groups.google.com/forum/#!topic/comp.cad.autocad/9gn8s5O_w6E
+        vertices.push(vertex);
+        vertexIsStarted = false;
+        vertexIsFinished = false;
+    }
+    scanner.rewind();
+    return vertices;
+};

package/lib/dxf-viewer/parser/entities/mtext.js

@@ -0,0 +1,54 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'MTEXT';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 3:
+        case 1:
+            entity.text ? entity.text += curr.value : entity.text = curr.value;
+            break;
+        case 10:
+            entity.position = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.direction = helpers.parsePoint(scanner);
+            break;
+        case 40:
+            //Note: this is the text height
+            entity.height = curr.value;
+            break;
+        case 41:
+            entity.width = curr.value;
+            break;
+        case 44:
+            entity.lineSpacing = curr.value;
+            break;
+        case 50:
+            entity.rotation = curr.value;
+            break;
+        case 71:
+            entity.attachmentPoint = curr.value;
+            break;
+        case 72:
+            entity.drawingDirection = curr.value;
+            break;
+        case 101:
+            helpers.skipEmbeddedObject(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/point.js

@@ -0,0 +1,35 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'POINT';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10:
+            entity.position = helpers.parsePoint(scanner);
+            break;
+        case 39:
+            entity.thickness = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        case 100:
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/polyline.js

@@ -0,0 +1,92 @@
+
+import * as helpers from '../ParseHelpers.js'
+import VertexParser from './vertex.js';
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'POLYLINE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value, vertices: [] };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10: // always 0
+            break;
+        case 20: // always 0
+            break;
+        case 30: // elevation
+            break;
+        case 39: // thickness
+            entity.thickness = curr.value;
+            break;
+        case 40: // start width
+            break;
+        case 41: // end width
+            break;
+        case 70:
+            entity.shape = (curr.value & 1) !== 0;
+            entity.includesCurveFitVertices = (curr.value & 2) !== 0;
+            entity.includesSplineFitVertices = (curr.value & 4) !== 0;
+            entity.is3dPolyline = (curr.value & 8) !== 0;
+            entity.is3dPolygonMesh = (curr.value & 16) !== 0;
+            entity.is3dPolygonMeshClosed = (curr.value & 32) !== 0; // 32 = The polygon mesh is closed in the N direction
+            entity.isPolyfaceMesh = (curr.value & 64) !== 0;
+            entity.hasContinuousLinetypePattern = (curr.value & 128) !== 0;
+            break;
+        case 71: // Polygon mesh M vertex count
+            break;
+        case 72: // Polygon mesh N vertex count
+            break;
+        case 73: // Smooth surface M density
+            break;
+        case 74: // Smooth surface N density
+            break;
+        case 75: // Curves and smooth surface type
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    entity.vertices = parsePolylineVertices(scanner, curr);
+
+    return entity;
+};
+
+function parsePolylineVertices(scanner, curr) {
+    var vertexParser = new VertexParser();
+
+    var vertices = [];
+    while (!scanner.isEOF()) {
+        if (curr.code === 0) {
+            if (curr.value === 'VERTEX') {
+                vertices.push(vertexParser.parseEntity(scanner, curr));
+                curr = scanner.lastReadGroup;
+            } else if (curr.value === 'SEQEND') {
+                parseSeqEnd(scanner, curr);
+                break;
+            }
+        }
+    }
+    return vertices;
+};
+
+function parseSeqEnd(scanner, curr) {
+    var entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr != 'EOF') {
+        if (curr.code == 0) break;
+        helpers.checkCommonEntityProperties(entity, curr, scanner);
+        curr = scanner.next();
+    }
+
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/solid.js

@@ -0,0 +1,40 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'SOLID';
+
+EntityParser.prototype.parseEntity = function(scanner, currentGroup) {
+    var entity;
+    entity = { type: currentGroup.value };
+    entity.points = [];
+    currentGroup = scanner.next();
+    while(currentGroup !== 'EOF') {
+        if(currentGroup.code === 0) break;
+
+        switch(currentGroup.code) {
+        case 10:
+            entity.points[0] = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.points[1] = helpers.parsePoint(scanner);
+            break;
+        case 12:
+            entity.points[2] = helpers.parsePoint(scanner);
+            break;
+        case 13:
+            entity.points[3] = helpers.parsePoint(scanner);
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, currentGroup, scanner);
+            break;
+        }
+        currentGroup = scanner.next();
+    }
+
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/spline.js

@@ -0,0 +1,70 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'SPLINE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF')
+    {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10:
+            if (!entity.controlPoints) entity.controlPoints = [];
+            entity.controlPoints.push(helpers.parsePoint(scanner));
+            break;
+        case 11:
+            if (!entity.fitPoints) entity.fitPoints = [];
+            entity.fitPoints.push(helpers.parsePoint(scanner));
+            break;
+        case 12:
+            entity.startTangent = helpers.parsePoint(scanner);
+            break;
+        case 13:
+            entity.endTangent = helpers.parsePoint(scanner);
+            break;
+        case 40:
+            if (!entity.knotValues) entity.knotValues = [];
+            entity.knotValues.push(curr.value);
+            break;
+        case 70:
+            if ((curr.value & 1) != 0) entity.closed = true;
+            if ((curr.value & 2) != 0) entity.periodic = true;
+            if ((curr.value & 4) != 0) entity.rational = true;
+            if ((curr.value & 8) != 0) entity.planar = true;
+            if ((curr.value & 16) != 0)
+            {
+                entity.planar = true;
+                entity.linear = true;
+            }
+            break;
+
+        case 71:
+            entity.degreeOfSplineCurve = curr.value;
+            break;
+        case 72:
+            entity.numberOfKnots = curr.value;
+            break;
+        case 73:
+            entity.numberOfControlPoints = curr.value;
+            break;
+        case 74:
+            entity.numberOfFitPoints = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/text.js

@@ -0,0 +1,47 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'TEXT';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+        entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+        switch(curr.code) {
+        case 10: // X coordinate of 'first alignment point'
+            entity.startPoint = helpers.parsePoint(scanner);
+            break;
+        case 11: // X coordinate of 'second alignment point'
+            entity.endPoint = helpers.parsePoint(scanner);
+            break;
+        case 40: // Text height
+            entity.textHeight = curr.value;
+            break;
+        case 41:
+            entity.xScale = curr.value;
+            break;
+        case 50: // Rotation in degrees
+            entity.rotation = curr.value;
+            break;
+        case 1: // Text
+            entity.text = curr.value;
+            break;
+        // NOTE: 72 and 73 are meaningless without 11 (second alignment point)
+        case 72: // Horizontal alignment
+            entity.halign = curr.value;
+            break;
+        case 73: // Vertical alignment
+            entity.valign = curr.value;
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/vertex.js

@@ -0,0 +1,62 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'VERTEX';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10:    // X
+            entity.x = curr.value;
+            break;
+        case 20: // Y
+            entity.y = curr.value;
+            break;
+        case 30: // Z
+            entity.z = curr.value;
+            break;
+        case 40: // start width
+            break;
+        case 41: // end width
+            break;
+        case 42: // bulge
+            if(curr.value != 0) entity.bulge = curr.value;
+            break;
+        case 70: // flags
+            entity.curveFittingVertex = (curr.value & 1) !== 0;
+            entity.curveFitTangent = (curr.value & 2) !== 0;
+            entity.splineVertex = (curr.value & 8) !== 0;
+            entity.splineControlPoint = (curr.value & 16) !== 0;
+            entity.threeDPolylineVertex = (curr.value & 32) !== 0;
+            entity.threeDPolylineMesh = (curr.value & 64) !== 0;
+            entity.polyfaceMeshVertex = (curr.value & 128) !== 0;
+            break;
+        case 50: // curve fit tangent direction
+            break;
+        case 71: // polyface mesh vertex index
+            entity.faces = [curr.value];
+            break;
+        case 72: // polyface mesh vertex index
+            entity.faces[1] = curr.value;
+            break;
+        case 73: // polyface mesh vertex index
+            entity.faces[2] = curr.value;
+            break;
+        case 74: // polyface mesh vertex index
+            entity.faces[3] = curr.value;
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        
+        curr = scanner.next();
+    }
+    return entity;
+};

package/lib/dxf-viewer/parser/entities/viewport.js

@@ -0,0 +1,56 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'VIEWPORT';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value, vertices: [] },
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 281:
+            entity.renderMode = curr.value;
+            break;
+        case 40:
+            entity.width = curr.value;
+            break;
+        case 41:
+            entity.height = curr.value;
+            break;
+        case 10: // X coordinate of center point
+            entity.center = helpers.parsePoint(scanner);
+            break;
+        case 12: // X coordinate of view center point
+            entity.viewCenter = helpers.parsePoint(scanner);
+            break;
+        case 17: // X coordinate of view target point (in WCS)
+            entity.viewTarget = helpers.parsePoint(scanner);
+            break;
+        case 45: // View height
+            entity.viewHeight = curr.value;
+            break;
+        case 51: // View twist angle
+            entity.twist = curr.value;
+            break;
+        case 340:
+            entity.boundaryHandle = curr.value;
+            break;
+        case 68:
+            entity.status = curr.value;
+            break;
+        case 69:
+            entity.id = curr.value;
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};
+