org.netbeans.api.visual.graph.layout.UniversalGraph Java Examples

@Override
protected void performGraphLayout(UniversalGraph<N, E> graph) {
	if (!graph.getNodes().contains(rootNode)) {
		throw new IllegalArgumentException(
				"graph does not contain rootNode");
	}

	TreeLayout<N> layout = new TreeLayout<N>(new MyTreeForTreeLayout(
			rootNode, graph), new MyNodeExtentProvider(graph),
			configuration);
	Map<N, Rectangle2D.Double> bounds = layout.getNodeBounds();
	for (Map.Entry<N, Rectangle2D.Double> entry : bounds.entrySet()) {
		Rectangle2D.Double rect = entry.getValue();
		Point pt = new Point((int) Math.round(rect.getX() + originX),
				(int) Math.round(rect.getY() + originY));
		setResolvedNodeLocation(graph, entry.getKey(), pt);
	}
}
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new HashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new HashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new HashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new HashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new HashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new HashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new HashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new HashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new LinkedHashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new LinkedHashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new HashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new HashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new HashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new HashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

public VertexWrapper(N node, UniversalGraph<N, E> graph) {
    this.node = node;
    this.graph = graph;
    final VertexWrapper vertex = this;
    this.slot = new Port() {

        public Vertex getVertex() {
            return vertex;
        }

        public Point getRelativePosition() {
            return new Point((int) (vertex.getSize().getWidth() / 2), (int) (vertex.getSize().getHeight() / 2));
        }
    };

    Widget w = graph.getScene().findWidget(node);
    this.position = w.getPreferredLocation();
}
 

protected void performGraphLayout(UniversalGraph<N, E> graph) {

        Set<LinkWrapper> links = new HashSet<LinkWrapper>();
        Set<VertexWrapper> vertices = new HashSet<VertexWrapper>();
        Map<N, VertexWrapper> vertexMap = new HashMap<N, VertexWrapper>();

        for (N node : graph.getNodes()) {
            VertexWrapper v = new VertexWrapper(node, graph);
            vertexMap.put(node, v);
            vertices.add(v);
        }

        for (E edge : graph.getEdges()) {
            N source = graph.getEdgeSource(edge);
            N target = graph.getEdgeTarget(edge);
            LinkWrapper l = new LinkWrapper(vertexMap.get(source), vertexMap.get(target));
            links.add(l);
        }

        HierarchicalLayoutManager m = new HierarchicalLayoutManager(HierarchicalLayoutManager.Combine.NONE);

        LayoutGraph layoutGraph = new LayoutGraph(links, vertices);
        m.doLayout(layoutGraph);
    }
 

/** Creates a new instance of UndirectedGraph */
private MixedGraph(UniversalGraph<N, E> uGraph, GraphScene scene) {
    this.uGraph = uGraph;
    this.scene = scene;
    this.nodes = uGraph.getNodes();
    this.edges = uGraph.getEdges() ;

    vertexMap = new HashMap<N, Vertex>();
}
 

/**
 * Creates a new instance of DirectedGraph
 */
protected DirectedGraph(UniversalGraph<N, E> uGraph, GraphScene scene) {
    this.uGraph = uGraph;
    this.scene = scene;
    this.nodes = uGraph.getNodes();
    this.edges = uGraph.getEdges();

    vertexMap = new HashMap<N, Vertex>();
    edgeMap = new LinkedHashMap<E, Edge>();
    rootVertices = new ArrayList<Vertex>();
    vertices = new ArrayList<Vertex>();
}
 

/**
 * Method to determine the maximal space (horizontaly or verticaly) of each level in the tree.
 * @param map the {@link Map} to which the maximal space for each level should be stored.
 * @param lvl the level to analyse.
 * @return the result of the maximal space calculation for the given level and the sublevels.
 * @since 2.25
 */
private Map<Integer, Integer> calculateMaxSpace(UniversalGraph<N, E> graph, Map<Integer, Integer> map, int lvl) {

    Widget widget = graph.getScene().findWidget(node);
    widget.getLayout().layout(widget);
    relativeBounds = widget.getPreferredBounds();

    if (vertical) {
        space = relativeBounds.height;
    } else {
        space = relativeBounds.width;
    }

    if (map.get(lvl) != null) {
        // lvl is in list, but height is greater than the old one.
        if (map.get(lvl) < space) {
            map.put(lvl, space);
        }
    } else {
        // lvl isn't in the map right now.
        map.put(lvl, space);
    }

    lvl++;

    // do iteration over all children of the current node and calculate
    // the maxSpace
    for (Node n : children) {
        n.calculateMaxSpace(graph, map, lvl);
    }
    return map;
}
 

private Node (UniversalGraph<N, E> graph, N node, HashSet<N> loadedSet) {
    this.node = node;
    loadedSet.add (node);

    children = new ArrayList<Node> ();
    for (E edge: graph.findNodeEdges (node, true, false)) {
        N child = graph.getEdgeTarget (edge);
        if (child != null  &&  ! loadedSet.contains (child))
            children.add (new Node (graph, child, loadedSet));
    }
}
 

/**
 * 
 * @param uGraph
 * @param scene
 */
protected MGraph(UniversalGraph<N, E> uGraph, GraphScene scene) {
    this.uGraph = uGraph;
    this.scene = scene;
    this.nodes = uGraph.getNodes();

    vertexMap = new HashMap<N, Vertex>();
    edgeMap = new LinkedHashMap<E, Edge>();
    vertices = new ArrayList<Vertex>();

    DummyVertex.resetCounter();
}
 

protected void performNodesLayout(UniversalGraph<N, E> graph, Collection<N> nodes) {
    throw new UnsupportedOperationException();
}
 

@Override
protected void performNodesLayout(UniversalGraph<N, E> universalGraph,
		Collection<N> nodes) {
	throw new UnsupportedOperationException(
			"Cannot layout a subsets of nodes of a tree");
}
 

public static <N, E> DirectedGraph createGraph(UniversalGraph<N, E> uGraph, GraphScene scene) {
    DirectedGraph<N, E> graph = new DirectedGraph<N, E>(uGraph, scene);
    graph.createGraph();
    //graph.printGraph();
    return graph;
}
 

public MyTreeForTreeLayout(N root, UniversalGraph<N, E> graph) {
	super(root);
	this.graph = graph;
}
 

public MyNodeExtentProvider(UniversalGraph<N, E> graph) {
	this.graph = graph;
}
 

protected void performNodesLayout(UniversalGraph<N, E> graph, Collection<N> nodes) {
    throw new UnsupportedOperationException();
}
 

protected void performNodesLayout(UniversalGraph<N, E> graph, Collection<N> nodes) {
    throw new UnsupportedOperationException();
}
 

public static <N, E> MixedGraph createGraph(UniversalGraph<N, E> uGraph, GraphScene scene) {
    MixedGraph<N, E> graph = new MixedGraph<N, E>(uGraph, scene);
    graph.createGraph();
    //graph.printGraph();
    return graph;
}