JTree collapses when reloaded (open problem)

[S Dan]

I'm trying to reload a part of the jtree, where the node value has been changed (suppose the tree represents directory structure and the some file name has been modified under the root directory). The problem is that, each time I reload it, the tree collapses. I have an utility function to expand the tree but the problem is that the tree nodes changes (basically file names)quite frequently (every sec) and expanding the whole tree after each reload causing horrible flickering.
I tried reload(node), fireTreeStructureChanged(Object source, Object[] path, int[] childIndices, Object[] children) , reload and all sort of relevant methods. But nothing works!! Can anyone tell me how to refresh a node of a tree without collapsing the whole tree.
From my google search, it seems that it is an open problem! I'd appreciate if you could provide me an working example.. As for example a FileTree where a file name change on your local machine will be reflected in that tree dynamically, without collapsing the tree.
Thanks.
-Dan
[ January 17, 2006: Message edited by: S Dan ]

[KiranKiran Chandra]

I am having the same problem, with respect to implementing a tree table. Did you get any leads for your question. Any help in this regards would be greatly appreciated.

Thanks,

Kiran

[Craig Wood]

import java.awt.*;
import java.util.*;
import javax.swing.*;
import javax.swing.tree.*;
 
public class TreeChanges
{
    private JTree getTree()
    {
        DefaultMutableTreeNode
            root = new DefaultMutableTreeNode("root"),
            leaf;
        DefaultMutableTreeNode[]
            nodes    = new DefaultMutableTreeNode[3],
            subNodes = new DefaultMutableTreeNode[8];
        int[][] keys = {  { 1, 2, 3 }, { 3 }, { 1, 2, 3, 4 }  };
        int subIndex = 0;
        for(int j = 0; j < nodes.length; j++)
        {
            nodes[j] = new DefaultMutableTreeNode("node " + (j+1));
            root.insert(nodes[j], j);
            for(int k = 0; k < keys[j].length; k++, subIndex++)
            {
                String id = "sub " + (j+1) + (k+1);
                subNodes[subIndex] = new DefaultMutableTreeNode(id);
                nodes[j].insert(subNodes[subIndex], k);
                for(int m = 0; m < keys[j][k]; m++)
                {
                    id = "leaf " + (j+1) + (k+1) + (m+1);
                    leaf = new DefaultMutableTreeNode(id);
                    subNodes[subIndex].insert(leaf, m);
                }
            }
        }
        DefaultTreeModel model = new DefaultTreeModel(root);
        JTree tree = new JTree(model);
        expandTree(tree);
        return tree;
    }
 
    private void expandTree(JTree tree)
    {
        DefaultMutableTreeNode root = (DefaultMutableTreeNode)tree.getModel().getRoot();
        Enumeration e = root.breadthFirstEnumeration();
        while(e.hasMoreElements())
        {
            DefaultMutableTreeNode node = (DefaultMutableTreeNode)e.nextElement();
            if(node.isLeaf()) break;
            int row = tree.getRowForPath(new TreePath(node.getPath()));
            tree.expandRow(row);
        }
    }
 
    public static void main(String[] args)
    {
        TreeChanges tc = new TreeChanges();
        JTree tree = tc.getTree();
        TreeChanger changer = new TreeChanger(tree);
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new JScrollPane(tree));
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
        changer.start();
    }
}
 
class TreeChanger implements Runnable
{
    JTree tree;
    Random seed;
    Thread thread;
    boolean mutate;
 
    public TreeChanger(JTree tree)
    {
        this.tree = tree;
        seed = new Random();
    }
 
    public void run()
    {
        while(mutate)
        {
            try
            {
                Thread.sleep(1000);
            }
            catch(InterruptedException ie)
            {
                System.err.println("interrupt: " + ie.getMessage());
            }
            DefaultMutableTreeNode node = getRandomNode();
            String data = getRandomData();
            DefaultTreeModel model = (DefaultTreeModel)tree.getModel();
            model.valueForPathChanged(new TreePath(node), data);
        }
    }
 
    private DefaultMutableTreeNode getRandomNode()
    {
        DefaultMutableTreeNode root =
                (DefaultMutableTreeNode)tree.getModel().getRoot();
        // count the nodes in this tree
        Enumeration e = root.breadthFirstEnumeration();
        int count = 0;
        while(e.hasMoreElements())
        {
            e.nextElement();
            count++;
        }
        // pick a random node index, exclusive of the root node [index:0]
        int index = 1 + seed.nextInt(count-1);
        // find the node at the random index of the Enumeration
        e = root.breadthFirstEnumeration();
        count = 0;
        while(e.hasMoreElements())
        {
            Object o = e.nextElement();
            if(count++ == index)
                return (DefaultMutableTreeNode)o;
        }
        return null;
    }
 
    private String getRandomData()
    {
        String alpha = "abcdefghijklmnopqrstuvwxyz";
        int len = 5;
        char[] chars = new char[len];
        for(int j = 0; j < len; j++)
            chars[j] = alpha.charAt(seed.nextInt(alpha.length()));
        return String.valueOf(chars);
    }
 
    public void start()
    {
        mutate = true;
        thread = new Thread(this);
        thread.setPriority(Thread.NORM_PRIORITY);
        thread.start();
    }
}