import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
protected void setDummyEdges() {
	Node targetNode = null;
	int nodeCount = nodeList.size();

	// if node count is only one then we don't have to worry about whether
	// the nodes are connected
	if (nodeCount > 1) {
		for (Iterator iter = nodeList.iterator(); iter.hasNext();) {
			Node sourceNode = (Node) iter.next();
			// we will need to set up a dummy relationship for any table not
			// in one already
			if (sourceNode.outgoing.size() == 0 && sourceNode.incoming.size() == 0) {
				targetNode = findTargetNode(sourceNode);
				Edge edge = newDummyEdge(targetNode, sourceNode);
				edgesAdded.add(edge);
			}
		}
	}
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
protected void addEdges(AbstractGraphicalEditPart diagram) {
	for (Object obj : diagram.getChildren()) {
		AbstractGraphicalEditPart part = (AbstractGraphicalEditPart) obj;
		for (Object item : part.getSourceConnections()) {
			RelationshipPart rpart = (RelationshipPart) item;
			Node source = (Node) partToNodesMap.get(rpart.getSource());
			Node target = (Node) partToNodesMap.get(rpart.getTarget());
			if (source != null && target != null) {
				Edge e = new Edge(rpart, source, target);
				e.weight = 2;
				graph.edges.add(e);
				partToNodesMap.put(rpart, e);
			}
		}
	}
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
protected void applyChildrenResults(AbstractGraphicalEditPart diagram) {
	List<AbstractGraphicalEditPart> children = diagram.getChildren();
	Rectangle r = diagram.getFigure().getBounds();
	for (AbstractGraphicalEditPart tp : children) {
		Node n = (Node) partToNodesMap.get(tp);
		IFigure f = tp.getFigure();

		Dimension psize = f.getPreferredSize();
		f.setBounds(new Rectangle(r.x + n.x, r.y + n.y, psize.width,
				psize.height));

		List<RelationshipPart> sc = tp.getSourceConnections();
		for (RelationshipPart rp : sc)
			applyResults(rp);
	}
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * Locates the nodes.
 */
private void locateNode() {
    int xPoint = BASE_POINT_X;
    int yPoint = BASE_POINT_Y;

    NodeList baseNodeList = getGraph().getBaseNodeList();
    for (int i = 0; i < baseNodeList.size(); i++) {
        Node node = baseNodeList.getNode(i);
        NodeEx nodeEx = getNodeEx(node);

        Rectangle rect = nodeEx.getBlockBounds();
        locateNode(nodeEx, xPoint, yPoint);
        if (ArrangeAngle.createInstance().getAngle() == ArrangeAngle.Direction.Vertical) {
            xPoint += rect.width + HORIZONTAL_SPACING;
        } else {
            yPoint += rect.height + VERTICAL_SPACING;
        }
    }
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * Returns the children those should be locate to the south.
 * 
 * @return the children those should be locate to the south.
 */
@SuppressWarnings("unchecked")
public NodeList getSouthNodes() {
    EdgeList edgeList = new EdgeList();
    NodeList nodeList = new NodeList();
    for (Object obj : node.outgoing) {
        if (!DcaseDirectedGraph.isEast((Node) ((Edge) obj).target)) {
            edgeList.add(obj);
        }
    }
    // sorts by the sibling order.
    if (edgeList.size() > 1) {
        Collections.sort(edgeList, new DcaseEditPartLayoutComparator());
    }
    for (int i = 0; i < edgeList.size(); i++) {
        nodeList.add(((Edge) edgeList.get(i)).target);
    }
    return nodeList;
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * Returns the children those should be locate to the east.
 * 
 * @return the children those should be locate to the east.
 */
@SuppressWarnings("unchecked")
public NodeList getEastNodes() {
    EdgeList edgeList = new EdgeList();
    NodeList nodeList = new NodeList();
    for (Object obj : node.outgoing) {
        if (DcaseDirectedGraph.isEast((Node) ((Edge) obj).target)) {
            edgeList.add(obj);
        }
    }
    // sorts by the sibling order.
    if (edgeList.size() > 1) {
        Collections.sort(edgeList, new DcaseEditPartLayoutComparator());
    }
    for (int i = 0; i < edgeList.size(); i++) {
        nodeList.add(((Edge) edgeList.get(i)).target);
    }
    return nodeList;
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * Collects the first node.
 * 
 * @param node the node.
 */
private void collectBaseNode(Node node) {
    NodeEx nodeEx = getNodeEx(node);
    if (nodeEx != null) {
        if (stack.contains(nodeEx)) {
            nodeEx.setLooped(true);
        }
        return;
    }
    nodeEx = addNodeEx(node);
    stack.push(nodeEx);
    NodeList list = nodeEx.getChildren();
    for (int i = 0; i < list.size(); i++) {
        Node child = list.getNode(i);
        collectBaseNode(child);
    }
    if (nodeEx.getParentCount() > 1) {
        list = nodeEx.getParent();
        for (int i = 0; i < list.size(); i++) {
            Node parent = list.getNode(i);
            getRootParent(parent);
        }
    }
    nodeEx.setDepth(stack.size());
    stack.pop();
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * Returns the root of the specified node.
 * 
 * @param node the node.
 */
private void getRootParent(Node node) {
    if (getNodeEx(node) != null) {
        return;
    }
    if (workStack.contains(node)) {
        return;
    }
    workStack.push(node);
    EdgeList edgeList = node.incoming;
    if (edgeList.size() > 0) {
        for (int i = 0; i < edgeList.size(); i++) {
            Node parent = ((Edge) edgeList.get(i)).source;
            getRootParent(parent);
        }
    } else {
        addBaseNodeList(node);
        collectBaseNode(node);
    }
    workStack.pop();
    return;
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * Calculates the preferred size of the area to show the specified node and its children.
 * 
 * @param node the root node.
 */
private void calcBlockSize(Node node) {
    NodeEx nodeEx = getNodeEx(node);

    if (stack.contains(nodeEx)) {
        return;
    }
    stack.push(nodeEx);

    NodeList list = nodeEx.getChildren();
    for (int i = 0; i < list.size(); i++) {
        Node child = list.getNode(i);
        NodeEx childEx = getNodeEx(child);
        if (nodeEx.getDepth() < childEx.getDepth()) {
            calcBlockSize(child);
        }
    }
    Dimension dim = nodeEx.calcBlockSize();
    Rectangle rect = nodeEx.getBlockBounds();
    rect.width = dim.width;
    rect.height = dim.height;
    stack.pop();
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
public void contributeNodesToGraph(DirectedGraph graph, HashMap map){
	Node node = new Node(this);
	node.width = getFigure().getBounds().width;//getNode().getWidth();
	int height = 22;
	if (((CFGNode)getModel()).getBefore() != null){
		height += ((CFGNode)getModel()).getBefore().getChildren().size() * 22;
	}
	if (((CFGNode)getModel()).getAfter() != null){
		height += ((CFGNode)getModel()).getAfter().getChildren().size() * 22;
	}
	node.height = height;//getFigure().getBounds().height;
	graph.nodes.add(node);
	map.put(this, node);
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
public void applyGraphResults(DirectedGraph graph, HashMap map){
	Node node = (Node)map.get(this);
	((CFGNodeFigure)getFigure()).setBounds(new Rectangle(node.x, node.y, node.width, node.height));//getFigure().getBounds().height));//getFigure().getBounds().height));
	List outgoing = getSourceConnections();
	for (int i = 0; i < outgoing.size(); i++){
		CFGEdgeEditPart edge = (CFGEdgeEditPart)outgoing.get(i);
		edge.applyGraphResults(graph, map);
	}

}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void execute(ICustomContext context) {

	Diagram diagram = getDiagram();
	CompoundDirectedGraph draw2dGrap = new CompoundDirectedGraph();
	BiMap<PictogramElement, Node> draw2dGraphMap = HashBiMap.create();
	for (Shape shape : diagram.getChildren()) {
		final EObject eObject = Graphiti.getLinkService().getBusinessObjectForLinkedPictogramElement(shape);
		if (eObject instanceof ProcessingUnit || eObject instanceof Medium) {
			Node node = new Node();
			draw2dGrap.nodes.add(node);
			node.setSize(new Dimension(SHAPE_WIDTH, SHAPE_HEIGHT));
			draw2dGraphMap.put(shape, node);
		}
	}

	for (Connection connection : diagram.getConnections()) {
		Node start = draw2dGraphMap.get(connection.getEnd().getParent());
		Node end = draw2dGraphMap.get(connection.getStart().getParent());
		Edge edge = new Edge(start, end);
		draw2dGrap.edges.add(edge);
	}

	new CompoundDirectedGraphLayout().visit(draw2dGrap);

	for (Entry<PictogramElement, Node> e : draw2dGraphMap.entrySet()) {
		PictogramElement pe = e.getKey();
		Node n = e.getValue();
		Graphiti.getGaService().setLocation(pe.getGraphicsAlgorithm(), n.x, n.y);
	}

	hasDoneChanges = true;

}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
public void visit(DirectedGraph graph) {
	try {
		this.graph = graph;
		this.nodeList = graph.nodes;
		this.edgeList = graph.edges;

		// iterate through all of the nodes in the node list
		for (Iterator iter = nodeList.iterator(); iter.hasNext();) {
			Node node = (Node) iter.next();

			// check whether we have already come across this node
			if (!encountered.contains(node)) {
				// create a new cluster for this node
				currentCluster = new Cluster();
				clusters.add(currentCluster);
				encountered.add(node);
				currentCluster.set.add(node);

				// System.out.println("Adding to NEW cluster: " + node + ", cluster: "
				// + currentCluster);
				// recursively add any other nodes reachable from it
				int depth = INITIAL_RECURSION_DEPTH;
				recursivelyAddToCluster(node, depth);
			} else {
				// System.out.println("Already encountered: " + node);
			}
		}
		coalesceRemainingClusters();

		// System.out.println("");
		joinClusters();
	} catch (RuntimeException e) {
		e.printStackTrace();
		throw e;
	}
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * creates a new dummy edge to be used in the graph
 */
private Edge newDummyEdge(Node sourceNode, Node targetNode) {
	DummyEdgePart edgePart = new DummyEdgePart();
	Edge edge = new Edge(edgePart, sourceNode, targetNode);
	edge.weight = 2;
	// add the new edge to the edge list
	edgeList.add(edge);
	targetNode = sourceNode;
	return edge;
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
/**
 * creates a new dummy edge to be used in the graph
 */
private Edge newDummyEdge(Node targetNode, Node sourceNode) {
	DummyEdgePart edgePart = new DummyEdgePart();
	Edge edge = new Edge(edgePart, sourceNode, targetNode);
	edge.weight = 2;
	edgeList.add(edge);
	targetNode = sourceNode;
	return edge;
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
private Node getNext() {
	if (targetNodeIndex == candidateList.size() - 1)
		targetNodeIndex = 0;
	else
		targetNodeIndex++;
	return (Node) candidateList.get(targetNodeIndex);
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
protected void addNodes(AbstractGraphicalEditPart diagram) {
	for (Object obj : diagram.getChildren()) {
		AbstractGraphicalEditPart part = (AbstractGraphicalEditPart) obj;
		Node n = new Node(part);
		Dimension psize = part.getFigure().getPreferredSize(400, 300);
		n.width = psize.width;
		n.height = psize.height;
		n.setPadding(PADDING);
		partToNodesMap.put(part, n);
		graph.nodes.add(n);
	}
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
protected void applyResults(RelationshipPart relationshipPart) {
	Edge e = (Edge) partToNodesMap.get(relationshipPart);
	if (e == null)
		return;
	NodeList nodes = e.vNodes;

	PolylineConnection conn = (PolylineConnection) relationshipPart
			.getConnectionFigure();
	if (nodes != null) {
		List<AbsoluteBendpoint> bends = new ArrayList<AbsoluteBendpoint>();
		for (int i = 0; i < nodes.size(); i++) {
			Node vn = nodes.getNode(i);
			int x = vn.x;
			int y = vn.y;
			if (e.isFeedback()) {
				bends.add(new AbsoluteBendpoint(x, y + vn.height));
				bends.add(new AbsoluteBendpoint(x, y));
			} else {
				bends.add(new AbsoluteBendpoint(x, y));
				bends.add(new AbsoluteBendpoint(x, y + vn.height));
			}
		}
		conn.setRoutingConstraint(bends);
	} else {
		conn.setRoutingConstraint(Collections.EMPTY_LIST);
	}

}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
private static void sortEdges(final List<Edge> edges)
{
  Collections.sort(edges, new Comparator<Edge>()
    {
      @Override
      public int compare(final Edge e1, final Edge e2)
      {
        final Node v1 = e1.target;
        final Node v2 = e2.target;
        final Long id1 = (Long) v1.data * (v1.incoming.size() == 0 ? -1 : 1);
        final Long id2 = (Long) v2.data * (v2.incoming.size() == 0 ? -1 : 1);
        return id1 < 0 && id2 < 0 ? (int) (id2 - id1) : (int) (id1 - id2);
      }
    });
}
 

import org.eclipse.draw2d.graph.Node; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static void sortNodes(final NodeList nodes)
{
  Collections.sort(nodes, new Comparator<Node>()
    {
      @Override
      public int compare(final Node v1, final Node v2)
      {
        final Long id1 = (Long) v1.data;
        final Long id2 = (Long) v2.data;
        final int isz1 = v1.incoming.size();
        final int isz2 = v2.incoming.size();
        final int osz1 = v1.outgoing.size();
        final int osz2 = v2.outgoing.size();
        // at least one node is a root
        if (isz1 == 0 || isz2 == 0)
        {
          // if both are root nodes, oldest first, otherwise, root first
          return isz1 == isz2 ? (int) (id1 - id2) : (isz1 - isz2);
        }
        // at least one node is a leaf
        if (osz1 == 0 || osz2 == 0)
        {
          // if both are leaf nodes, oldest first, otherwise, internal first
          return osz1 == osz2 ? (int) (id1 - id2) : (osz2 - osz1);
        }
        // both nodes are internal
        return (int) (id1 - id2);
      }
    });
}