import org.netbeans.api.visual.layout.LayoutFactory;

import org.netbeans.api.visual.layout.SceneLayout;

        // new implementation

        GraphLayout<String,String> graphLayout = GraphLayoutFactory.createTreeGraphLayout (100, 100, 50, 50, true);

        GraphLayoutSupport.setTreeGraphLayoutRootNode (graphLayout, "root");

        final SceneLayout sceneGraphLayout = LayoutFactory.createSceneGraphLayout (this, graphLayout);

        <change>

            <api name="general"/>

            <summary>GraphLayoutFactory.createTreeGraphLayout added</summary>

            <version major="2" minor="4"/>

            <date day="1" month="6" year="2007"/>

            <author login="dkaspar"/>

            <compatibility addition="yes"/>

            <description>

                TreeGraphLayout added.

            </description>

            <class package="org.netbeans.api.visual.graph.layout" name="GraphLayoutFactory" link="yes"/>

            <issue number="105278"/>

        </change>

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.visual.graph.layout;

import org.netbeans.modules.visual.graph.layout.TreeGraphLayout;

/**

 * The factory class of all built-in GraphLayout based implementations.

 * 

 * @author David Kaspar

 * @since 2.4

 */

public class GraphLayoutFactory {

    /**

     * Creates a tree graph layout.

     * Use GraphLayoutSupport.setTreeGraphLayoutRootNode method to set the root node of the graph.

     * If not set/found, then layout is not executed.

     * @param originX the x-axis origin

     * @param originY the y-axis origin

     * @param verticalGap the vertical gap between cells

     * @param horizontalGap the horizontal gap between cells

     * @param vertical if true, then layout organizes the graph vertically; if false, then horizontally

     * @return the tree graph layout

     * @since 2.4

     */

    public static <N,E> GraphLayout<N,E> createTreeGraphLayout (int originX, int originY, int verticalGap, int horizontalGap, boolean vertical) {

        return new TreeGraphLayout<N,E> (originX, originY, verticalGap, horizontalGap, vertical);

    }

}

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.visual.graph.layout;

import org.netbeans.modules.visual.graph.layout.TreeGraphLayout;

/**

 * @author David Kaspar

 * @since 2.4

 */

public class GraphLayoutSupport {

    /**

     * Sets a root node to a tree graph layout.

     * @param graph the tree graph layout

     * @param rootNode the root node

     * @since 2.4

     */

    public static <N,E> void setTreeGraphLayoutRootNode (GraphLayout<N,E> graph, N rootNode) {

        if (graph instanceof TreeGraphLayout)

            ((TreeGraphLayout<N,E>) graph).setRootNode (rootNode);

    }

}

<li><a href="#TreeGraphLayout">TreeGraphLayout</a>

<h3><a name="TreeGraphLayout">TreeGraphLayout</a></h3>

<p>

The algotihm organizes nodes in to a tree. Nodes that are not in the tree (defined by a root node and connecting edges) are resolved at [0,0] location.

<p>

The layout can be created using <code>GraphLayoutFactory.createTreeGraphLayout</code> factory method.

For proper work, you have to specify a root node using <code>GraphLayoutSupport.createTreeGraphLayoutRootNode</code> method. See <code>test.graphlayout.TreeGraphLayoutTest</code> example for usages.

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.visual.graph.layout;

import org.netbeans.api.visual.graph.layout.GraphLayout;

import org.netbeans.api.visual.graph.layout.UniversalGraph;

import org.netbeans.api.visual.widget.Widget;

import java.awt.*;

import java.util.*;

/**

 * @author David Kaspar

 */

public final class TreeGraphLayout<N,E> extends GraphLayout<N,E> {

    private int originX;

    private int originY;

    private int verticalGap;

    private int horizontalGap;

    private boolean vertical;

    private N rootNode;

    public TreeGraphLayout (int originX, int originY, int verticalGap, int horizontalGap, boolean vertical) {

        this.originX = originX;

        this.originY = originY;

        this.verticalGap = verticalGap;

        this.horizontalGap = horizontalGap;

        this.vertical = vertical;

    }

    public void setRootNode (N rootNode) {

        this.rootNode = rootNode;

    }

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

        if (rootNode == null)

            return;

        Collection<N> allNodes = graph.getNodes ();

        ArrayList<N> nodesToResolve = new ArrayList<N> (allNodes);

        HashSet<N> loadedSet = new HashSet<N> ();

        Node root = new Node (graph, rootNode, loadedSet);

        nodesToResolve.removeAll (loadedSet);

        if (vertical) {

            root.allocateHorizontally (graph);

            root.resolveVertically (originX, originY);

        } else {

            root.allocateVertically (graph);

            root.resolveHorizontally (originX, originY);

        }

        final HashMap<N, Point> resultPosition = new HashMap<N, Point> ();

        root.upload (resultPosition);

        for (N node : nodesToResolve) {

            Point position = new Point ();

            // TODO - resolve others

            resultPosition.put (node, position);

        }

        for (Map.Entry<N, Point> entry : resultPosition.entrySet ())

            setResolvedNodeLocation (graph, entry.getKey (), entry.getValue ());

    }

    protected void performNodesLayout (UniversalGraph<N, E> universalGraph, Collection<N> nodes) {

        throw new UnsupportedOperationException (); // TODO

    }

    private class Node {

        private N node;

        private ArrayList<Node> children;

        private Rectangle relativeBounds;

        private int space;

        private int totalSpace;

        private Point point;

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

            }

        }

        private int allocateHorizontally (UniversalGraph<N, E> graph) {

            Widget widget = graph.getScene ().findWidget (node);

            widget.getLayout ().layout (widget);

            relativeBounds = widget.getPreferredBounds ();

            space = 0;

            for (int i = 0; i < children.size (); i++) {

                if (i > 0)

                    space += horizontalGap;

                space += children.get (i).allocateHorizontally (graph);

            }

            totalSpace = Math.max (space, relativeBounds.width);

            return totalSpace;

        }

        private void resolveVertically (int x, int y) {

            point = new Point (x + totalSpace / 2, y - relativeBounds.y);

            x += (totalSpace - space) / 2;

            y += relativeBounds.height + verticalGap;

            for (Node child : children) {

                child.resolveVertically (x, y);

                x += child.totalSpace + horizontalGap;

            }

        }

        private int allocateVertically (UniversalGraph<N, E> graph) {

            Widget widget = graph.getScene ().findWidget (node);

            widget.getLayout ().layout (widget);

            relativeBounds = widget.getPreferredBounds ();

            space = 0;

            for (int i = 0; i < children.size (); i++) {

                if (i > 0)

                    space += verticalGap;

                space += children.get (i).allocateVertically (graph);

            }

            totalSpace = Math.max (space, relativeBounds.height);

            return totalSpace;

        }

        private void resolveHorizontally (int x, int y) {

            point = new Point (x - relativeBounds.x, y + totalSpace / 2);

            x += relativeBounds.width + horizontalGap;

            y += (totalSpace - space) / 2;

            for (Node child : children) {

                child.resolveHorizontally (x, y);

                y += child.totalSpace + verticalGap;

            }

        }

        private void upload (HashMap<N, Point> result) {

            result.put (node, point);

            for (Node child : children)

                child.upload (result);

        }

    }

}