JTree with XML Content

Question

Hi Friends,
I am trying to create a JTree whose data will come from a XML Document. Whenever the tree is refreshed (There is a JPopupMenu on the tree which allows the user to call refresh), the tree must update itself with the underlying XML document. If there is any change in the xml doc, it must be reflected in the tree. However, the tree must not collapse when the refresh is called. For example if I have a tree like this:-
+ Root
    |
    ------ Child #1
    |            |
    |            -------- A
    |            |
    |            -------- B
    |
    +------ Child #2
    |
    ------- Child #3
                |
                -------- AAA
                |
                -------- BBBThe XML Document for the above tree structure would be:-
<?xml version="1.0" encoding="UTF-8"?>
<Root>Root
      <Child> Child #1
            <SubChild>A</SubChild>
            <SubChild>B</SubChild>
      </Child>
      <Child> Child #2
            <SubChild>AA</SubChild>
            <SubChild>BB</SubChild>
      </Child>
      <Child> Child #3
            <SubChild>AAA</SubChild>
            <SubChild>BBB</SubChild>
      </Child>
</Root>Now if i add another node (CCC) in Child #3 (by adding another Subchild element in the XML document), and click refresh on the tree, the tree should look like:-
+ Root
    |
    ------ Child #1
    |            |
    |            -------- A
    |            |
    |            -------- B
    |
    +------ Child #2
    |
    ------- Child #3
                |
                -------- AAA
                |
                -------- BBB
                |
                -------- CCCHowever, if i am trying to reload the tree model, after reading the XML file, the whole tree collapses.
Can anyone please help me out with this problem?
Thanx a lot in advance,
~Debopam

Answer 1

