@vitrosoftware/common-ui-ts 1.1.122 → 1.1.124

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

@@ -0,0 +1,109 @@
+import * as helpers from '../ParseHelpers.js';
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'ATTRIB';
+
+EntityParser.prototype.parseEntity = function (scanner, curr) {
+    var entity = {
+        type: curr.value,
+        scale: 1,
+        textStyle: 'STANDARD',
+    };
+    curr = scanner.next();
+    while (curr !== 'EOF') {
+        if (curr.code === 0) {
+            break;
+        }
+        switch (curr.code) {
+            case 1:
+                entity.text = curr.value;
+                break;
+            case 2:
+                entity.tag = curr.value;
+                break;
+            case 3:
+                entity.prompt = curr.value;
+                break;
+            case 7:
+                entity.textStyle = curr.value;
+                break;
+            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 39:
+                entity.thickness = curr.value;
+                break;
+            case 40:
+                entity.textHeight = curr.value;
+                break;
+            case 41:
+                entity.scale = curr.value;
+                break;
+            case 44:
+                entity.lineSpacingFactor = curr.value;
+                break;
+            case 45:
+                entity.fillBoxScale = curr.value;
+                break;
+            case 46:
+                entity.annotationHeight = curr.value;
+                break;
+            case 50:
+                entity.rotation = curr.value;
+                break;
+            case 51:
+                entity.obliqueAngle = curr.value;
+                break;
+            case 63:
+                entity.backgroundFillColor = curr.value;
+                break;
+            case 70:
+                entity.invisible = !!(curr.value & 0x01);
+                entity.constant = !!(curr.value & 0x02);
+                entity.verificationRequired = !!(curr.value & 0x04);
+                entity.preset = !!(curr.value & 0x08);
+                break;
+            case 71:
+                entity.attachmentPoint = curr.value;
+                break;
+            case 72:
+                entity.horizontalJustification = curr.value;
+                break;
+            case 73:
+                entity.lineSpacing = curr.value;
+                break;
+            case 74:
+                entity.verticalJustification = curr.value;
+                break;
+            case 90:
+                // TODO:: enum
+                // 0 = Background fill off
+                // 1 = Use background fill color
+                // 2 = Use drawing window color as background fill color
+                // and 420 ~ 439 background color check
+                entity.backgroundFillSetting = curr.value;
+                break;
+            case 100:
+                break;
+            case 210:
+                entity.extrusionDirection = helpers.parsePoint(scanner);
+                break;
+            case 280:
+                entity.lockPositionFlag = curr.value;
+                break;
+            case 340:
+                entity.hardPointerId = curr.value;
+                break;
+            default:
+                helpers.checkCommonEntityProperties(entity, curr, scanner);
+                break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};

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

@@ -0,0 +1,43 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'CIRCLE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity, endAngle;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10: // X coordinate of point
+            entity.center = helpers.parsePoint(scanner);
+            break;
+        case 40: // radius
+            entity.radius = curr.value;
+            break;
+        case 50: // start angle
+            entity.startAngle = Math.PI / 180 * curr.value;
+            break;
+        case 51: // end angle
+            endAngle = Math.PI / 180 * curr.value;
+            if(endAngle < entity.startAngle)
+                entity.angleLength = endAngle + 2 * Math.PI - entity.startAngle;
+            else
+                entity.angleLength = endAngle - entity.startAngle;
+            entity.endAngle = endAngle;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default: // ignored attribute
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};

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

@@ -0,0 +1,72 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'DIMENSION';
+
+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 2: // Referenced block name
+            entity.block = curr.value;
+            break;
+        case 3: // Dimension style name
+            entity.styleName = curr.value;
+            break;
+        case 10: // X coordinate of 'first alignment point'
+            entity.anchorPoint = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.middleOfText = helpers.parsePoint(scanner);
+            break;
+        case 12: // Insertion point for clones of a dimension
+            entity.insertionPoint = helpers.parsePoint(scanner);
+            break;
+        case 13: // Definition point for linear and angular dimensions
+            entity.linearOrAngularPoint1 = helpers.parsePoint(scanner);
+            break;
+        case 14: // Definition point for linear and angular dimensions
+            entity.linearOrAngularPoint2 = helpers.parsePoint(scanner);
+            break;
+        case 15: // Definition point for diameter, radius, and angular dimensions
+            entity.diameterOrRadiusPoint = helpers.parsePoint(scanner);
+            break;
+        case 16: // Point defining dimension arc for angular dimensions
+            entity.arcPoint = helpers.parsePoint(scanner);
+            break;
+        case 70: // Dimension type
+            entity.dimensionType = curr.value;
+            break;
+        case 71: // 5 = Middle center
+            entity.attachmentPoint = curr.value;
+            break;
+        case 42: // Actual measurement
+            entity.actualMeasurement = curr.value;
+            break;
+        case 1: // Text entered by user explicitly
+            entity.text = curr.value;
+            break;
+        case 50: // Angle of rotated, horizontal, or vertical dimensions
+            entity.angle = curr.value;
+            break;
+        case 53: // Rotation angle of the dimension text away from its default orientation (the
+            //direction of the dimension line)
+            entity.textRotation = 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/ellipse.js

@@ -0,0 +1,46 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'ELLIPSE';
+
+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.center = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.majorAxisEndPoint = helpers.parsePoint(scanner);
+            break;
+        case 40:
+            entity.axisRatio = curr.value;
+            break;
+        case 41:
+            entity.startAngle = curr.value;
+            break;
+        case 42:
+            entity.endAngle = curr.value;
+            break;
+        case 2:
+            entity.name = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        
+        curr = scanner.next();
+    }
+
+    return entity;
+};

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

@@ -0,0 +1,343 @@
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'HATCH';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+    entity = { type: curr.value };
+
+    let numBoundaryLoops = 0;
+    let numDefinitionLines = 0;
+    let numSeedPoints = 0;
+
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if (curr.code === 0) break;
+
+        while (numBoundaryLoops > 0) {
+            const loop = ParseBoundaryLoop(curr, scanner)
+            if (loop) {
+                entity.boundaryLoops.push(loop);
+                numBoundaryLoops--;
+                curr = scanner.next();
+            } else {
+                numBoundaryLoops = 0
+            }
+        }
+
+        while (numDefinitionLines > 0) {
+            const line = ParseDefinitionLine(curr, scanner)
+            if (line) {
+                entity.definitionLines.push(line);
+                numDefinitionLines--;
+                curr = scanner.next();
+            } else {
+                numDefinitionLines = 0
+            }
+        }
+
+        while (numSeedPoints > 0) {
+            const pt = ParseSeedPoint(curr, scanner);
+            if (pt) {
+                entity.seedPoints.push(pt);
+                numSeedPoints--;
+                curr = scanner.next();
+            } else {
+                numSeedPoints = 0
+            }
+        }
+
+        if (curr.code === 0) break;
+
+        switch(curr.code) {
+
+        case 2: // Hatch pattern name
+            entity.patternName = curr.value;
+            break;
+
+        case 70: //Solid fill flag (solid fill = 1; pattern fill = 0)
+            entity.isSolid = curr.value != 0;
+            break;
+
+        case 91: // Number of boundary paths (loops)
+            numBoundaryLoops = curr.value;
+            if (numBoundaryLoops > 0) {
+                entity.boundaryLoops = []
+            }
+            break;
+
+        // Hatch style:
+        // 0 = Hatch “odd parity” area (Normal style)
+        // 1 = Hatch outermost area only (Outer style)
+        // 2 = Hatch through entire area (Ignore style)
+        case 75:
+            entity.hatchStyle = curr.value;
+            break;
+
+        //Hatch pattern type:
+        // 0 = User-defined; 1 = Predefined; 2 = Custom
+        case 76:
+            entity.patternType = curr.value;
+            break;
+
+        case 52: // Hatch pattern angle (pattern fill only)
+            entity.patternAngle = curr.value * Math.PI / 180;
+            break;
+
+        case 41: // Hatch pattern scale or spacing (pattern fill only)
+            entity.patternScale = curr.value;
+            break;
+
+        case 78: // Number of pattern definition lines
+            numDefinitionLines = curr.value;
+            if (numDefinitionLines > 0) {
+                entity.definitionLines = []
+            }
+            break;
+
+        case 98: // Number of seed points
+            numSeedPoints = curr.value;
+            if (numSeedPoints > 0) {
+                entity.seedPoints = []
+            }
+            break;
+
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};
+
+function ParseBoundaryLoop(curr, scanner) {
+    let entity = null
+
+    const ParsePolyline = () => {
+        const pl = {vertices: [], isClosed: false};
+        let hasBulge = false;
+        let numVertices = 0;
+        while (true) {
+            if (numVertices > 0) {
+                for (let i = 0; i < numVertices; i++) {
+                    if (curr.code != 10) {
+                        break
+                    }
+                    const p = helpers.parsePoint(scanner)
+                    curr = scanner.next();
+                    if (curr.code == 42) {
+                        p.bulge = curr.value
+                        curr = scanner.next();
+                    }
+                    pl.vertices.push(p)
+                }
+                return pl
+            }
+
+            switch (curr.code) {
+            case 72:
+                hasBulge = curr.value;
+                break;
+            case 73:
+                pl.isClosed = curr.value;
+                break;
+            case 93:
+                numVertices = curr.value;
+                break;
+            default:
+                return pl;
+            }
+            curr = scanner.next();
+        }
+    }
+
+    const ParseEdge = () => {
+        if (curr.code != 72) {
+            return null
+        }
+        const e = {type: curr.value}
+        curr = scanner.next();
+        const isSpline = e.type == 4
+
+        while (true) {
+            switch (curr.code) {
+            case 10:
+                if (isSpline) {
+                    if (!e.controlPoints) {
+                        e.controlPoints = [];
+                    }
+                    e.controlPoints.push(helpers.parsePoint(scanner));
+                } else {
+                    e.start = helpers.parsePoint(scanner);
+                }
+                break;
+            case 11:
+                if (isSpline) {
+                    if (!e.fitPoints) {
+                        e.fitPoints = [];
+                    }
+                    e.fitPoints.push(helpers.parsePoint(scanner));
+                } else {
+                    e.end = helpers.parsePoint(scanner);
+                }
+                break;
+            case 40:
+                if (isSpline) {
+                    if (!e.knotValues) {
+                        e.knotValues = [];
+                    }
+                    e.knotValues.push(curr.value);
+                } else {
+                    e.radius = curr.value;
+                }
+                break;
+            case 50:
+                e.startAngle = curr.value * Math.PI / 180;
+                break;
+            case 51:
+                e.endAngle = curr.value * Math.PI / 180;
+                break;
+            case 73:
+                if (isSpline) {
+                    e.rational = curr.value;
+                } else {
+                    e.isCcw = curr.value;
+                }
+                break;
+            case 74:
+                e.periodic = curr.value;
+                break;
+            case 94:
+                e.degreeOfSplineCurve = curr.value;
+                break;
+
+            //XXX ignore some groups for now, mostly spline
+            case 95:
+            case 96:
+            case 40:
+            case 42:
+            case 97:
+                break;
+            default:
+                return e
+            }
+            curr = scanner.next();
+        }
+    }
+
+    let polylineParsed = false;
+    let numEdges = 0;
+    let numSourceRefs = 0;
+
+    while (true) {
+
+        if (!entity) {
+            if (curr.code != 92) {
+                return null;
+            }
+            entity = {type: curr.value};
+            curr = scanner.next();
+        }
+
+        if ((entity.type & 2) && !polylineParsed) {
+            entity.polyline = ParsePolyline()
+            polylineParsed = true
+        }
+
+        while (numEdges) {
+            const edge = ParseEdge();
+            if (edge) {
+                entity.edges.push(edge);
+                numEdges--;
+            } else {
+                numEdges = 0;
+            }
+        }
+
+        while (numSourceRefs) {
+            if (curr.code == 330) {
+                entity.sourceRefs.push(curr.value);
+                numSourceRefs--;
+                curr = scanner.next();
+            } else {
+                numSourceRefs = 0
+            }
+        }
+
+        switch (curr.code) {
+        case 93:
+            numEdges = curr.value;
+            if (numEdges > 0) {
+                entity.edges = []
+            }
+            break;
+        case 97:
+            numSourceRefs = curr.value;
+            if (numSourceRefs > 0) {
+                entity.sourceRefs = []
+            }
+            break;
+        default:
+            scanner.rewind();
+            return entity;
+        }
+        curr = scanner.next();
+    }
+}
+
+function ParseDefinitionLine(curr, scanner) {
+    /* Assuming always starts from group 53. */
+    if (curr.code != 53) {
+        return null
+    }
+    const entity = {
+        angle: curr.value * Math.PI / 180,
+        base: {x: 0, y: 0},
+        offset: {x: 0, y: 0}
+    };
+    curr = scanner.next();
+
+    let numDashes = 0;
+    while (true) {
+        switch (curr.code) {
+        case 43:
+            entity.base.x = curr.value;
+            break;
+        case 44:
+            entity.base.y = curr.value;
+            break;
+        case 45:
+            entity.offset.x = curr.value;
+            break;
+        case 46:
+            entity.offset.y = curr.value;
+            break;
+        case 49:
+            if (numDashes > 0) {
+                entity.dashes.push(curr.value);
+                numDashes--;
+            }
+            break;
+        case 79:
+            numDashes = curr.value;
+            if (curr.value) {
+                entity.dashes = []
+            }
+        default:
+            scanner.rewind();
+            return entity;
+        }
+        curr = scanner.next();
+    }
+}
+
+function ParseSeedPoint(curr, scanner) {
+    if (curr.code != 10) {
+        return null
+    }
+    return helpers.parsePoint(scanner);
+}

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

@@ -0,0 +1,62 @@
+
+import * as helpers from '../ParseHelpers.js'
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'INSERT';
+
+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 1:
+            entity.path = curr.value;
+            break;
+        case 2:
+            entity.name = curr.value;
+            break;
+        case 41:
+            entity.xScale = curr.value;
+            break;
+        case 42:
+            entity.yScale = curr.value;
+            break;
+        case 43:
+            entity.zScale = curr.value;
+            break;
+        case 10:
+            entity.position = helpers.parsePoint(scanner);
+            break;
+        case 50:
+            entity.rotation = curr.value;
+            break;
+        case 70:
+            entity.columnCount = curr.value;
+            break;
+        case 71:
+            entity.rowCount = curr.value;
+            break;
+        case 44:
+            entity.columnSpacing = curr.value;
+            break;
+        case 45:
+            entity.rowSpacing = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};
+
+