public DefaultMutableTreeNode() 
{
                        
        this(null);
}

Creates a tree node that has no parent and no children, but which allows children.

 public DefaultMutableTreeNode(Object userObject) 
{
        this(userObject, true);
}

Creates a tree node with no parent, no children, but which allows children, and initializes it with the specified user object.

Parameters:

userObject - an Object provided by the user that constitutes the node's data

 public DefaultMutableTreeNode(Object userObject,
    boolean allowsChildren) 
{
        super();
        parent = null;
        this.allowsChildren = allowsChildren;
        this.userObject = userObject;
}

Creates a tree node with no parent, no children, initialized with the specified user object, and that allows children only if specified.

Parameters:

userObject - an Object provided by the user that constitutes the node's data

allowsChildren - if true, the node is allowed to have child nodes -- otherwise, it is always a leaf node

 public  void add(MutableTreeNode newChild) 
{
        if(newChild != null && newChild.getParent() == this)
            insert(newChild, getChildCount() - 1);
        else
            insert(newChild, getChildCount());
}

Removes newChild from its parent and makes it a child of this node by adding it to the end of this node's child array.

 public Enumeration breadthFirstEnumeration() 
{
        return new BreadthFirstEnumeration(this);
}

Creates and returns an enumeration that traverses the subtree rooted at this node in breadth-first order. The first node returned by the enumeration's nextElement() method is this node.

Modifying the tree by inserting, removing, or moving a node invalidates any enumerations created before the modification.

 public Enumeration children() 
{
        if (children == null) {
            return EMPTY_ENUMERATION;
        } else {
            return children.elements();
        }
}

Creates and returns a forward-order enumeration of this node's children. Modifying this node's child array invalidates any child enumerations created before the modification.

 public Object clone() 
{
        DefaultMutableTreeNode newNode = null;
        try {
            newNode = (DefaultMutableTreeNode)super.clone();
            // shallow copy -- the new node has no parent or children
            newNode.children = null;
            newNode.parent = null;
        } catch (CloneNotSupportedException e) {
            // Won't happen because we implement Cloneable
            throw new Error(e.toString());
        }
        return newNode;
}

Overridden to make clone public. Returns a shallow copy of this node; the new node has no parent or children and has a reference to the same user object, if any.

 public Enumeration depthFirstEnumeration() 
{
        return postorderEnumeration();
}

Creates and returns an enumeration that traverses the subtree rooted at this node in depth-first order. The first node returned by the enumeration's nextElement() method is the leftmost leaf. This is the same as a postorder traversal.

Modifying the tree by inserting, removing, or moving a node invalidates any enumerations created before the modification.

 public boolean getAllowsChildren() 
{
        return allowsChildren;
}

Returns true if this node is allowed to have children.

 public TreeNode getChildAfter(TreeNode aChild) 
{
        if (aChild == null) {
            throw new IllegalArgumentException("argument is null");
        }
        int index = getIndex(aChild);           // linear search
        if (index == -1) {
            throw new IllegalArgumentException("node is not a child");
        }
        if (index <  getChildCount() - 1) {
            return getChildAt(index + 1);
        } else {
            return null;
        }
}

Returns the child in this node's child array that immediately follows aChild, which must be a child of this node. If aChild is the last child, returns null. This method performs a linear search of this node's children for aChild and is O(n) where n is the number of children; to traverse the entire array of children, use an enumeration instead.

 public TreeNode getChildAt(int index) 
{
        if (children == null) {
            throw new ArrayIndexOutOfBoundsException("node has no children");
        }
        return (TreeNode)children.elementAt(index);
}

Returns the child at the specified index in this node's child array.

 public TreeNode getChildBefore(TreeNode aChild) 
{
        if (aChild == null) {
            throw new IllegalArgumentException("argument is null");
        }
        int index = getIndex(aChild);           // linear search
        if (index == -1) {
            throw new IllegalArgumentException("argument is not a child");
        }
        if (index  > 0) {
            return getChildAt(index - 1);
        } else {
            return null;
        }
}

