Re: Sortable Java Tree Ta

  To: comp.lang.java.gui
Roedy Green wrote:


Well, I guess you could write a SortedTreeModel adapter class that
contains a similar node pattern to the underlying TreeModel, along with
int[] arrays mapping viewToModel and modelToView

e.g.

public class SortedTreeModel extends AbstractTreeModel {

private Map<Object, int[]> viewToModel;
private Comparator comparator;

public SortedTreeModel(TreeModel delegate) {
     viewToModel = new HashMap<Object, int[]>();
     this.delegate = delegate;
}

public Object getChild(Object parent, int index) {
     int[] viewToModel = getViewToModel(parent);
     if (viewToModel == null)
         return delegate.getChild(parent, index);
     return delegate.getChild(parent, viewToModel[index]);
}

public int getChildCount(Object parent) {
     return delegate.getChildCound(parent);
}

public int getIndexOfChild(Object parent, Object child) {
     int index = delegate.getIndexOfChild(parent, child);
     int[] viewToModel = getViewToModel(parent);
     if (viewToModel == null)
         return index;
     for (int i=0; i<viewToModel.length; i++)
         if (viewToModel[i] == index)
             return i;
     throw new RuntimeException("This should never happen");
}

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

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

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

protected int[] getViewToModel(Object parent) {
     return viewToModel.get(parent);
}

public void setComparator(Comparator comparator) {
     this.comparator = comparator;
     sort(new TreePath(getRoot()), true);
}

protected void sort(TreePath path, boolean recursive) {
     Object parent = path.lastPathComponent();
     int childCount = delegate.getChildCount(parent);
     if (childCount == 0)
         return;
     Object[] children = new Object[childCount];
     int[] viewToModel = new int[childCount];
     for (int i=0; i<childCount; i++) {
         children[i] = delegate.getChild(parent, i);
         if (recursive)
             sort(path.pathByAddingChild(children[i]), recursive);
     }
     Arrays.sort(children, comparator);
     for (int i=0; i<childCount; i++)
         viewToModel[i] = delegate.getIndexOfChild(parent, children[i]);
     this.viewToModel.put(parent, viewToModel);
     fireChildrenChanged(path, childrenArray[children.length], children);
}

private int[] childrenArray(int size) {
     int[] a = new int[size];
     for (int i=0; i<size; i++)
         a[i] = i;
     return a;
}

}

This *should* work, but since I wrote it in my news reader, I make no
guarantees it will even compile.

Now, all you need to do is implement a Comparator for your nodes. And if
it is a dynamic TreeModel, then you need to add the necessary listener
to the delegate and call sort(node) (or sort(node, true) ) whenever the
node changes.

Use it like so:

TreeModel delegate = . . . ; // your underlying TreeModel
TreeModel sorted = new SortedTreeModel(delegate);
JTree tree = new JTree(sorted);
Comparator comp = new MyComparator();
sorted.setComparator(comp);

Obviously, you can extend the identical technique to TreeTableModel.

NOTE: You can try to be more fine grained in your event firing, of course.

Rogan

---
 * Synchronet * The Whitehouse BBS --- whitehouse.hulds.com --- check it out free usenet!
--- Synchronet 3.15a-Win32 NewsLink 1.92
Time Warp of the Future BBS - telnet://time.synchro.net:24