* XMLNode.java
* Created on December 18, 2004, 4:25 PM
package debopam.utils.xml;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import java.util.Vector;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeNode;
import org.jdom.Element;
* @author Debopam Ghoshal
public class XMLNode implements MutableTreeNode
    private Element nodeElement;
    private XMLNode parent;
    /** optional user object */
    transient protected Object     userObject;
    /** true if the node is able to have children */
    protected boolean allowsChildren;
    /** array of children, may be null if this node has no children */
    protected Vector children;
     * An enumeration that is always empty. This is used when an enumeration
     * of a leaf node's children is requested.
    static public final Enumeration<TreeNode> EMPTY_ENUMERATION
            = new Enumeration<TreeNode>()
        public boolean hasMoreElements()
        { return false; }
        public TreeNode nextElement()
            throw new NoSuchElementException("No more elements");
    /** Creates a new instance of XMLNode */
    public XMLNode(Element nodeElement, boolean allowsChildren)
        this.nodeElement = nodeElement;
        this.allowsChildren = allowsChildren;
    public XMLNode(String nodeName, boolean allowsChildren)
        nodeElement = new Element(nodeName);
        this.allowsChildren = allowsChildren;
     * 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.
     * @return     an Enumeration of this node's children
    public java.util.Enumeration children()
        if(children == null)
            return EMPTY_ENUMERATION;
        else
            return children.elements();
     * Returns true if this node is allowed to have children.
     * @return     true if this node allows children, else false
    public boolean getAllowsChildren()
        return allowsChildren;
     * Determines whether or not this node is allowed to have children.
     * If <code>allows</code> is false, all of this node's children are
     * removed.
     * <p>
     * Note: By default, a node allows children.
     * @param     allows     true if this node is allowed to have children
    public void setAllowsChildren(boolean allows)
        if (allows != allowsChildren)
            allowsChildren = allows;
            if (!allowsChildren)
                removeAllChildren();
     * Returns the child at the specified index in this node's child array.
     * @param     index     an index into this node's child array
     * @exception     ArrayIndexOutOfBoundsException     if <code>index</code>
     *                              is out of bounds
     * @return     the TreeNode in this node's child array at  the specified index
    public javax.swing.tree.TreeNode getChildAt(int index)
        if (children == null)
            throw new ArrayIndexOutOfBoundsException("node has no children");
        return (TreeNode)children.elementAt(index);
     * Returns the number of children of this node.
     * @return     an int giving the number of children of this node
    public int getChildCount()
        if (children == null)
            return 0;
        else
            return children.size();
     * 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
     * <code>-1</code>.  This method performs a linear search and is O(n)
     * where n is the number of children.
     * @param     aChild     the TreeNode to search for among this node's children
     * @exception     IllegalArgumentException     if <code>aChild</code>
     *                                   is null
     * @return     an int giving the index of the node in this node's child
     *          array, or <code>-1</code> if the specified node is a not
     *          a child of this node
    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 this node's parent or null if this node has no parent.
     * @return     this node's parent TreeNode, or null if this node has no parent
    public TreeNode getParent()
        return parent;
     * Removes <code>newChild</code> 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 <code>childIndex</code>.
     * <code>newChild</code> must not be null and must not be an ancestor of
     * this node.
     * @param     newChild     the MutableTreeNode to insert under this node
     * @param     childIndex     the index in this node's child array
     *                    where this node is to be inserted
     * @exception     ArrayIndexOutOfBoundsException     if
     *                    <code>childIndex</code> is out of bounds
     * @exception     IllegalArgumentException     if
     *                    <code>newChild</code> is null or is an
     *                    ancestor of this node
     * @exception     IllegalStateException     if this node does not allow
     *                              children
     * @see     #isNodeDescendant
    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);
    public boolean isLeaf()
        return !nodeElement.hasChildren();
     * 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 <code>MutableTreeNode</code>.
     * @param     childIndex     the index in this node's child array
     *                    of the child to remove
     * @exception     ArrayIndexOutOfBoundsException     if
     *                    <code>childIndex</code> is out of bounds
    public void remove(int childIndex)
        MutableTreeNode child = (MutableTreeNode)getChildAt(childIndex);
        children.removeElementAt(childIndex);
        child.setParent(null);
     * Removes <code>aChild</code> from this node's child array, giving it a
     * null parent.
     * @param     aChild     a child of this node to remove
     * @exception     IllegalArgumentException     if <code>aChild</code>
     *                         is null or is not a child of this node
    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 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 removeFromParent()
        MutableTreeNode parent = (MutableTreeNode)getParent();
        if (parent != null)
            parent.remove(this);
     * Sets this node's parent to <code>newParent</code> but does not
     * change the parent's child array.  This method is called from
     * <code>insert()</code> and <code>remove()</code> to
     * reassign a child's parent, it should not be messaged from anywhere
     * else.
     * @param     newParent     this node's new parent
    public void setParent(MutableTreeNode mutableTreeNode)
        this.parent = parent;
    public void setUserObject(Object obj)
        this.userObject = obj;
    public Element getXMLElement()
        return this.nodeElement;
    public String toString()
        return this.nodeElement.getTextTrim();
     * Returns true if <code>anotherNode</code> 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 <code>anotherNode</code> is null, this method returns false.  This
     * operation is at worst O(h) where h is the distance from the root to
     * this node.
     * @see          #isNodeDescendant
     * @see          #getSharedAncestor
     * @param     anotherNode     node to test as an ancestor of this node
     * @return     true if this node is a descendant of <code>anotherNode</code>
    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 <code>aNode</code> is a child of this node.  If
     * <code>aNode</code> is null, this method returns false.
     * @return     true if <code>aNode</code> is a child of this node; false if
     *            <code>aNode</code> is null
    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;
     * Removes all of this node's children, setting their parents to null.
     * If this node has no children, this method does nothing.
    public void removeAllChildren()
        for (int i = getChildCount()-1; i >= 0; i--)
            remove(i);
     * Removes <code>newChild</code> from its parent and makes it a child of
     * this node by adding it to the end of this node's child array.
     * @see          #insert
     * @param     newChild     node to add as a child of this node
     * @exception     IllegalArgumentException    if <code>newChild</code>
     *                              is null
     * @exception     IllegalStateException     if this node does not allow
     *                              children
    public void add(MutableTreeNode newChild)
        if(newChild != null && newChild.getParent() == this)
            insert(newChild, getChildCount() - 1);
        else
            insert(newChild, getChildCount());
     * Indicates whether some other object is "equal to" this one.
     * @param   obj   the reference object with which to compare.
     * @return  <code>true</code> if this object is the same as the obj
     *          argument; <code>false</code> otherwise.
    public boolean equals(XMLNode node)
        boolean retValue;
        retValue = (this.getXMLElement().getTextTrim().equals(node.getXMLElement().getTextTrim())) &&
                (this.getXMLElement().getParent().getTextTrim().equals(node.getXMLElement().getParent().getTextTrim()));
        return retValue;