Returns the child in this node's child array that immediately precedes aChild, which must be a child of this node. If aChild is the first child, returns null. This method performs a linear search of this node's children for aChild and is O(n) where n is the number of children.

 public int getChildCount() 
{
        if (children == null) {
            return 0;
        } else {
            return children.size();
        }
}

Returns the number of children of this node.

 public int getDepth() 
{
        Object  last = null;
        Enumeration     enum_ = breadthFirstEnumeration();
        while (enum_.hasMoreElements()) {
            last = enum_.nextElement();
        }
        if (last == null) {
            throw new Error ("nodes should be null");
        }
        return ((DefaultMutableTreeNode)last).getLevel() - getLevel();
}

Returns the depth of the tree rooted at this node -- the longest distance from this node to a leaf. If this node has no children, returns 0. This operation is much more expensive than getLevel() because it must effectively traverse the entire tree rooted at this node.

 public TreeNode getFirstChild() 
{
        if (getChildCount() == 0) {
            throw new NoSuchElementException("node has no children");
        }
        return getChildAt(0);
}

Returns this node's first child. If this node has no children, throws NoSuchElementException.

 public DefaultMutableTreeNode getFirstLeaf() 
{
        DefaultMutableTreeNode node = this;
        while (!node.isLeaf()) {
            node = (DefaultMutableTreeNode)node.getFirstChild();
        }
        return node;
}

Finds and returns the first leaf that is a descendant of this node -- either this node or its first child's first leaf. Returns this node if it is a leaf.

 public int getIndex(TreeNode aChild) 
{
        if (aChild == null) {
            throw new IllegalArgumentException("argument is null");
        }
        if (!isNodeChild(aChild)) {
            return -1;
        }
        return children.indexOf(aChild);        // linear search
}

Returns the index of the specified child in this node's child array. If the specified node is not a child of this node, returns -1. This method performs a linear search and is O(n) where n is the number of children.

 public TreeNode getLastChild() 
{
        if (getChildCount() == 0) {
            throw new NoSuchElementException("node has no children");
        }
        return getChildAt(getChildCount()-1);
}

Returns this node's last child. If this node has no children, throws NoSuchElementException.

 public DefaultMutableTreeNode getLastLeaf() 
{
        DefaultMutableTreeNode node = this;
        while (!node.isLeaf()) {
            node = (DefaultMutableTreeNode)node.getLastChild();
        }
        return node;
}

Finds and returns the last leaf that is a descendant of this node -- either this node or its last child's last leaf. Returns this node if it is a leaf.

 public int getLeafCount() 
{
        int count = 0;
        TreeNode node;
        Enumeration enum_ = breadthFirstEnumeration(); // order matters not
        while (enum_.hasMoreElements()) {
            node = (TreeNode)enum_.nextElement();
            if (node.isLeaf()) {
                count++;
            }
        }
        if (count <  1) {
            throw new Error("tree has zero leaves");
        }
        return count;
}

Returns the total number of leaves that are descendants of this node. If this node is a leaf, returns 1. This method is O(n) where n is the number of descendants of this node.

 public int getLevel() 
{
        TreeNode ancestor;
        int levels = 0;
        ancestor = this;
        while((ancestor = ancestor.getParent()) != null){
            levels++;
        }
        return levels;
}

Returns the number of levels above this node -- the distance from the root to this node. If this node is the root, returns 0.

 public DefaultMutableTreeNode getNextLeaf() 
{
        DefaultMutableTreeNode nextSibling;
        DefaultMutableTreeNode myParent = (DefaultMutableTreeNode)getParent();
        if (myParent == null)
            return null;
        nextSibling = getNextSibling(); // linear search
        if (nextSibling != null)
            return nextSibling.getFirstLeaf();
        return myParent.getNextLeaf();  // tail recursion
}

Returns the leaf after this node or null if this node is the last leaf in the tree.

