TypeScript DiagramNode.DiagramNode类代码示例

 public createBlock(node: DiagramNode, outboundLinks: Link[], interpreter: Interpreter, 
                    robotModels: RobotModel[]): AbstractBlock {
     switch (node.getType()) {
         case "InitialNode":
             return new InitialBlock(node, outboundLinks);
         case "FinalNode":
             return new FinalBlock(node, outboundLinks);
         case "IfBlock":
             return new IfBlock(node, outboundLinks, interpreter);
         case "Function":
             return new FunctionBlock(node, outboundLinks, interpreter);                
         case "TrikV6EnginesForward":
             return new MotorsForwardBlock(node, outboundLinks, robotModels, interpreter);
         case "TrikV6EnginesBackward":
             return new MotorsBackwardBlock(node, outboundLinks, robotModels, interpreter);
         case "TrikV6EnginesStop":
             return new MotorsStopBlock(node, outboundLinks, robotModels);
         case "Timer":
             return new TimerBlock(node, outboundLinks, interpreter);
         case "SwitchBlock":
             return new SwitchBlock(node, outboundLinks, interpreter);
         case "MarkerUp":
             return new MarkerUpBlock(node, outboundLinks, robotModels);
         case "MarkerDown":
             return new MarkerDownBlock(node, outboundLinks, robotModels);
         case "VariableInit":
             return new VariableInitBlock(node, outboundLinks, interpreter);
         case "Randomizer":
             return new RandomInitBlock(node, outboundLinks, interpreter);
         case "FiBlock":
             return new EndIfBlock(node, outboundLinks);
         case "TrikSadSmile":
             return new TrikSadSmileBlock(node, outboundLinks, robotModels);
         case "TrikSmile":
             return new TrikSmileBlock(node, outboundLinks, robotModels);
         case "TrikSetPainterColor":
             return new TrikSetPainterColorBlock(node, outboundLinks, interpreter);
         case "TrikSetPainterWidth":
             return new TrikSetPainterWidthBlock(node, outboundLinks, interpreter);
         case "TrikDrawEllipse":
             return new TrikDrawEllipseBlock(node, outboundLinks, interpreter, robotModels);
         case "ClearScreen":
             return new ClearScreenBlock(node, outboundLinks, robotModels);
         case "TrikDrawPixel":
             return new TrikDrawPixelBlock(node, outboundLinks, interpreter, robotModels);
         case "TrikDrawLine":
             return new TrikDrawLineBlock(node, outboundLinks, interpreter, robotModels);
         case "TrikDrawRect":
             return new TrikDrawRectBlock(node, outboundLinks, interpreter, robotModels);
         case "TrikSetBackground":
             return new TrikSetBackgroundBlock(node, outboundLinks, robotModels);
         case "PrintText":
             return new PrintTextBlock(node, outboundLinks, interpreter, robotModels);
         default:
             throw new Error("Block " + node.getType() + " is not supported");
     }
 }

 private findInitialNodeId(nodesMap: Map<String, DiagramNode>): string {
     for (var id in nodesMap) {
         if (nodesMap.hasOwnProperty(id)) {
             var node: DiagramNode = nodesMap[id];
             if (node.getType() === "InitialNode") {
                 return node.getJointObject().id;
             }
         }
     }
     throw new Error("Initial node was not found");
 }

    protected exportNodes(graph: joint.dia.Graph, diagramParts: DiagramParts) {
        var nodes = [];

        for (var id in diagramParts.nodesMap) {
            var node: DiagramNode = diagramParts.nodesMap[id];
            var newNode = new TDefaultDiagramNode();
            newNode.logicalId = node.getLogicalId();
            newNode.graphicalId = node.getJointObject().id;
            newNode.type = node.getType();
            newNode.properties = this.exportProperties(node.getChangeableProperties());

            var nameProperty = new TProperty();
            nameProperty.name = "name";
            nameProperty.value = node.getName();
            nameProperty.type = "string";
            newNode.properties.push(nameProperty);

            var positionProperty = new TProperty();
            positionProperty.name = "position";
            positionProperty.value = "" + node.getX() + ", " + node.getY();
            positionProperty.type = "QPointF";
            newNode.properties.push(positionProperty);

            var sizeProperty = new TProperty();
            sizeProperty.name = "size";
            sizeProperty.value = node.getSize();
            sizeProperty.type = "string";
            newNode.properties.push(sizeProperty);

            nodes.push(newNode);
        }

        return nodes;
    }

    private getEntities(nodesMap: Map<String, DiagramNode>, linksMap: Map<String, Link>) {
        var nodes = [];
        for (var id in nodesMap) {
            var node: DiagramNode = nodesMap[id];
            if (node.getName() === "entity") {
                var newNode = new TNode();
                newNode.name = node.getChangeableProperties()['name'].value;
                newNode.image = GeneralConstants.APP_ROOT_PATH + "images/" + node.getChangeableProperties()['image'].value + ".svg";
                newNode.properties = this.getProperties(nodesMap, linksMap, node);

                nodes.push(newNode);
            }
        }
        return nodes;
    }

 private getOutboundLinks(graph: joint.dia.Graph, node: DiagramNode, linksMap: Map<String, Link>): Link[] {
     var links: Link[] = [];
     var cell = graph.getCell(node.getJointObject().id);
     var jointOutboundLinks: joint.dia.Link[] = graph.getConnectedLinks(cell, { outbound : true });
     jointOutboundLinks.forEach((jointLink) => links.push(linksMap[jointLink.id]));
     return links;
 }

    protected exportNodes(nodesMap: Map<String, DiagramNode>, linksMap: Map<String, Link>) {
        var nodes = [];

        var initial: string;
        for (var i in nodesMap) {
            var target: boolean = false;
            var node: DiagramNode = nodesMap[i];
            for (var id in linksMap) {
                var link = linksMap[id];
                var jointObject = link.getJointObject();
                if (nodesMap[jointObject.get('target').id] === node) {
                    target = true;
                    break;
                }
            }
            if (target === false) {
                initial = i;
                break;
            }
        }

        var existNext: boolean = true;
        while (existNext) {
            existNext = false;
            var node: DiagramNode = nodesMap[initial];
            var newNode = new TNode();
            newNode.name = node.getName();
            newNode.properties = this.exportProperties(node.getChangeableProperties());
            for (var id in linksMap) {
                var link = linksMap[id];
                var jointObject = link.getJointObject();
                if (nodesMap[jointObject.get('source').id] === node) {
                    initial = jointObject.get('target').id;
                    existNext = true;
                }
            }
            nodes.push(newNode);
        }

        return nodes;
    }

 public checkRangeNumberOfOutboundLinks(minNumber: number, maxNumber: number): void {
     if (this.outboundLinks.length < minNumber) {
         throw new Error("There must be at least " + minNumber + " links from " + this.node.getName());
     }
     if (this.outboundLinks.length > maxNumber) {
         throw new Error("There more than " + maxNumber + " links from " + this.node.getName());
     }
 }

 public checkExpectedNumberOfOutboundLinks(expectedNumber: number): void {
     if (this.outboundLinks.length !== expectedNumber) {
         throw new Error("There must be exact " + expectedNumber + " links from " + this.node.getName());
     }
 }