* XMLTreeModel.java
* Created on December 20, 2004, 11:29 AM
package debopam.utils.xml;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.EventListener;
import java.util.List;
import java.util.Vector;
import javax.swing.event.EventListenerList;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
* @author Debopam Ghoshal
public class XMLTreeModel implements TreeModel
    private XMLNode rootNode;
    private String xmlFileName;
    private Document xmlDocument;
    /** Listeners. */
    protected EventListenerList listenerList = new EventListenerList();
     * Determines how the <code>isLeaf</code> method figures
     * out if a node is a leaf node. If true, a node is a leaf
     * node if it does not allow children. (If it allows
     * children, it is not a leaf node, even if no children
     * are present.) That lets you distinguish between <i>folder</i>
     * nodes and <i>file</i> nodes in a file system, for example.
     * <p>
     * If this value is false, then any node which has no
     * children is a leaf node, and any node may acquire
     * children.
     * @see TreeNode#getAllowsChildren
     * @see TreeModel#isLeaf
     * @see #setAsksAllowsChildren
    protected boolean asksAllowsChildren;
    /** Creates a new instance of XMLTreeModel */
    public XMLTreeModel(String xmlFileName, boolean asksAllowsChildren)
        this.xmlFileName = xmlFileName;
        this.asksAllowsChildren = asksAllowsChildren;
        loadXMLDocument();
        rootNode = makeRootNode();
    public XMLTreeModel(String xmlFileName)
        this(xmlFileName, false);
    private void loadXMLDocument()
        System.out.println("loading xml document...");
        try
            this.xmlDocument = null;
            this.xmlDocument = new SAXBuilder().build(new File(xmlFileName));
        catch(Exception x)
            System.out.println("Error while loading XML Document.");
            x.printStackTrace();
    private XMLNode makeRootNode()
        XMLNode root = new XMLNode(xmlDocument.getRootElement(), true);
        addChildren(root, xmlDocument.getRootElement());
        return root;
    private void addChildren(XMLNode parentXMLNode, Element element)
        List children = element.getChildren();
        for(int i = 0; i < children.size(); i++)
            Element childElement = (Element)children.get(i);
            XMLNode childNode = new XMLNode(childElement, true);
            parentXMLNode.add(childNode);
            addChildren(childNode, childElement);
     * Sets whether or not to test leafness by asking getAllowsChildren()
     * or isLeaf() to the TreeNodes.  If newvalue is true, getAllowsChildren()
     * is messaged, otherwise isLeaf() is messaged.
    public void setAsksAllowsChildren(boolean newValue)
        asksAllowsChildren = newValue;
     * Tells how leaf nodes are determined.
     * @return true if only nodes which do not allow children are
     *         leaf nodes, false if nodes which have no children
     *         (even if allowed) are leaf nodes
     * @see #asksAllowsChildren
    public boolean asksAllowsChildren()
        return asksAllowsChildren;
     * Returns the child of <I>parent</I> at index <I>index</I> in the parent's
     * child array.  <I>parent</I> must be a node previously obtained from
     * this data source. This should not return null if <i>index</i>
     * is a valid index for <i>parent</i> (that is <i>index</i> >= 0 &&
     * <i>index</i> < getChildCount(<i>parent</i>)).
     * @param   parent  a node in the tree, obtained from this data source
     * @return  the child of <I>parent</I> at index <I>index</I>
    public Object getChild(Object parent, int index)
        return ((XMLNode)parent).getChildAt(index);
     * Returns the number of children of <I>parent</I>.  Returns 0 if the node
     * is a leaf or if it has no children.  <I>parent</I> must be a node
     * previously obtained from this data source.
     * @param   parent  a node in the tree, obtained from this data source
     * @return  the number of children of the node <I>parent</I>
    public int getChildCount(Object parent)
        return ((XMLNode)parent).getChildCount();
     * Returns the index of child in parent.
     * If either the parent or child is <code>null</code>, returns -1.
     * @param parent a note in the tree, obtained from this data source
     * @param child the node we are interested in
     * @return the index of the child in the parent, or -1
     *    if either the parent or the child is <code>null</code>
    public int getIndexOfChild(Object parent, Object child)
        if(parent == null || child == null)
            return -1;
        return ((XMLNode)parent).getIndex((XMLNode)child);
     * Sets the root to <code>root</code>. A null <code>root</code> implies
     * the tree is to display nothing, and is legal.
    public void setRoot(XMLNode rootNode)
        Object oldRoot = this.rootNode;
        this.rootNode = rootNode;
        if (rootNode == null && oldRoot != null)
            fireTreeStructureChanged(this, null);
        else
            nodeStructureChanged(rootNode);
     * Returns the root of the tree.  Returns null only if the tree has
     * no nodes.
     * @return  the root of the tree
    public Object getRoot()
        return rootNode;
     * Returns whether the specified node is a leaf node.
     * The way the test is performed depends on the
     * <code>askAllowsChildren</code> setting.
     * @param node the node to check
     * @return true if the node is a leaf node
     * @see #asksAllowsChildren
     * @see TreeModel#isLeaf
    public boolean isLeaf(Object node)
        if(asksAllowsChildren)
            return !((XMLNode)node).getAllowsChildren();
        return ((XMLNode)node).isLeaf();
     * This sets the user object of the TreeNode identified by path
     * and posts a node changed.  If you use custom user objects in
     * the TreeModel you're going to need to subclass this and
     * set the user object of the changed node to something meaningful.
    public void valueForPathChanged(TreePath path, Object newValue)
        XMLNode aNode = (XMLNode)path.getLastPathComponent();
        aNode.setUserObject(newValue);
        nodeChanged(aNode);
     * Invoked this to insert newChild at location index in parents children.
     * This will then message nodesWereInserted to create the appropriate
     * event. This is the preferred way to add children as it will create
     * the appropriate event.
    public void insertNodeInto(XMLNode newChild, XMLNode parent, int index)
        parent.insert(newChild, index);
        int[] newIndexs = new int[1];
        newIndexs[0] = index;
        nodesWereInserted(parent, newIndexs);
     * Message this to remove node from its parent. This will message
     * nodesWereRemoved to create the appropriate event. This is the
     * preferred way to remove a node as it handles the event creation
     * for you.
    public void removeNodeFromParent(XMLNode node)
        XMLNode parent = (XMLNode)node.getParent();
        if(parent == null)
            throw new IllegalArgumentException("node does not have a parent.");
        int[] childIndex = new int[1];
        Object[] removedArray = new Object[1];
        childIndex[0] = parent.getIndex(node);
        parent.remove(childIndex[0]);
        removedArray[0] = node;
        nodesWereRemoved(parent, childIndex, removedArray);
     * Invoke this method after you've changed how node is to be
     * represented in the tree.
    public void nodeChanged(XMLNode node)
        if(listenerList != null && node != null)
            XMLNode parent = (XMLNode)node.getParent();
            if(parent != null)
                int        anIndex = parent.getIndex(node);
                if(anIndex != -1)
                    int[] cIndexs = new int[1];
                    cIndexs[0] = anIndex;
                    nodesChanged(parent, cIndexs);
            else if (node == getRoot())
                nodesChanged(node, null);
     * Invoke this method if you've modified the TreeNodes upon which this
     * model depends.  The model will notify all of its listeners that the
     * model has changed.
    public void reload()
        loadXMLDocument();
        XMLNode tempRootNode = makeRootNode();
        if(!tempRootNode.equals(rootNode))
            // Means that the root node itself has changed.
            System.out.println("Root node changed");
            reload(rootNode);
        //else
            checkForNodesChanged(tempRootNode, rootNode);
     * Invoke this method if you've modified the TreeNodes upon which this
     * model depends.  The model will notify all of its listeners that the
     * model has changed below the node <code>node</code> (PENDING).
    public void reload(XMLNode node)
        if(node != null)
            fireTreeStructureChanged(this, getPathToRoot(node), null, null);
     * Invoke this method after you've inserted some TreeNodes into
     * node.  childIndices should be the index of the new elements and
     * must be sorted in ascending order.
    public void nodesWereInserted(XMLNode node, int[] childIndices)
        if(listenerList != null && node != null && childIndices != null
                && childIndices.length > 0)
            int               cCount = childIndices.length;
            Object[]          newChildren = new Object[cCount];
            for(int counter = 0; counter < cCount; counter++)
                newChildren[counter] = node.getChildAt(childIndices[counter]);
            fireTreeNodesInserted(this, getPathToRoot(node), childIndices,
                    newChildren);
     * Invoke this method after you've removed some TreeNodes from
     * node.  childIndices should be the index of the removed elements and
     * must be sorted in ascending order. And removedChildren should be
     * the array of the children objects that were removed.
    public void nodesWereRemoved(XMLNode node, int[] childIndices,
            Object[] removedChildren)
        if(node != null && childIndices != null)
            fireTreeNodesRemoved(this, getPathToRoot(node), childIndices,
                    removedChildren);
     * Invoke this method after you've changed how the children identified by
     * childIndicies are to be represented in the tree.
    public void nodesChanged(XMLNode node, int[] childIndices)
        if(node != null)
            if (childIndices != null)
                int cCount = childIndices.length;
                if(cCount > 0)
                    Object[] cChildren = new Object[cCount];
                    for(int counter = 0; counter < cCount; counter++)
                        cChildren[counter] = node.getChildAt
                                (childIndices[counter]);
                    fireTreeNodesChanged(this, getPathToRoot(node),
                            childIndices, cChildren);
            else if (node == getRoot())
                fireTreeNodesChanged(this, getPathToRoot(node), null, null);
     * Invoke this method if you've totally changed the children of
     * node and its childrens children...  This will post a
     * treeStructureChanged event.
    public void nodeStructureChanged(XMLNode node)
        if(node != null)
            fireTreeStructureChanged(this, getPathToRoot(node), null, null);
     * 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 aNode the TreeNode to get the path for
    public XMLNode[] getPathToRoot(XMLNode aNode)
        return getPathToRoot(aNode, 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 aNode  the 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 an array of TreeNodes giving the path from the root to the
     *         specified node
    protected XMLNode[] getPathToRoot(XMLNode aNode, int depth)
        XMLNode[] retNodes;
        // This method recurses, traversing towards the root in order
        // size the array. On the way back, it fills in the nodes,
        // starting from the root and working back to the original node.
        /* 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 XMLNode[depth];
        else
            depth++;
            if(aNode == rootNode)
                retNodes = new XMLNode[depth];
            else
                retNodes = getPathToRoot((XMLNode)aNode.getParent(), depth);
            retNodes[retNodes.length - depth] = aNode;
        return retNodes;
    //  Events
     * Adds a listener for the TreeModelEvent posted after the tree changes.
     * @see     #removeTreeModelListener
     * @param   l       the listener to add
    public void addTreeModelListener(TreeModelListener l)
        listenerList.add(TreeModelListener.class, l);
     * Removes a listener previously added with <B>addTreeModelListener()</B>.
     * @see     #addTreeModelListener
     * @param   l       the listener to remove
    public void removeTreeModelListener(TreeModelListener l)
        listenerList.remove(TreeModelListener.class, l);
     * Returns an array of all the tree model listeners
     * registered on this model.
     * @return all of this model's <code>TreeModelListener</code>s
     *         or an empty
     *         array if no tree model listeners are currently registered
     * @see #addTreeModelListener
     * @see #removeTreeModelListener
     * @since 1.4
    public TreeModelListener[] getTreeModelListeners()
        return (TreeModelListener[])listenerList.getListeners(
                TreeModelListener.class);
     * Notifies all listeners that have registered interest for
     * notification on this event type.  The event instance
     * is lazily created using the parameters passed into
     * the fire method.
     * @param source the node being changed
     * @param path the path to the root node
     * @param childIndices the indices of the changed elements
     * @param children the changed elements
     * @see EventListenerList
    protected void fireTreeNodesChanged(Object source, Object[] path,
            int[] childIndices,
            Object[] children)
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2)
            if (listeners==TreeModelListener.class)
// Lazily create the event:
if (e == null)
e = new TreeModelEvent(source, path,
childIndices, children);
((TreeModelListener)listeners[i+1]).treeNodesChanged(e);
* Notifies all listeners that have registered interest for
* notification on this event type. The event instance