In this implementation of the MutableNode interface, this operation is very inefficient. In order to determine the next node, this method first performs a linear search in the parent's child-list in order to find the current node.

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 depthFirstEnumeration to enumerate the nodes in the tree and use isLeaf on each node to determine which are leaves.

 public DefaultMutableTreeNode getNextNode() 
{
        if (getChildCount() == 0) {
            // No children, so look for nextSibling
            DefaultMutableTreeNode nextSibling = getNextSibling();
            if (nextSibling == null) {
                DefaultMutableTreeNode aNode = (DefaultMutableTreeNode)getParent();
                do {
                    if (aNode == null) {
                        return null;
                    }
                    nextSibling = aNode.getNextSibling();
                    if (nextSibling != null) {
                        return nextSibling;
                    }
                    aNode = (DefaultMutableTreeNode)aNode.getParent();
                } while(true);
            } else {
                return nextSibling;
            }
        } else {
            return (DefaultMutableTreeNode)getChildAt(0);
        }
}

Returns the node that follows this node in a preorder traversal of this node's tree. Returns null if this node is the last node of the traversal. This is an inefficient way to traverse the entire tree; use an enumeration, instead.

 public DefaultMutableTreeNode getNextSibling() 
{
        DefaultMutableTreeNode retval;
        DefaultMutableTreeNode myParent = (DefaultMutableTreeNode)getParent();
        if (myParent == null) {
            retval = null;
        } else {
            retval = (DefaultMutableTreeNode)myParent.getChildAfter(this);      // linear search
        }
        if (retval != null && !isNodeSibling(retval)) {
            throw new Error("child of parent is not a sibling");
        }
        return retval;
}

Returns the next sibling of this node in the parent's children array. Returns null if this node has no parent or is the parent's last child. This method performs a linear search that is O(n) where n is the number of children; to traverse the entire array, use the parent's child enumeration instead.

 public TreeNode getParent() 
{
        return parent;
}

Returns this node's parent or null if this node has no parent.

 public TreeNode[] getPath() 
{
        return getPathToRoot(this, 0);
}

Returns the path from the root, to get to this node. The last element in the path is this node.

 protected TreeNode[] getPathToRoot(TreeNode aNode,
    int depth) 
{
        TreeNode[]              retNodes;
        /* Check for null, in case someone passed in a null node, or
           they passed in an element that isn't rooted at root. */
        if(aNode == null) {
            if(depth == 0)
                return null;
            else
                retNodes = new TreeNode[depth];
        }
        else {
            depth++;
            retNodes = getPathToRoot(aNode.getParent(), depth);
            retNodes[retNodes.length - depth] = aNode;
        }
        return retNodes;
}

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.

 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 leaf before this node or null if this node is the first leaf in the tree.

In this implementation of the MutableNode 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.

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 depthFirstEnumeration to enumerate the nodes in the tree and use isLeaf on each node to determine which are leaves.

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

Returns the node that precedes this node in a preorder traversal of this node's tree. Returns null 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.

 public DefaultMutableTreeNode getPreviousSibling() 
{
        DefaultMutableTreeNode retval;
        DefaultMutableTreeNode myParent = (DefaultMutableTreeNode)getParent();
        if (myParent == null) {
            retval = null;
        } else {
            retval = (DefaultMutableTreeNode)myParent.getChildBefore(this);     // linear search
        }
        if (retval != null && !isNodeSibling(retval)) {
            throw new Error("child of parent is not a sibling");
        }
        return retval;
}

Returns the previous sibling of this node in the parent's children array. Returns null if this node has no parent or is the parent's first child. This method performs a linear search that is O(n) where n is the number of children.

 public TreeNode getRoot() 
{
        TreeNode ancestor = this;
        TreeNode previous;
        do {
            previous = ancestor;
            ancestor = ancestor.getParent();
        } while (ancestor != null);
        return previous;
}

Returns the root of the tree that contains this node. The root is the ancestor with a null parent.

 public TreeNode getSharedAncestor(DefaultMutableTreeNode aNode) 
{
        if (aNode == this) {
            return this;
        } else if (aNode == null) {
            return null;
        }
        int             level1, level2, diff;
        TreeNode        node1, node2;
        level1 = getLevel();
        level2 = aNode.getLevel();
        if (level2  > level1) {
            diff = level2 - level1;
            node1 = aNode;
            node2 = this;
        } else {
            diff = level1 - level2;
            node1 = this;
            node2 = aNode;
        }
        // Go up the tree until the nodes are at the same level
        while (diff  > 0) {
            node1 = node1.getParent();
            diff--;
        }
        // Move up the tree until we find a common ancestor.  Since we know
        // that both nodes are at the same level, we won't cross paths
        // unknowingly (if there is a common ancestor, both nodes hit it in
        // the same iteration).
        do {
            if (node1 == node2) {
                return node1;
            }
            node1 = node1.getParent();
            node2 = node2.getParent();
        } while (node1 != null);// only need to check one -- they're at the
        // same level so if one is null, the other is
        if (node1 != null || node2 != null) {
            throw new Error ("nodes should be null");
        }
        return null;
}

