com.alee.laf.tree.TreeUtils Maven / Gradle / Ivy
/*
* This file is part of WebLookAndFeel library.
*
* WebLookAndFeel library is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* WebLookAndFeel library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with WebLookAndFeel library. If not, see tree node type
* @return appropriate {@link TreeWalker} implementation for the specified {@link JTree}
*/
@NotNull
public static TreeWalker getTreeWalker ( @NotNull final JTree tree )
{
final TreeWalker treeWalker;
if ( tree.getModel () instanceof AsyncTreeModel )
{
treeWalker = new AsyncTreeWalker ( tree );
}
else
{
treeWalker = new SimpleTreeWalker ( tree );
}
return ( TreeWalker ) treeWalker;
}
/**
* Returns {@link TreePath} from the root to the specified {@link TreeNode}.
* The last element in the path is the specified {@link TreeNode}.
*
* @param node {@link TreeNode} to get {@link TreePath} for
* @return {@link TreePath} from the root to the specified {@link TreeNode}
*/
@Nullable
public static TreePath getTreePath ( @Nullable final TreeNode node )
{
final TreePath treePath;
if ( node != null )
{
final TreeNode[] path = getPath ( node );
if ( path != null )
{
treePath = new TreePath ( path );
}
else
{
treePath = null;
}
}
else
{
treePath = null;
}
return treePath;
}
/**
* Returns the path from the root, to get to this node.
* First element in the path is the root and the last element in the path is this node.
*
* @param node {@link TreeNode} to get the path for
* @return array of {@link TreeNode}s representing the path
*/
@Nullable
public static TreeNode[] getPath ( @Nullable final TreeNode node )
{
return getPathToRoot ( node, 0 );
}
/**
* Builds the parents of node up to and including the root node, where the original node is the last element in the returned array.
* The length of the returned array gives the node's depth in the tree.
*
* @param node {@link TreeNode} to get the path for
* @param depth an int giving the number of steps already taken towards the root (on recursive calls), used to size the returned array
* @return array of {@link TreeNode}s representing the path from the root to the specified {@link TreeNode}
*/
@Nullable
private static TreeNode[] getPathToRoot ( @Nullable final TreeNode node, int depth )
{
final TreeNode[] path;
if ( node == null )
{
if ( depth != 0 )
{
path = new TreeNode[ depth ];
}
else
{
path = null;
}
}
else
{
depth++;
path = getPathToRoot ( node.getParent (), depth );
if ( path != null )
{
path[ path.length - depth ] = node;
}
}
return path;
}
/**
* Returns whether or not {@code anotherNode} is an ancestor of {@code node}.
* If {@code anotherNode} is {@code null}, this method returns {@code false}.
* Note that any node is considered as an ancestor of itself.
* This operation is at worst O(h) where h is the distance from the root to {@code node}.
*
* @param node tested {@code node}
* @param anotherNode node to test as an ancestor of {@code node}
* @return {@code true} if {@code anotherNode} is an ancestor of {@code node}, {@code false} otherwise
*/
public static boolean isNodeAncestor ( @NotNull final TreeNode node, @Nullable final TreeNode anotherNode )
{
boolean nodeAncestor = false;
if ( anotherNode != null )
{
TreeNode ancestor = node;
do
{
if ( ancestor == anotherNode )
{
nodeAncestor = true;
break;
}
}
while ( ( ancestor = ancestor.getParent () ) != null );
}
return nodeAncestor;
}
/**
* Returns whether or not {@code anotherNode} is an ancestor of {@code node}.
* If {@code anotherNode} is {@code null}, this method returns {@code false}.
* Note that any node is considered as an ancestor of itself.
* This operation is at worst O(h) where h is the distance from the root to {@code node}.
*
* Als note that unlike {@link #isNodeAncestor(TreeNode, TreeNode)} this method will make sure it takes all {@link TreeNode}s currently
* hidden by tree filtering into account meaning result might not be consistent with what you actually see in the tree at the time.
*
* @param tree {@link JTree} containing specified {@link TreeNode}s
* @param node tested {@code node}
* @param anotherNode node to test as an ancestor of {@code node}
* @return {@code true} if {@code anotherNode} is an ancestor of {@code node}, {@code false} otherwise
*/
public static boolean isNodeAncestor ( @NotNull final JTree tree, @NotNull final TreeNode node, @Nullable final TreeNode anotherNode )
{
final boolean ancestor;
final TreeModel model = tree.getModel ();
if ( model instanceof ExTreeModel )
{
boolean isParent = false;
final ExTreeModel exTreeModel = ( ExTreeModel ) model;
if ( anotherNode != null )
{
TreeNode parent = node;
do
{
if ( parent == anotherNode )
{
isParent = true;
break;
}
}
while ( ( parent = exTreeModel.getRawParent ( ( UniqueNode ) parent ) ) != null );
}
ancestor = isParent;
}
/* todo This should be implemented along with WebAsyncCheckBoxTree
else if ( model instanceof AsyncTreeModel )
{
boolean isParent = false;
final AsyncTreeModel asyncTreeModel = ( AsyncTreeModel ) model;
if ( other != null )
{
TreeNode parent = node;
do
{
if ( parent == other )
{
isParent = true;
break;
}
}
while ( ( parent = asyncTreeModel.getRawParent ( ( UniqueNode ) parent ) ) != null );
}
ancestor = isParent;
}*/
else
{
ancestor = isNodeAncestor ( node, anotherNode );
}
return ancestor;
}
/**
* Returns number of levels above the specified {@code node}.
* It is basically the distance from the root to the specified {@code node}.
* Returns {@code 0} if {@code node} is the root.
*
* @param node {@code node}
* @return number of levels above the specified {@code node}
*/
public static int getLevel ( @NotNull final TreeNode node )
{
int levels = 0;
TreeNode ancestor = node;
while ( ( ancestor = ancestor.getParent () ) != null )
{
levels++;
}
return levels;
}
/**
* Expands all {@link JTree} nodes in a single call.
*
* @param tree {@link JTree} to expand all nodes for
*/
public static void expandAll ( @NotNull final JTree tree )
{
if ( tree instanceof WebTree )
{
final WebTree webTree = ( WebTree ) tree;
webTree.expandAll ();
}
else
{
int row = 0;
while ( row < tree.getRowCount () )
{
tree.expandRow ( row );
row++;
}
}
}
/**
* Expands all {@link TreeNode}s loaded within {@link JTree} in a single call.
*
* @param tree {@link JTree} to expand {@link TreeNode}s for
*/
public static void expandLoaded ( @NotNull final JTree tree )
{
final Object root = tree.getModel ().getRoot ();
if ( root instanceof TreeNode )
{
expandLoaded ( tree, ( TreeNode ) root );
}
else
{
throw new RuntimeException ( "Specified tree doesn't use TreeNodes: " + tree );
}
}
/**
* Expands all {@link TreeNode}s loaded within {@link JTree} in a single call.
*
* @param tree {@link JTree} to expand {@link TreeNode}s for
* @param node {@link TreeNode} under which all other {@link TreeNode}s should be expanded
*/
public static void expandLoaded ( @NotNull final JTree tree, @NotNull final TreeNode node )
{
// Only expand parent for non-root nodes
if ( node.getParent () != null )
{
// Make sure this node's parent is expanded
// We do not need to expand the node itself, we only need to make sure it is visible in the tree
final TreePath path = getTreePath ( node.getParent () );
if ( !tree.isExpanded ( path ) )
{
tree.expandPath ( path );
}
}
// Expanding all child nodes
// We are asking node instead of tree model to avoid any additional data loading to occur
for ( int index = 0; index < node.getChildCount (); index++ )
{
expandLoaded ( tree, node.getChildAt ( index ) );
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy