/**
* Returns the leaf before this node or null if this node is the first leaf in the tree.
*
* <p>In this implementation of the <code>MutableNode</code> interface, this operation is very
* inefficient. In order to determine the previous node, this method first performs a linear
* search in the parent's child-list in order to find the current node.
*
* <p>That implementation makes the operation suitable for short traversals from a known position.
* But to traverse all of the leaves in the tree, you should use <code>depthFirstEnumeration
* </code> to enumerate the nodes in the tree and use <code>isLeaf</code> on each node to
* determine which are leaves.
*
* @see #depthFirstEnumeration
* @see #isLeaf
* @return returns the leaf before this node
*/
public DefaultMutableTreeNode getPreviousLeaf() {
DefaultMutableTreeNode previousSibling;
DefaultMutableTreeNode myParent = (DefaultMutableTreeNode) getParent();
if (myParent == null) return null;
previousSibling = getPreviousSibling(); // linear search
if (previousSibling != null) return previousSibling.getLastLeaf();
return myParent.getPreviousLeaf(); // tail recursion
}
/**
* Returns the node that precedes this node in a preorder traversal of this node's tree. Returns
* <code>null</code> if this node is the first node of the traversal -- the root of the tree. This
* is an inefficient way to traverse the entire tree; use an enumeration, instead.
*
* @see #preorderEnumeration
* @return the node that precedes this node in a preorder traversal, or null if this node is the
* first
*/
public DefaultMutableTreeNode getPreviousNode() {
DefaultMutableTreeNode previousSibling;
DefaultMutableTreeNode myParent = (DefaultMutableTreeNode) getParent();
if (myParent == null) {
return null;
}
previousSibling = getPreviousSibling();
if (previousSibling != null) {
if (previousSibling.getChildCount() == 0) return previousSibling;
else return previousSibling.getLastLeaf();
} else {
return myParent;
}
}