Returns the nearest common ancestor to this node and aNode. Returns null, if no such ancestor exists -- if this node and aNode are in different trees or if aNode is null. A node is considered an ancestor of itself.

 public int getSiblingCount() 
{
        TreeNode myParent = getParent();
        if (myParent == null) {
            return 1;
        } else {
            return myParent.getChildCount();
        }
}

Returns the number of siblings of this node. A node is its own sibling (if it has no parent or no siblings, this method returns 1).

 public Object getUserObject() 
{
        return userObject;
}

Returns this node's user object.

 public Object[] getUserObjectPath() 
{
        TreeNode[]          realPath = getPath();
        Object[]            retPath = new Object[realPath.length];
        for(int counter = 0; counter <  realPath.length; counter++)
            retPath[counter] = ((DefaultMutableTreeNode)realPath[counter])
                               .getUserObject();
        return retPath;
}

Returns the user object path, from the root, to get to this node. If some of the TreeNodes in the path have null user objects, the returned path will contain nulls.

 public  void insert(MutableTreeNode newChild,
    int childIndex) 
{
        if (!allowsChildren) {
            throw new IllegalStateException("node does not allow children");
        } else if (newChild == null) {
            throw new IllegalArgumentException("new child is null");
        } else if (isNodeAncestor(newChild)) {
            throw new IllegalArgumentException("new child is an ancestor");
        }
            MutableTreeNode oldParent = (MutableTreeNode)newChild.getParent();
            if (oldParent != null) {
                oldParent.remove(newChild);
            }
            newChild.setParent(this);
            if (children == null) {
                children = new Vector();
            }
            children.insertElementAt(newChild, childIndex);
}

Removes newChild from its present parent (if it has a parent), sets the child's parent to this node, and then adds the child to this node's child array at index childIndex. newChild must not be null and must not be an ancestor of this node.

 public boolean isLeaf() 
{
        return (getChildCount() == 0);
}

Returns true if this node has no children. To distinguish between nodes that have no children and nodes that cannot have children (e.g. to distinguish files from empty directories), use this method in conjunction with getAllowsChildren

 public boolean isNodeAncestor(TreeNode anotherNode) 
{
        if (anotherNode == null) {
            return false;
        }
        TreeNode ancestor = this;
        do {
            if (ancestor == anotherNode) {
                return true;
            }
        } while((ancestor = ancestor.getParent()) != null);
        return false;
}

Returns true if anotherNode is an ancestor of this node -- if it is this node, this node's parent, or an ancestor of this node's parent. (Note that a node is considered an ancestor of itself.) If anotherNode is null, this method returns false. This operation is at worst O(h) where h is the distance from the root to this node.

 public boolean isNodeChild(TreeNode aNode) 
{
        boolean retval;
        if (aNode == null) {
            retval = false;
        } else {
            if (getChildCount() == 0) {
                retval = false;
            } else {
                retval = (aNode.getParent() == this);
            }
        }
        return retval;
}

Returns true if aNode is a child of this node. If aNode is null, this method returns false.

 public boolean isNodeDescendant(DefaultMutableTreeNode anotherNode) 
{
        if (anotherNode == null)
            return false;
        return anotherNode.isNodeAncestor(this);
}

Returns true if anotherNode is a descendant of this node -- if it is this node, one of this node's children, or a descendant of one of this node's children. Note that a node is considered a descendant of itself. If anotherNode is null, returns false. This operation is at worst O(h) where h is the distance from the root to anotherNode.

 public boolean isNodeRelated(DefaultMutableTreeNode aNode) 
{
        return (aNode != null) && (getRoot() == aNode.getRoot());
}

