circuitscript 0.0.28 → 0.0.31

package/dist/esm/draw_symbols.mjs

@@ -1,10 +1,11 @@
-import { ReferenceTypes, SymbolPinSide, defaultFont } from "./globals.mjs";
+import { milsToMM } from "./helpers.mjs";
+import { ColorScheme, CustomSymbolParamTextSize, CustomSymbolPinIdSize, CustomSymbolPinTextSize, CustomSymbolRefDesSize, PortArrowSize, PortPaddingHorizontal, PortPaddingVertical, ReferenceTypes, SymbolPinSide, defaultFont, defaultPinIdTextSize, defaultPinNameTextSize, defaultSymbolLineWidth, fontDisplayScale } from "./globals.mjs";
 import { Geometry, GeometryProp, HorizontalAlign, Textbox, VerticalAlign } from "./geometry.mjs";
 import { PinTypes } from "./objects/PinTypes.mjs";
-const defaultSymbolLineWidth = 2;
+import { roundValue } from "./utils.mjs";
 export class SymbolGraphic {
     drawPortsName = true;
-    displayBounds = true;
+    displayBounds = false;
     drawing;
     _angle = 0;
     _flipX = 0;
@@ -51,6 +52,7 @@ export class SymbolGraphic {
         this.drawPins(innerGroup);
         this.drawLabels(innerGroup);
         this.drawPlaceRemove(innerGroup, extra);
+        this.displayBounds && this.drawBounds(group);
     }
     drawPlaceRemove(group, extra) {
         if (extra && extra.place === false) {
@@ -69,8 +71,8 @@ export class SymbolGraphic {
     pinPosition(id) {
         const pin = this.drawing.getPinPosition(id);
         const [x, y] = pin.start;
-        const useX = Math.round(x * 10000) / 10000;
-        const useY = Math.round(y * 10000 / 10000);
+        const useX = roundValue(x);
+        const useY = roundValue(y);
         return {
             x: useX,
             y: useY,
@@ -79,15 +81,16 @@ export class SymbolGraphic {
     }
     drawBounds(group) {
         const bbox = this.drawing.getBoundingBox();
-        group.circle(3)
-            .translate(-3 / 2, -3 / 2)
+        const originSize = milsToMM(10);
+        group.circle(originSize)
+            .translate(-originSize / 2, -originSize / 2)
             .fill('red')
             .stroke('none');
         group.rect(bbox.width, bbox.height)
             .translate(bbox.start[0], bbox.start[1])
             .fill('none')
             .stroke({
-            width: 1,
+            width: milsToMM(2),
             color: '#ccc',
         });
     }
@@ -104,17 +107,20 @@ export class SymbolGraphic {
         });
     }
     drawPins(group) {
-        group.path(this.drawing.getPinsPath())
-            .stroke({
-            width: defaultSymbolLineWidth,
-            color: '#333',
+        const pinPaths = this.drawing.getPinsPath();
+        pinPaths.forEach(({ path, lineColor }) => {
+            group.path(path)
+                .stroke({
+                width: defaultSymbolLineWidth,
+                color: lineColor
+            });
         });
     }
     drawLabels(group) {
         const labels = this.drawing.getLabels();
         labels.forEach(label => {
             const tmpLabel = label;
-            const { fontSize = 10, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', angle: labelAngle = 0, } = tmpLabel.style ?? {};
+            const { fontSize = 50, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', angle: labelAngle = 0, textColor = "#333", } = tmpLabel.style ?? {};
             let anchorStyle = 'start';
             let dominantBaseline = 'auto';
             let useAnchor = anchor;
@@ -155,15 +161,6 @@ export class SymbolGraphic {
             }
             const useFont = defaultFont;
             const textContainer = group.group();
-            const text = textContainer.text(tmpLabel.text)
-                .fill('#333')
-                .font({
-                family: useFont,
-                size: fontSize,
-                anchor: anchorStyle,
-                'dominant-baseline': dominantBaseline,
-                weight: fontWeight,
-            });
             let translateX, translateY;
             let useRotateAngle = 0;
             if (isRotation180) {
@@ -176,26 +173,121 @@ export class SymbolGraphic {
                 translateY = position[1];
                 useRotateAngle = this.angle;
             }
-            translateX = this.roundValues(translateX);
-            translateY = this.roundValues(translateY);
-            text.rotate(labelAngle);
+            translateX = roundValue(translateX);
+            translateY = roundValue(translateY);
+            const { portType = null } = tmpLabel.style;
+            if (portType !== null) {
+                const { x: boundsX, y: boundsY } = tmpLabel.textMeasurementBounds;
+                const paddingHorizontal = PortPaddingHorizontal;
+                const paddingVert = PortPaddingVertical;
+                const boundsWidth = tmpLabel.textMeasurementBounds.width
+                    + paddingHorizontal * 2;
+                const boundsHeight = tmpLabel.textMeasurementBounds.height
+                    + paddingVert * 2;
+                let path = [];
+                let boundsTranslateX = -paddingHorizontal;
+                switch (portType) {
+                    case PinTypes.Input:
+                        path = ['M', 0, 0,
+                            'L', boundsWidth, 0,
+                            'L', boundsWidth, boundsHeight,
+                            'L', 0, boundsHeight,
+                            'L', -PortArrowSize, boundsHeight / 2,
+                            'Z',
+                        ];
+                        break;
+                    case PinTypes.Output:
+                        path = ['M', 0, 0,
+                            'L', boundsWidth, 0,
+                            'L', boundsWidth + PortArrowSize,
+                            boundsHeight / 2,
+                            'L', boundsWidth, boundsHeight,
+                            'L', 0, boundsHeight,
+                            'Z',
+                        ];
+                        break;
+                    case PinTypes.IO:
+                        path = ['M', 0, 0,
+                            'L', boundsWidth, 0,
+                            'L', boundsWidth + PortArrowSize,
+                            boundsHeight / 2,
+                            'L', boundsWidth, boundsHeight,
+                            'L', 0, boundsHeight,
+                            'L', -PortArrowSize, boundsHeight / 2,
+                            'Z',
+                        ];
+                        break;
+                    case PinTypes.Any:
+                    case PinTypes.Power:
+                        path = ['M', 0, 0,
+                            'L', boundsWidth, 0,
+                            'L', boundsWidth, boundsHeight,
+                            'L', 0, boundsHeight,
+                            'Z',
+                        ];
+                        break;
+                }
+                if (path.length > 0) {
+                    let flip = 1;
+                    if (this.flipX !== 0) {
+                        flip = -1;
+                        boundsTranslateX = paddingHorizontal;
+                    }
+                    textContainer.path(path)
+                        .stroke({
+                        width: milsToMM(5),
+                        color: '#333'
+                    })
+                        .fill('none')
+                        .scale(flip, 1, 0, 0)
+                        .translate(boundsTranslateX, boundsY - paddingVert);
+                }
+            }
+            const drawTextBounds = false;
+            const drawBoxBounds = false;
+            const drawOrigin = false;
+            if (drawBoxBounds) {
+                const box = tmpLabel.box;
+                textContainer.rect(box.width, box.height).fill('red')
+                    .translate(box.xmin, box.ymin)
+                    .scale(this.flipX !== 0 ? -1 : 1, 1, -box.xmin, box.ymin);
+            }
+            if (drawTextBounds) {
+                const textBounds = tmpLabel.textMeasurementBounds;
+                const xOffset = (this.flipX !== 0) ? textBounds.width : 0;
+                textContainer.rect(textBounds.width, textBounds.height).fill('#cccccc')
+                    .translate(textBounds.x - xOffset, textBounds.y);
+            }
             textContainer.translate(translateX, translateY)
                 .rotate(useRotateAngle, -translateX, -translateY);
+            textContainer.text(tmpLabel.text)
+                .fill(textColor)
+                .font({
+                family: useFont,
+                size: fontSize * fontDisplayScale,
+                anchor: anchorStyle,
+                'dominant-baseline': dominantBaseline,
+                weight: fontWeight,
+            })
+                .rotate(labelAngle);
             const { a, b, c, d, e, f } = textContainer.matrix();
             const newMatrix = {
-                a: this.roundValues(a),
-                b: this.roundValues(b),
-                c: this.roundValues(c),
-                d: this.roundValues(d),
-                e: this.roundValues(e),
-                f: this.roundValues(f),
+                a: roundValue(a),
+                b: roundValue(b),
+                c: roundValue(c),
+                d: roundValue(d),
+                e: roundValue(e),
+                f: roundValue(f),
             };
             textContainer.transform(newMatrix);
+            if (drawOrigin) {
+                const originSize = milsToMM(10);
+                textContainer.circle(originSize)
+                    .translate(originSize / 2, originSize / 2)
+                    .fill('green');
+            }
         });
     }
-    roundValues(value) {
-        return +value.toFixed(7);
-    }
     flipTextAnchor(value) {
         if (value === HorizontalAlign.Left) {
             return HorizontalAlign.Right;
@@ -244,7 +336,7 @@ export class SymbolPointHidden extends SymbolGraphic {
 }
 export class SymbolText extends SymbolGraphic {
     text;
-    fontSize = 10;
+    fontSize = 40;
     fontWeight = 'regular';
     constructor(text) {
         super();
@@ -268,8 +360,16 @@ export class SymbolPlaceholder extends SymbolGraphic {
         drawing.angle = this._angle;
         drawing.flipX = this._flipX;
         drawing.flipY = this._flipY;
-        const commands = drawing.getCommands();
+        const commands = [
+            [PlaceHolderCommands.units, ['mils'], {}],
+            [PlaceHolderCommands.lineColor, [ColorScheme.PinLineColor], {}],
+            [PlaceHolderCommands.textColor, [ColorScheme.PinNameColor], {}],
+            [PlaceHolderCommands.lineWidth, [5], {}],
+            ...drawing.getCommands()
+        ];
         drawing.log('id: ', drawing.id, 'angle: ', this._angle, "commands:", commands.length);
+        let lineColor = "#333";
+        let textColor = "#333";
         commands.forEach(([commandName, positionParams, keywordParams]) => {
             switch (commandName) {
                 case PlaceHolderCommands.rect:
@@ -299,6 +399,11 @@ export class SymbolPlaceholder extends SymbolGraphic {
                     break;
                 case PlaceHolderCommands.lineColor:
                     drawing.addSetLineColor(...positionParams);
+                    lineColor = positionParams[0];
+                    break;
+                case PlaceHolderCommands.textColor:
+                    drawing.addSetTextColor(...positionParams);
+                    textColor = positionParams[0];
                     break;
                 case PlaceHolderCommands.arc:
                     drawing.addArc(...positionParams);
@@ -313,11 +418,14 @@ export class SymbolPlaceholder extends SymbolGraphic {
                 case PlaceHolderCommands.hpin:
                 case PlaceHolderCommands.vpin:
                     {
-                        this.drawPinParams(drawing, commandName, keywordParams, positionParams);
+                        this.drawPinParams(drawing, commandName, keywordParams, positionParams, lineColor, textColor);
                         break;
                     }
                 case PlaceHolderCommands.label: {
                     const style = this.parseLabelStyle(keywordParams);
+                    if (style['textColor'] === undefined) {
+                        style['textColor'] = textColor;
+                    }
                     positionParams = [...positionParams];
                     positionParams.push(style);
                     const labelId = positionParams[0];
@@ -343,12 +451,17 @@ export class SymbolPlaceholder extends SymbolGraphic {
                     drawing.addTextbox(offsetX, offsetY, content, style);
                     break;
                 }
+                case PlaceHolderCommands.units: {
+                    drawing.addSetUnits(...positionParams);
+                    break;
+                }
             }
         });
         drawing.log("=== end generate drawing ===");
     }
     parseLabelStyle(keywordParams) {
-        const keywords = ['fontSize', 'anchor', 'vanchor', 'angle'];
+        const keywords = ['fontSize', 'anchor', 'vanchor',
+            'angle', 'textColor', 'portType'];
         const style = {};
         keywords.forEach(item => {
             if (keywordParams.has(item)) {
@@ -357,13 +470,16 @@ export class SymbolPlaceholder extends SymbolGraphic {
         });
         return style;
     }
-    drawPinParams(drawing, commandName, keywordParams, positionParams) {
+    drawPinParams(drawing, commandName, keywordParams, positionParams, lineColor, pinNameColor) {
         drawing.log('add pin', ...positionParams);
+        positionParams = [...positionParams];
         const keywordDisplayPinId = 'display_pin_id';
         let displayPinId = true;
-        if (keywordParams.has(keywordDisplayPinId)
-            && keywordParams.get(keywordDisplayPinId) === 0) {
-            displayPinId = false;
+        if (keywordParams.has(keywordDisplayPinId)) {
+            const value = keywordParams.get(keywordDisplayPinId);
+            if (value === 0 || value === false) {
+                displayPinId = false;
+            }
         }
         let pinNameParam = null;
         let pinType = PinTypes.Any;
@@ -375,10 +491,10 @@ export class SymbolPlaceholder extends SymbolGraphic {
             pinNameParam = positionParams[1];
             positionParams = [positionParams[0], ...positionParams.slice(2)];
         }
-        const startX = positionParams[1];
-        const startY = positionParams[2];
+        const startX = milsToMM(positionParams[1]);
+        const startY = milsToMM(positionParams[2]);
         if (commandName === PlaceHolderCommands.vpin) {
-            const magnitude = positionParams[3];
+            const magnitude = milsToMM(positionParams[3]);
             positionParams = [
                 positionParams[0],
                 startX,
@@ -388,7 +504,7 @@ export class SymbolPlaceholder extends SymbolGraphic {
             ];
         }
         else if (commandName === PlaceHolderCommands.hpin) {
-            const magnitude = positionParams[3];
+            const magnitude = milsToMM(positionParams[3]);
             positionParams = [
                 positionParams[0],
                 startX,
@@ -397,50 +513,64 @@ export class SymbolPlaceholder extends SymbolGraphic {
                 startY
             ];
         }
-        drawing.addPin(...positionParams);
+        else {
+            const [, , , endX, endY] = positionParams;
+            positionParams = [
+                positionParams[0],
+                startX,
+                startY,
+                milsToMM(endX),
+                milsToMM(endY)
+            ];
+        }
+        drawing.addPinMM(...positionParams, lineColor);
         const lastAddedPin = this.drawing.pins[this.drawing.pins.length - 1];
         const [pinId, , angle] = lastAddedPin;
         const [, , , endX, endY] = positionParams;
         let pinNameAlignment = HorizontalAlign.Left;
-        let pinNameOffsetX = 4;
+        const offset1 = 15;
+        const offset2 = 15;
+        let pinNameOffsetX = milsToMM(offset1);
         let pinIdOffsetX = 0;
         let pinIdAlignment = HorizontalAlign.Left;
         let pinIdVAlignment = VerticalAlign.Bottom;
-        let pinIdOffsetY = -2;
+        let pinIdOffsetY = milsToMM(-offset2);
         switch (angle) {
             case 0:
                 pinNameAlignment = HorizontalAlign.Left;
-                pinNameOffsetX = 4;
+                pinNameOffsetX = milsToMM(offset1);
                 pinIdAlignment = HorizontalAlign.Right;
-                pinIdOffsetX = -2;
+                pinIdOffsetX = milsToMM(-offset2);
                 break;
             case 90:
             case 180:
                 pinNameAlignment = HorizontalAlign.Right;
-                pinNameOffsetX = -4;
+                pinNameOffsetX = milsToMM(-offset1);
                 pinIdAlignment = HorizontalAlign.Left;
-                pinIdOffsetX = 2;
+                pinIdOffsetX = milsToMM(offset2);
                 break;
             case 270:
                 pinNameAlignment = HorizontalAlign.Left;
-                pinNameOffsetX = 4;
+                pinNameOffsetX = milsToMM(offset1);
                 pinIdAlignment = HorizontalAlign.Left;
-                pinIdOffsetX = 2;
-                pinIdOffsetY = 2;
+                pinIdOffsetX = milsToMM(offset2);
+                pinIdOffsetY = milsToMM(offset2);
                 pinIdVAlignment = VerticalAlign.Top;
                 break;
         }
         if (angle === 0 || angle === 90 || angle === 180 || angle === 270) {
             const usePinName = pinNameParam ?? "";
             usePinName !== "" && drawing.addLabel(endX + pinNameOffsetX, endY, usePinName, {
-                fontSize: 10,
+                fontSize: defaultPinNameTextSize,
                 anchor: pinNameAlignment,
                 vanchor: VerticalAlign.Middle,
+                textColor: pinNameColor,
             });
             displayPinId && drawing.addLabel(endX + pinIdOffsetX, endY + pinIdOffsetY, pinId.toString(), {
-                fontSize: 8,
+                fontSize: defaultPinIdTextSize,
                 anchor: pinIdAlignment,
                 vanchor: pinIdVAlignment,
+                textColor: lineColor
             });
         }
     }
@@ -466,16 +596,18 @@ export var PlaceHolderCommands;
     PlaceHolderCommands["lineWidth"] = "lineWidth";
     PlaceHolderCommands["fill"] = "fill";
     PlaceHolderCommands["lineColor"] = "lineColor";
+    PlaceHolderCommands["textColor"] = "textColor";
     PlaceHolderCommands["text"] = "text";
+    PlaceHolderCommands["units"] = "units";
 })(PlaceHolderCommands || (PlaceHolderCommands = {}));
 export class SymbolCustom extends SymbolGraphic {
     pinDefinition = [];
-    bodyWidth = 100;
-    pinLength = 20;
-    width = 100;
-    height = 100;
-    pinSpacing = 20;
-    pinTextPadding = 5;
+    bodyWidth = milsToMM(400);
+    pinLength = milsToMM(100);
+    width = milsToMM(100);
+    height = milsToMM(100);
+    pinSpacing = milsToMM(100);
+    pinTextPadding = milsToMM(5);
     pins = [];
     _cacheLeftPins;
     _cacheRightPins;
@@ -498,65 +630,109 @@ export class SymbolCustom extends SymbolGraphic {
         drawing.flipY = this._flipY;
         const bodyWidth = this.bodyWidth;
         const bodyHeight = (1 + Math.max(maxLeftPins, maxRightPins)) * this.pinSpacing;
-        drawing.addRect(0, 0, bodyWidth, bodyHeight);
-        const leftPinStart = -bodyWidth / 2;
-        const rightPinStart = bodyWidth / 2;
-        const pinStartY = -bodyHeight / 2;
+        const defaultLineColor = ColorScheme.PinLineColor;
+        drawing.addSetLineColor(defaultLineColor);
+        drawing.addSetLineWidth(5);
+        drawing.addRectMM(0, 0, bodyWidth, bodyHeight);
+        this.generateDrawingPins(drawing, bodyWidth, bodyHeight, leftPins, rightPins, defaultLineColor);
+        this.drawing = drawing;
+        this._cacheLeftPins = leftPins;
+        this._cacheRightPins = rightPins;
+    }
+    generateDrawingPins(drawing, bodyWidthMM, bodyHeightMM, leftPins, rightPins, defaultLineColor) {
+        const leftPinStart = -bodyWidthMM / 2;
+        const rightPinStart = bodyWidthMM / 2;
+        const pinStartY = -bodyHeightMM / 2;
         leftPins.forEach(pin => {
             const position = pin.position;
             const pinY = pinStartY + (position + 1) * this.pinSpacing;
-            drawing.addPin(pin.pinId, leftPinStart - this.pinLength, pinY, leftPinStart, pinY);
-            drawing.addLabel(leftPinStart + 4, pinY, pin.text, {
-                fontSize: 10,
+            drawing.addPinMM(pin.pinId, leftPinStart - this.pinLength, pinY, leftPinStart, pinY, defaultLineColor);
+            drawing.addLabel(leftPinStart + milsToMM(20), pinY, pin.text, {
+                fontSize: CustomSymbolPinTextSize,
                 anchor: HorizontalAlign.Left,
                 vanchor: VerticalAlign.Middle,
+                textColor: ColorScheme.PinNameColor,
             });
-            drawing.addLabel(leftPinStart - 2, pinY - 2, pin.pinId.toString(), {
-                fontSize: 8,
+            drawing.addLabel(leftPinStart - milsToMM(10), pinY - milsToMM(10), pin.pinId.toString(), {
+                fontSize: CustomSymbolPinIdSize,
                 anchor: HorizontalAlign.Right,
                 vanchor: VerticalAlign.Bottom,
+                textColor: defaultLineColor
             });
         });
         rightPins.forEach(pin => {
             const position = pin.position;
             const pinY = pinStartY + (position + 1) * this.pinSpacing;
-            drawing.addPin(pin.pinId, rightPinStart + this.pinLength, pinY, rightPinStart, pinY);
-            drawing.addLabel(rightPinStart - 4, pinY, pin.text, {
-                fontSize: 10,
+            drawing.addPinMM(pin.pinId, rightPinStart + this.pinLength, pinY, rightPinStart, pinY, defaultLineColor);
+            drawing.addLabel(rightPinStart - milsToMM(20), pinY, pin.text, {
+                fontSize: CustomSymbolPinTextSize,
                 anchor: HorizontalAlign.Right,
                 vanchor: VerticalAlign.Middle,
+                textColor: ColorScheme.PinNameColor,
             });
-            drawing.addLabel(rightPinStart + 2, pinY - 2, pin.pinId.toString(), {
-                fontSize: 8,
+            drawing.addLabel(rightPinStart + milsToMM(10), pinY - milsToMM(10), pin.pinId.toString(), {
+                fontSize: CustomSymbolPinIdSize,
                 anchor: HorizontalAlign.Left,
                 vanchor: VerticalAlign.Bottom,
+                textColor: defaultLineColor
             });
         });
         const instanceName = this.getLabelValue("refdes");
-        instanceName && drawing.addLabel(-bodyWidth / 2, -bodyHeight / 2 - 4, instanceName, {
-            fontSize: 10,
+        instanceName && drawing.addLabel(-bodyWidthMM / 2, -bodyHeightMM / 2 - milsToMM(20), instanceName, {
+            fontSize: CustomSymbolRefDesSize,
             anchor: HorizontalAlign.Left,
         });
         const acceptedMPNKeys = ['MPN', 'mpn', 'manufacturer_pn'];
         acceptedMPNKeys.some(key => {
             const labelValue = this.getLabelValue(key);
             if (labelValue !== undefined) {
-                drawing.addLabel(-bodyWidth / 2, bodyHeight / 2 + 4, labelValue, {
-                    fontSize: 10,
+                drawing.addLabel(-bodyWidthMM / 2, bodyHeightMM / 2 + milsToMM(20), labelValue, {
+                    fontSize: CustomSymbolParamTextSize,
                     anchor: HorizontalAlign.Left,
                     vanchor: VerticalAlign.Top,
                 });
             }
         });
-        this.drawing = drawing;
-        this._cacheLeftPins = leftPins;
-        this._cacheRightPins = rightPins;
     }
     calculateSize() {
         this.width = this.bodyWidth + 2 * this.pinLength;
         this.height = (1 + Math.max(this._cacheLeftPins.length, this._cacheRightPins.length)) * this.pinSpacing;
     }
 }
+export class SymbolCustomModule extends SymbolCustom {
+    pinLength = 0;
+    portWidth = milsToMM(100);
+    portHeight = milsToMM(50);
+    generateDrawingPins(drawing, bodyWidthMM, bodyHeightMM, leftPins, rightPins, defaultLineColor) {
+        const leftPinStart = -bodyWidthMM / 2;
+        const rightPinStart = bodyWidthMM / 2;
+        const pinStartY = -bodyHeightMM / 2;
+        leftPins.forEach(pin => {
+            const position = pin.position;
+            const pinY = pinStartY + (position + 1) * this.pinSpacing;
+            drawing.addPinMM(pin.pinId, leftPinStart - this.pinLength, pinY, leftPinStart, pinY, defaultLineColor);
+            drawing.addModulePort(leftPinStart, pinY, this.portWidth, this.portHeight, pin.pinType);
+            drawing.addLabel(leftPinStart + this.portWidth + milsToMM(20), pinY, pin.text, {
+                fontSize: 40,
+                anchor: HorizontalAlign.Left,
+                vanchor: VerticalAlign.Middle,
+                textColor: ColorScheme.PinNameColor,
+            });
+        });
+        rightPins.forEach(pin => {
+            const position = pin.position;
+            const pinY = pinStartY + (position + 1) * this.pinSpacing;
+            drawing.addPinMM(pin.pinId, rightPinStart + this.pinLength, pinY, rightPinStart, pinY, defaultLineColor);
+            drawing.addModulePort(rightPinStart, pinY, this.portWidth, this.portHeight, pin.pinType, -1);
+            drawing.addLabel(rightPinStart - this.portWidth - milsToMM(20), pinY, pin.text, {
+                fontSize: 40,
+                anchor: HorizontalAlign.Right,
+                vanchor: VerticalAlign.Middle,
+                textColor: ColorScheme.PinNameColor,
+            });
+        });
+    }
+}
 export class SymbolDrawing {
     items = [];
     pins = [];
@@ -573,43 +749,68 @@ export class SymbolDrawing {
         this.logger && this.logger.add(params.join(' '));
     }
     addLine(startX, startY, endX, endY) {
+        startX = milsToMM(startX);
+        startY = milsToMM(startY);
+        endX = milsToMM(endX);
+        endY = milsToMM(endY);
         this.items.push(Geometry.segment([startX, startY], [endX, endY]));
         return this;
     }
-    addPin(pinId, startX, startY, endX, endY) {
+    addPin(pinId, startX, startY, endX, endY, lineColor) {
+        startX = milsToMM(startX);
+        startY = milsToMM(startY);
+        endX = milsToMM(endX);
+        endY = milsToMM(endY);
+        return this.addPinMM(pinId, startX, startY, endX, endY, lineColor);
+    }
+    addPinMM(pinId, startXMM, startYMM, endXMM, endYMM, lineColor) {
         let angle = 0;
-        if (startX === endX) {
-            if (startY > endY) {
+        if (startXMM === endXMM) {
+            if (startYMM > endYMM) {
                 angle = 270;
             }
-            else if (startY < endY) {
+            else if (startYMM < endYMM) {
                 angle = 90;
             }
         }
         else {
-            if (startX < endX) {
+            if (startXMM < endXMM) {
                 angle = 0;
             }
-            else if (startX > endX) {
+            else if (startXMM > endXMM) {
                 angle = 180;
             }
         }
         this.pins.push([
             pinId,
-            Geometry.segment([startX, startY], [endX, endY]),
-            angle
+            Geometry.segment([startXMM, startYMM], [endXMM, endYMM]),
+            angle,
+            lineColor
         ]);
         return this;
     }
     addVLine(startX, startY, value) {
+        startX = milsToMM(startX);
+        startY = milsToMM(startY);
+        value = milsToMM(value);
         this.items.push(Geometry.segment([startX, startY], [startX, startY + value]));
         return this;
     }
     addHLine(startX, startY, value) {
+        startX = milsToMM(startX);
+        startY = milsToMM(startY);
+        value = milsToMM(value);
         this.items.push(Geometry.segment([startX, startY], [startX + value, startY]));
         return this;
     }
     addRect(centerX, centerY, width, height) {
+        centerX = milsToMM(centerX);
+        centerY = milsToMM(centerY);
+        width = milsToMM(width);
+        height = milsToMM(height);
+        return this.addRectMM(centerX, centerY, width, height);
+    }
+    addRectMM(centerX, centerY, width, height) {
         const width2 = width / 2;
         const height2 = height / 2;
         this.items.push(Geometry.polygon([
@@ -622,6 +823,11 @@ export class SymbolDrawing {
         return this;
     }
     addTriangle(startX, startY, endX, endY, width) {
+        startX = milsToMM(startX);
+        startY = milsToMM(startY);
+        endX = milsToMM(endX);
+        endY = milsToMM(endY);
+        width = milsToMM(width);
         const line = Geometry.line(startX, startY, endX, endY);
         const normLine = line.norm;
         const dx1 = normLine.x * width / 2;
@@ -651,13 +857,67 @@ export class SymbolDrawing {
         return this;
     }
     addLabelId(id, x, y, textValue, style) {
+        x = milsToMM(x);
+        y = milsToMM(y);
         this.items.push(Geometry.label(id, x, y, textValue, style));
         return this;
     }
     addTextbox(x, y, textValue, style) {
+        x = milsToMM(x);
+        y = milsToMM(y);
         this.items.push(Geometry.textbox(null, x, y, textValue, style));
         return this;
     }
+    addModulePort(x, y, width, height, portType = PinTypes.Any, scaleX = 1) {
+        const height2 = height / 2;
+        let path = [];
+        const arrowSize = milsToMM(30);
+        if (portType === PinTypes.Any) {
+            path = [
+                [0, -height2],
+                [width, -height2],
+                [width, +height2],
+                [0, +height2],
+                [0, -height2]
+            ];
+        }
+        else if (portType === PinTypes.Output) {
+            path = [
+                [arrowSize, -height2],
+                [width, -height2],
+                [width, height2],
+                [arrowSize, height2],
+                [0, 0],
+                [arrowSize, -height2]
+            ];
+        }
+        else if (portType === PinTypes.Input) {
+            path = [
+                [0, -height2],
+                [width - arrowSize, -height2],
+                [width, 0],
+                [width - arrowSize, height2],
+                [0, +height2],
+                [0, -height2],
+            ];
+        }
+        else if (portType === PinTypes.IO) {
+            path = [
+                [arrowSize, -height2],
+                [width - arrowSize, -height2],
+                [width, 0],
+                [width - arrowSize, +height2],
+                [arrowSize, +height2],
+                [0, 0],
+                [0 + arrowSize, -height2],
+            ];
+        }
+        path = path.map(point => {
+            return [x + point[0] * scaleX, y + point[1]];
+        });
+        this.items.push(Geometry.polygon(path));
+        return this;
+    }
     addPath(...pathParts) {
         const parts = pathParts.reduce((accum, tmp) => {
             if (typeof tmp === "string") {
@@ -676,14 +936,14 @@ export class SymbolDrawing {
                 if (currentObj !== null) {
                     geomObjects.push(currentObj);
                 }
-                const x = Number(parts[i + 1]);
-                const y = Number(parts[i + 2]);
+                const x = milsToMM(Number(parts[i + 1]));
+                const y = milsToMM(Number(parts[i + 2]));
                 currentObj = [[x, y]];
                 i += 2;
             }
             else if (command === 'L') {
-                const x = Number(parts[i + 1]);
-                const y = Number(parts[i + 2]);
+                const x = milsToMM(Number(parts[i + 1]));
+                const y = milsToMM(Number(parts[i + 2]));
                 currentObj.push([x, y]);
                 i += 2;
             }
@@ -709,6 +969,7 @@ export class SymbolDrawing {
         return this;
     }
     addSetLineWidth(value) {
+        value = milsToMM(value);
         this.items.push(new GeometryProp('lineWidth', value));
         return this;
     }
@@ -716,16 +977,27 @@ export class SymbolDrawing {
         this.items.push(new GeometryProp('lineColor', value));
         return this;
     }
+    addSetTextColor(value) {
+        this.items.push(new GeometryProp('textColor', value));
+        return this;
+    }
     addSetFillColor(value) {
         this.items.push(new GeometryProp('fillColor', value));
         return this;
     }
     addArc(x, y, radius, startAngle, endAngle) {
+        x = milsToMM(x);
+        y = milsToMM(y);
+        radius = milsToMM(radius);
         startAngle = startAngle * Math.PI / 180;
         endAngle = endAngle * Math.PI / 180;
         this.items.push(Geometry.arc([x, y], radius, startAngle, endAngle, true));
         return this;
     }
+    addSetUnits(value) {
+        this.items.push(new GeometryProp('units', value));
+        return this;
+    }
     getPaths() {
         let currentFill = "#fff";
         let currentLineWidth = 1;
@@ -760,11 +1032,15 @@ export class SymbolDrawing {
         return pathItems;
     }
     getPinsPath() {
-        let features = this.pins.map(item => item[1]);
-        features = Geometry.groupFlip(features, this.flipX, this.flipY);
-        features = Geometry.groupRotate(features, this.angle, this.mainOrigin);
-        const { path } = this.featuresToPath(features, this.flipX, this.flipY);
-        return path;
+        return this.pins.map(item => {
+            let features = Geometry.groupFlip([item[1]], this.flipX, this.flipY);
+            features = Geometry.groupRotate(features, this.angle, this.mainOrigin);
+            const { path } = this.featuresToPath(features, this.flipX, this.flipY);
+            return {
+                path,
+                lineColor: item[3],
+            };
+        });
     }
     getLabels() {
         return this.items.filter(item => item instanceof Textbox);