Can I stop JTree caching nodes (in a file system tree)?

Question

I have a JTree implementation for directories in the file system. The problem I have is that when a directory is removed or renamed, the tree still shows the directory in it's parent. The parent tree seems not to be updated for any changes once a node has been expanded.

The model I have written does not cache (I have commented out what limited caching it did have) - it's like the JTree itself has cached the node.

The code (the model is a nested subclass):

public class FileSystemTree
extends JTree
{

// *****************************************************************************
// INSTANCE CREATE/DELETE
// *****************************************************************************

public FileSystemTree() {
    this(new Model(null,null,null));
    }

public FileSystemTree(String startPath) {
    this(new Model(startPath,null,null));
    }

public FileSystemTree(FileSelector inc, FileSelector exc) {
    this(new Model(null,inc,exc));
    }

public FileSystemTree(String startPath, FileSelector inc, FileSelector exc) {
    this(new Model(startPath,inc,exc));
    }

private FileSystemTree(Model model) {
    super(model);

    //setLargeModel(true);
    setRootVisible(false);
    setShowsRootHandles(true);
    putClientProperty("JTree.lineStyle","Angled");
    }

// *****************************************************************************
// INSTANCE METHODS - ACCESSORS
// *****************************************************************************

public Object getRoot() {
    return getModel().getRoot();
    }

// *****************************************************************************
// INSTANCE METHODS
// *****************************************************************************

public String convertValueToText(Object value,boolean selected,boolean expanded,boolean leaf,int row,boolean hasFocus) {
    File                                fil=(File)value;

    return (fil.getName().length()!=0 ? fil.getName() : fil.getPath());
    }

// *****************************************************************************
// STATIC NESTED CLASSES - SUPPORTING MODEL
// *****************************************************************************

    static class Model
    extends Object
    implements TreeModel, FilenameFilter
    {

    private File                        root;                                   // tree root
    //ivate Map                         cache;                                  // caches child counts for directories
    private File[]                      fsRoots;                                // copy of file system roots
    private FileSelector                include;                                // inclusion selector
    private FileSelector                exclude;                                // exclusion selector
    private java.util.List              listeners=new ArrayList();

    public Model(String roo, FileSelector inc, FileSelector exc) {
        super();

        root=(roo==null ? DRIVES : new File(roo));
        //cache=new HashMap();
        fsRoots=(root==DRIVES ? rootList() : null);
        include=inc;
        exclude=exc;
        }

    // *****************************************************************************
    // METHODS - MODEL
    // *****************************************************************************

    public Object getRoot() {
        return root;
        }

    public Object getChild(Object parent, int index) {
        File                            dir=(File)parent;

        if(dir==DRIVES) {
            File[]   chl=fsRoots; //rootList();
            return (index<chl.length ? chl[index] : null);
            }
        else {
            String[] chl=dirList(dir);
            return (index<chl.length ? new File(dir,chl[index]) : null);
            }
        }

    public int getChildCount(Object parent) {
        File                            dir=(File)parent;
        //Integer                         cch=(Integer)cache.get(dir);

        //if(cch!=null) {
        //    return cch.intValue();
        //    }

        if(dir==DRIVES) {
            return fsRoots.length; //rootList().length;
            }
        else if(dir.isDirectory()) {
            return dirList(dir).length;
            }
        else {
            return 0;
            }
        }

    public boolean isLeaf(Object node) {
        return((File)node).isFile();
        }

    public void valueForPathChanged(TreePath path, Object newValue) {
        }

    public int getIndexOfChild(Object parent, Object child) {
        File                            dir=(File)parent;
        File                            fse=(File)child;

        if(dir==DRIVES) {
            File[] ca=fsRoots; //rootList();
            for(int xa=0; xa<ca.length; xa++) {
                if(fse.equals(ca[xa])) { return xa; }
                }
            }
        else {
            String[] ca=dirList(dir);
            for(int xa=0; xa<ca.length; ++xa) {
                if(fse.getName().equals(ca[xa])) { return xa; }
                }
            }
        return -1;
        }

     private File[] rootList() {
        File[]                          lst=File.listRoots();

        if(lst==null) { lst=new File[0]; }
        //cache.put(DRIVES,new Integer(lst.length));
        return lst;
        }

     private String[] dirList(File dir) {
        String[]                        lst=dir.list(this);

        if(lst==null) { lst=new String[0]; }
        //cache.put(dir,new Integer(lst.length));
        return lst;
        }

    // *****************************************************************************
    // METHODS - FILENAME FILTER
    // *****************************************************************************

    public boolean accept(File dir, String nam)  {
        return ((include==null || include.accept(dir,nam)) && (exclude==null || !exclude.accept(dir,nam)));
        }

    // *****************************************************************************
    // METHODS - LISTENER
    // *****************************************************************************

    public void addTreeModelListener(TreeModelListener listener) {
        if(listener != null && !listeners.contains(listener)) {
            listeners.add(listener);
            }
        }

    public void removeTreeModelListener(TreeModelListener listener) {
        if(listener != null) {
            listeners.remove(listener);
            }
        }

    public void fireTreeNodesChanged(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeNodesChanged(evt);
            }
        }

    public void fireTreeNodesInserted(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeNodesInserted(evt);
            }
        }

    public void fireTreeNodesRemoved(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeNodesRemoved(evt);
            }
        }

    public void fireTreeStructureChanged(TreeModelEvent evt) {
        Iterator                        itr=listeners.iterator();

        while(itr.hasNext()) {
            TreeModelListener listener=(TreeModelListener)itr.next();
            listener.treeStructureChanged(evt);
            }
        }
    } // END INNER CLASS

// *****************************************************************************
// STATIC PROPERTIES
// *****************************************************************************

static private final File               DRIVES=new File("*DRIVES");             // marker for listing file system drives

} // END PUBLIC CLASS

Answer 1

You could write some background thread that looks for changes in the filesystem and fire some model modification events if you detect that the directories have changed.

Answer 2

The model is responsible to notify the listeners of any modification in the tree structure. The tree will not refresh itself in absence of such a notification.

Answer 3

Without seeing the code for the Model, are you sure it is being called, such as the getChild method?