Returns true if and only if aNode is in the same tree as this node. Returns false if aNode is null.

 public boolean isNodeSibling(TreeNode anotherNode) 
{
        boolean retval;
        if (anotherNode == null) {
            retval = false;
        } else if (anotherNode == this) {
            retval = true;
        } else {
            TreeNode  myParent = getParent();
            retval = (myParent != null && myParent == anotherNode.getParent());
            if (retval && !((DefaultMutableTreeNode)getParent())
                           .isNodeChild(anotherNode)) {
                throw new Error("sibling has different parent");
            }
        }
        return retval;
}

Returns true if anotherNode is a sibling of (has the same parent as) this node. A node is its own sibling. If anotherNode is null, returns false.

 public boolean isRoot() 
{
        return getParent() == null;
}

Returns true if this node is the root of the tree. The root is the only node in the tree with a null parent; every tree has exactly one root.

 public Enumeration pathFromAncestorEnumeration(TreeNode ancestor) 
{
        return new PathBetweenNodesEnumeration(ancestor, this);
}

Creates and returns an enumeration that follows the path from ancestor to this node. The enumeration's nextElement() method first returns ancestor, then the child of ancestor that is an ancestor of this node, and so on, and finally returns this node. Creation of the enumeration is O(m) where m is the number of nodes between this node and ancestor, inclusive. Each nextElement() message is O(1).

Modifying the tree by inserting, removing, or moving a node invalidates any enumerations created before the modification.

 public Enumeration postorderEnumeration() 
{
        return new PostorderEnumeration(this);
}

Creates and returns an enumeration that traverses the subtree rooted at this node in postorder. The first node returned by the enumeration's nextElement() method is the leftmost leaf. This is the same as a depth-first traversal.

Modifying the tree by inserting, removing, or moving a node invalidates any enumerations created before the modification.

 public Enumeration preorderEnumeration() 
{
        return new PreorderEnumeration(this);
}

Creates and returns an enumeration that traverses the subtree rooted at this node in preorder. The first node returned by the enumeration's nextElement() method is this node.

Modifying the tree by inserting, removing, or moving a node invalidates any enumerations created before the modification.

 public  void remove(int childIndex) 
{
        MutableTreeNode child = (MutableTreeNode)getChildAt(childIndex);
        children.removeElementAt(childIndex);
        child.setParent(null);
}

Removes the child at the specified index from this node's children and sets that node's parent to null. The child node to remove must be a MutableTreeNode.

 public  void remove(MutableTreeNode aChild) 
{
        if (aChild == null) {
            throw new IllegalArgumentException("argument is null");
        }
        if (!isNodeChild(aChild)) {
            throw new IllegalArgumentException("argument is not a child");
        }
        remove(getIndex(aChild));       // linear search
}

Removes aChild from this node's child array, giving it a null parent.

 public  void removeAllChildren() 
{
        for (int i = getChildCount()-1; i  >= 0; i--) {
            remove(i);
        }
}

Removes all of this node's children, setting their parents to null. If this node has no children, this method does nothing.

 public  void removeFromParent() 
{
        MutableTreeNode parent = (MutableTreeNode)getParent();
        if (parent != null) {
            parent.remove(this);
        }
}

Removes the subtree rooted at this node from the tree, giving this node a null parent. Does nothing if this node is the root of its tree.

 public  void setAllowsChildren(boolean allows) 
{
        if (allows != allowsChildren) {
            allowsChildren = allows;
            if (!allowsChildren) {
                removeAllChildren();
            }
        }
}

Determines whether or not this node is allowed to have children. If allows is false, all of this node's children are removed.

Note: By default, a node allows children.

 public  void setParent(MutableTreeNode newParent) 
{
        parent = newParent;
}

Sets this node's parent to newParent but does not change the parent's child array. This method is called from insert() and remove() to reassign a child's parent, it should not be messaged from anywhere else.

 public  void setUserObject(Object userObject) 
{
        this.userObject = userObject;
}

Sets the user object for this node to userObject.

 public String toString() 
{
        if (userObject == null) {
            return "";
        } else {
            return userObject.toString();
        }
}

Returns the result of sending toString() to this node's user object, or the empty string if the node has no user object.