Java Node类代码示例

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;
}