Restore extension / selection state in JTree with lazy loading

I have an application that contains JTree with support for DefaultTreeModel, which is used to display a file hierarchy that reflects the file system section on my server (I will call it as my client application ). I also have a server application that provides the data that needs to be displayed to my client application (I will refer to this as a server application ). I use the "lazily load children" approach, so I only need to upload files to my tree if the user is interested in them. Lazy loading approach:

• I redefine treeWillExpand(TreeExpansionEvent evt)
• I set the path of choice to the node extension.
• Then I send a message to the server asking the children of this node.
• When the server responds, I get the last selected component of the path.
• Then I use DefaultTreeModel.insertNodeInto()for each returned data file.
• Finally, I call DefaultTreeModel.nodeStructureChanged().

The above works great and I have no problem with lazy loading of children. My problem arises when new data is uploaded to the server, and I want to update the tree to not only include the new data, but also set the extension state and the selected node to what it was before the tree was updated (so that the user does not twitch on the tree just because that to view new data). The stream is as follows:

• New data is uploaded to the server
• The server application archives this data and populates the database with information about the downloaded files.
• , .
• JTree.getExpandedDescendants()
• JTree.getSelectionPath()
• DefaultTreeModel.
• , node.
• , JTree.getExpandedDescendants(), JTree.expandPath() TreePath .
• .

, , , , . , expandPath , , , expandPath. node node. , , , GUI node (), ( ) .

, : JTree, ?

, :

• , equals() hashCode(), .
• , : setExpandsSelectedPaths(true), nodeStructureChanged(), JTree.invalidate()
• , , , , , .

SSCCE:

package tree.sscce;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import java.awt.BorderLayout;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.JButton;
import java.util.Enumeration;
import javax.swing.BoxLayout;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeWillExpandListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.ExpandVetoException;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreePath;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JTextPane;

public class TreeSSCCE extends JFrame implements TreeWillExpandListener {

private static final long serialVersionUID = -1930472429779070045L;

public static void main(String[] args) 
{
    SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            TreeSSCCE inst = new TreeSSCCE();
            inst.setLocationRelativeTo(null);
            inst.setVisible(true);
            inst.setDefaultCloseOperation(EXIT_ON_CLOSE);
        }           
    });
}

private DefaultMutableTreeNode rootNode;
private JTree tree;
private DefaultTreeModel treeModel;
private TreePath selectionPathPriorToNewData;
private Enumeration<TreePath> expandedPathsPriorToNewData;
private int treeSize = 5;

public TreeSSCCE() {

    this.setBounds(0, 0, 500, 400);
    JPanel mainPanel = new JPanel();
    getContentPane().add(mainPanel, BorderLayout.CENTER);
    mainPanel.setBounds(0, 0, 500, 400);
    mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));

    JPanel descriptionPanel = new JPanel();
    descriptionPanel.setBounds(0, 0, 500, 200);
    mainPanel.add(descriptionPanel);

    JTextPane textPane = new JTextPane();
    String newLine = System.getProperty("line.separator");
    descriptionPanel.setLayout(new BorderLayout(0, 0));
    textPane.setText("Start by expanding some nodes then click 'Add New Data' and you will notice that the tree state is not retained.");
    descriptionPanel.add(textPane);

    // Initialize The Tree
    tree = new JTree();
    rootNode = new DefaultMutableTreeNode("Root");
    treeModel = new DefaultTreeModel(rootNode);
    tree.addTreeWillExpandListener(this);
    tree.setModel(treeModel);
    tree.setShowsRootHandles(true);
    populateTree(false);

    JScrollPane scrollPane = new JScrollPane(tree);
    mainPanel.add(scrollPane);

    JPanel buttonPanel = new JPanel();
    mainPanel.add(buttonPanel);

    JButton btnAddNewData = new JButton("Add New Data");
    btnAddNewData.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent arg0) {
            addNewDataToTree();
        }
    });
    buttonPanel.add(btnAddNewData);


}

private void removeAllTreeNodes()
{

    while(!treeModel.isLeaf(treeModel.getRoot()))
    {
        treeModel.removeNodeFromParent((MutableTreeNode)treeModel.getChild(treeModel.getRoot(),0));
    }
    treeModel = null;
    treeModel = new DefaultTreeModel(rootNode);
    tree.setModel(treeModel);
}

public void restoreExpansionState(Enumeration enumeration)
{
    if (enumeration != null) 
    {
        while (enumeration.hasMoreElements()) 
        {
            TreePath treePath = (TreePath) enumeration.nextElement();
            tree.expandPath(treePath);
            tree.setSelectionPath(treePath);
        }
        tree.setSelectionPath(selectionPathPriorToNewData);
    }
}

protected void addNewDataToTree() 
{
    // save the tree state
    selectionPathPriorToNewData = tree.getSelectionPath();
    expandedPathsPriorToNewData = tree.getExpandedDescendants(new TreePath(tree.getModel().getRoot()));
    removeAllTreeNodes();
    populateTree(true);
    restoreExpansionState(expandedPathsPriorToNewData);
}

private void populateTree(boolean newData)
{
    if(newData)
        treeSize++;
    MyParentNode[] parents = new MyParentNode[treeSize];
    for(int i = 0; i < treeSize; i++)
    {
        parents[i] = new MyParentNode("Parent [" + i + "]");
        treeModel.insertNodeInto(parents[i], rootNode, i);
    }
}

@Override
public void treeWillCollapse(TreeExpansionEvent evt) throws ExpandVetoException {
    // Not used.
}

@Override
public void treeWillExpand(TreeExpansionEvent evt) throws ExpandVetoException 
{
    System.out.println("Tree expanding: " + evt.getPath());
    tree.setExpandsSelectedPaths(true);
    tree.setSelectionPath(evt.getPath());
    // we have already loaded the top-level items below root when we
    // connected so lets just return...
    if(evt.getPath().getLastPathComponent().equals(treeModel.getRoot()))
        return;

    // if this is not root lets figure out what we need to do.
    DefaultMutableTreeNode expandingNode = (DefaultMutableTreeNode) evt.getPath().getLastPathComponent();

    // if this node already has children then we don't want to reload so lets return;
    if(expandingNode.getChildCount() > 0)
        return;     
    // if this node has no children then lets add some
    MyParentNode mpn = new MyParentNode("Parent Under " + expandingNode.toString());
    treeModel.insertNodeInto(mpn, expandingNode, expandingNode.getChildCount());
    for(int i = 0; i < 3; i++)
    {
        treeModel.insertNodeInto(new DefaultMutableTreeNode("Node [" + i + "]"), mpn, i);
    }
}

private class MyParentNode extends DefaultMutableTreeNode
{
    private static final long serialVersionUID = 433317389888990065L;
    private String name = "";

    public MyParentNode(String _name)
    {
        super(_name);
        name = _name;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + getOuterType().hashCode();
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        MyParentNode other = (MyParentNode) obj;
        if (!getOuterType().equals(other.getOuterType()))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public boolean isLeaf()
    {
        return false;
    }

    private TreeSSCCE getOuterType() {
        return TreeSSCCE.this;
    }       
}

}

, .

P.S. , , , , ( ;)).