lcsim/src/org/lcsim/plugin/browser/sort
diff -N DefaultSortableTableModel.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DefaultSortableTableModel.java 1 Jun 2007 23:58:58 -0000 1.1
@@ -0,0 +1,459 @@
+package org.lcsim.plugin.browser.sort;
+
+import java.util.Comparator;
+
+import javax.swing.event.EventListenerList;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.TableModel;
+import org.lcsim.plugin.browser.*;
+
+/**
+ * Converts any TableModel to a SortableTableModel.
+ * @author Tony Johnson
+ * @version $Id: DefaultSortableTableModel.java,v 1.1 2007/06/01 23:58:58 tonyj Exp $
+ */
+public class DefaultSortableTableModel implements SortableTableModel
+{
+ private Comparator comparator = new DefaultComparator();
+ private TableModel source;
+ private EventListenerList listeners = new EventListenerList();
+ private TableModelListener internalListener = new InternalTableModelListener();
+ private int sortColumn = UNSORTED;
+ private boolean ascending = true;
+ private int[] rowMap;
+ private int[] reverseMap;
+ boolean reverseMapValid = false;
+ private int nRows;
+
+ /**
+ * Creates a new instance of DefaultTableSorter
+ * @param source The table model to be converted.
+ */
+ public DefaultSortableTableModel(TableModel source)
+ {
+ this.source = source;
+ }
+ private int mapFromSorted(int rowIndex)
+ {
+ return rowMap == null ? rowIndex : rowMap[rowIndex];
+ }
+ private int mapToSorted(int rowIndex)
+ {
+ if (rowMap != null && !reverseMapValid)
+ {
+ if (reverseMap == null || reverseMap.length < nRows)
+ {
+ reverseMap = new int[rowMap.length];
+ }
+ for (int i=0; i<nRows; i++) reverseMap[rowMap[i]] = i;
+ reverseMapValid = true;
+ }
+ return rowMap == null ? rowIndex : reverseMap[rowIndex];
+ }
+
+ public void addTableModelListener(TableModelListener l)
+ {
+ if (listeners.getListenerCount() == 0)
+ {
+ // If we have not been listening for changes to model, we must assume
+ // it has totally changed!
+ dataChanged();
+ source.addTableModelListener(internalListener);
+ }
+ listeners.add(TableModelListener.class, l);
+ }
+
+ public Class getColumnClass(int columnIndex)
+ {
+ return source.getColumnClass(columnIndex);
+ }
+
+ public int getColumnCount()
+ {
+ return source.getColumnCount();
+ }
+
+ public String getColumnName(int columnIndex)
+ {
+ return source.getColumnName(columnIndex);
+ }
+
+ public int getRowCount()
+ {
+ return source.getRowCount();
+ }
+
+ public Object getValueAt(int rowIndex, int columnIndex)
+ {
+ return source.getValueAt(mapFromSorted(rowIndex),columnIndex);
+ }
+
+ public boolean isCellEditable(int rowIndex, int columnIndex)
+ {
+ return source.isCellEditable(mapFromSorted(rowIndex),columnIndex);
+ }
+
+ public void removeTableModelListener(TableModelListener l)
+ {
+ listeners.remove(TableModelListener.class, l);
+ if (listeners.getListenerCount() == 0) source.removeTableModelListener(internalListener);
+ }
+
+ public void setValueAt(Object aValue, int rowIndex, int columnIndex)
+ {
+ source.setValueAt(aValue, mapFromSorted(rowIndex), columnIndex);
+ }
+
+ public void sort(int column, boolean ascending)
+ {
+ if (column == UNSORTED)
+ {
+ if (this.sortColumn != UNSORTED)
+ {
+ rowMap = null;
+ reverseMap = null;
+ reverseMapValid = false;
+ this.sortColumn = column;
+ TableModelEvent ee = new TableModelEvent(this,0,source.getRowCount()-1,TableModelEvent.ALL_COLUMNS);
+ fireTableChanged(ee);
+ }
+ }
+ else if (column == this.sortColumn)
+ {
+ if (ascending != this.ascending)
+ {
+ this.ascending = ascending;
+ for (int i=0; i<nRows/2; i++) swap(i,nRows-1-i);
+ reverseMapValid = false;
+ TableModelEvent ee = new TableModelEvent(this,0,nRows-1,TableModelEvent.ALL_COLUMNS);
+ fireTableChanged(ee);
+ }
+ }
+ else
+ {
+ if (rowMap == null)
+ {
+ nRows = source.getRowCount();
+ rowMap = new int[nRows+10]; // Leave a little room for expansion
+ for (int i=0; i<nRows; i++) rowMap[i] = i;
+ }
+ this.sortColumn = column;
+ this.ascending = ascending;
+ reverseMapValid = false;
+ sort1(0,nRows);
+ TableModelEvent ee = new TableModelEvent(this,0,nRows-1,TableModelEvent.ALL_COLUMNS);
+ fireTableChanged(ee);
+ }
+ }
+ private void reSort()
+ {
+ reverseMapValid = false;
+ sort1(0,nRows);
+ TableModelEvent ee = new TableModelEvent(this,0,nRows-1,TableModelEvent.ALL_COLUMNS);
+ fireTableChanged(ee);
+ }
+ private void dataChanged()
+ {
+ // Entire data was changed, including (perhaps) number of rows
+ nRows = source.getRowCount();
+ rowMap = new int[nRows+10]; // Leave a little room for expansion
+ for (int i=0; i<nRows; i++) rowMap[i] = i;
+ reverseMapValid = false;
+ sort1(0,nRows);
+ TableModelEvent ee = new TableModelEvent(this,0,Integer.MAX_VALUE,TableModelEvent.ALL_COLUMNS);
+ fireTableChanged(ee);
+ }
+ // Insert a newly added source row in a sorted list
+ private int rowWasInserted(int row)
+ {
+ if (nRows == rowMap.length)
+ {
+ int[] newMap = new int[rowMap.length+10];
+ System.arraycopy(rowMap,0,newMap,0,rowMap.length);
+ rowMap = newMap;
+ }
+ // Add new row to the end to begin with
+ for (int i=0; i<nRows; i++)
+ {
+ if (rowMap[i] >= row) rowMap[i]++;
+ }
+ rowMap[nRows] = row;
+ // Do a binary search to find out where the new row should go
+ int insertPoint = binarySearch(nRows,0,nRows);
+ if (insertPoint != nRows)
+ {
+ System.arraycopy(rowMap,insertPoint, rowMap, insertPoint+1,nRows-insertPoint);
+ rowMap[insertPoint] = row;
+ }
+ nRows++;
+ reverseMapValid = false;
+ return insertPoint;
+ }
+ private int binarySearch(int newRow, int start, int end)
+ {
+ if (start-end < 5)
+ {
+ for (int i=start; i<end; i++)
+ {
+ if (compare(newRow,i) <= 0 ) return i;
+ }
+ return end;
+ }
+ int mid = end-start >> 1;
+ int result = compare(newRow,mid);
+ if (result == 0) return mid;
+ else if (result > 0) return binarySearch(newRow,mid,end);
+ else return binarySearch(newRow,start,mid);
+ }
+ private int rowWasDeleted(int row)
+ {
+ int sortedRow = mapToSorted(row);
+ System.arraycopy(rowMap,sortedRow+1,rowMap,sortedRow,nRows-sortedRow-1);
+ nRows--;
+ for (int i=0; i<nRows; i++)
+ {
+ if (rowMap[i] > row) rowMap[i]--;
+ }
+ reverseMapValid = false;
+ return sortedRow;
+ }
+
+ private Object get(int index)
+ {
+ return source.getValueAt(rowMap[index], sortColumn);
+ }
+ private int compare(int i, int j)
+ {
+ return comparator.compare(get(i),get(j)) * (ascending ? 1 : -1);
+ }
+ private int compare(Object o, int j)
+ {
+ return comparator.compare(o,get(j)) * (ascending ? 1 : -1);
+ }
+ private void swap(int i, int j)
+ {
+ int tmp = rowMap[i];
+ rowMap[i] = rowMap[j];
+ rowMap[j] = tmp;
+ }
+ private int med3(int a, int b, int c)
+ {
+ return compare(a,b)<0 ?
+ compare(b,c)<0 ? b : compare(a,c)<0 ? c : a :
+ compare(b,c)>0 ? b : compare(a,c)>0 ? c : a;
+ }
+ private void vecswap(int a, int b, int n)
+ {
+ for (int i=0; i<n; i++, a++, b++)
+ swap(a, b);
+ }
+ private void sort1(int off, int len)
+ {
+ // Insertion sort on smallest arrays
+ if (len < 7)
+ {
+ for (int i=off; i<len+off; i++)
+ for (int j=i; j>off && compare(j-1,j)>0; j--)
+ swap(j, j-1);
+ return;
+ }
+
+ // Choose a partition element, v
+ int m = off + (len >> 1); // Small arrays, middle element
+ if (len > 7)
+ {
+ int l = off;
+ int n = off + len - 1;
+ if (len > 40) // Big arrays, pseudomedian of 9
+ {
+ int s = len/8;
+ l = med3(l, l+s, l+2*s);
+ m = med3(m-s, m, m+s);
+ n = med3(n-2*s, n-s, n);
+ }
+ m = med3(l, m, n); // Mid-size, med of 3
+ }
+ Object v = get(m);
+
+ // Establish Invariant: v* (<v)* (>v)* v*
+ int a = off, b = a, c = off + len - 1, d = c;
+ int comp;
+ while(true)
+ {
+ while (b <= c && (comp = compare(v,b)) >= 0)
+ {
+ if (comp == 0) swap(a++, b);
+ b++;
+ }
+ while (c >= b && (comp = compare(v,c)) <= 0)
+ {
+ if (comp == 0) swap(c, d--);
+ c--;
+ }
+ if (b > c) break;
+ swap(b++, c--);
+ }
+
+ // Swap partition elements back to middle
+ int s, n = off + len;
+ s = Math.min(a-off, b-a ); vecswap(off, b-s, s);
+ s = Math.min(d-c, n-d-1); vecswap(b, n-s, s);
+
+ // Recursively sort non-partition-elements
+ if ((s = b-a) > 1) sort1(off, s);
+ if ((s = d-c) > 1) sort1(n-s, s);
+ }
+
+ /**
+ * Notifies all listeners of a change to the sorted TableModel.
+ * @param event The event to be sent to the listeners.
+ */
+ protected void fireTableChanged(TableModelEvent event)
+ {
+ TableModelListener[] l = (TableModelListener[]) listeners.getListeners(TableModelListener.class);
+ for (int i=0; i<l.length; i++)
+ {
+ l[i].tableChanged(event);
+ }
+ }
+
+ public boolean isSortAscending()
+ {
+ return ascending;
+ }
+
+ public int getSortOnColumn()
+ {
+ return sortColumn;
+ }
+ private class InternalTableModelListener implements TableModelListener
+ {
+ public void tableChanged(TableModelEvent e)
+ {
+ int column = e.getColumn();
+ int first = e.getFirstRow();
+ int last = e.getLastRow();
+ int type = e.getType();
+ if (sortColumn == UNSORTED)
+ {
+ TableModelEvent ee = new TableModelEvent(DefaultSortableTableModel.this,first,last,column,type);
+ fireTableChanged(ee);
+ }
+ else if (first == TableModelEvent.HEADER_ROW)
+ {
+ // one or more entire columns was added, removed or changed -- deal with it
+ if (type == TableModelEvent.DELETE)
+ {
+ if (column < sortColumn) sortColumn--;
+ else if (column == sortColumn)
+ {
+ sort(UNSORTED,true);
+ }
+ }
+ else if (type == TableModelEvent.INSERT)
+ {
+ if (column <= sortColumn && sortColumn != UNSORTED) sortColumn++;
+ }
+ else if (type == TableModelEvent.UPDATE)
+ {
+ if (column == sortColumn || column == TableModelEvent.ALL_COLUMNS) reSort();
+ }
+ TableModelEvent ee = new TableModelEvent(DefaultSortableTableModel.this,first,last,column,type);
+ fireTableChanged(ee);
+ }
+ else if (column == TableModelEvent.ALL_COLUMNS)
+ {
+ // one or more rows were added, removed or changed -- deal with it
+
+ if (type == TableModelEvent.DELETE)
+ {
+ for (int i=first; i<=last; i++)
+ {
+ int sortedRow = rowWasDeleted(i);
+ TableModelEvent ee = new TableModelEvent(DefaultSortableTableModel.this,sortedRow,sortedRow,column,type);
+ fireTableChanged(ee);
+ }
+ }
+ else if (type == TableModelEvent.INSERT)
+ {
+ for (int i=first; i<=last; i++)
+ {
+ int sortedRow = rowWasInserted(i);
+ TableModelEvent ee = new TableModelEvent(DefaultSortableTableModel.this,sortedRow,sortedRow,column,type);
+ fireTableChanged(ee);
+ }
+ }
+ else if (type == TableModelEvent.UPDATE)
+ {
+ if (Integer.MAX_VALUE == last)
+ {
+ dataChanged();
+ }
+ else
+ {
+ for (int i=first; i<=last; i++)
+ {
+ int oldRow = rowWasDeleted(i);
+ int newRow = rowWasInserted(i);
+ if (oldRow == newRow)
+ {
+ TableModelEvent ee = new TableModelEvent(DefaultSortableTableModel.this,newRow,newRow,column,type);
+ fireTableChanged(ee);
+ }
+ else
+ {
+ TableModelEvent ee1 = new TableModelEvent(DefaultSortableTableModel.this,oldRow,oldRow,TableModelEvent.ALL_COLUMNS,TableModelEvent.DELETE);
+ fireTableChanged(ee1);
+ TableModelEvent ee2 = new TableModelEvent(DefaultSortableTableModel.this,newRow,newRow,TableModelEvent.ALL_COLUMNS,TableModelEvent.INSERT);
+ fireTableChanged(ee2);
+ }
+ }
+ }
+ }
+ }
+ else if (type == TableModelEvent.UPDATE)
+ {
+ if (column == sortColumn)
+ {
+ for (int i=first; i<=last; i++)
+ {
+ int oldRow = rowWasDeleted(i);
+ int newRow = rowWasInserted(i);
+ if (oldRow == newRow)
+ {
+ TableModelEvent ee = new TableModelEvent(DefaultSortableTableModel.this,newRow,newRow,column,type);
+ fireTableChanged(ee);
+ }
+ else
+ {
+ TableModelEvent ee1 = new TableModelEvent(DefaultSortableTableModel.this,oldRow,oldRow,TableModelEvent.ALL_COLUMNS,TableModelEvent.DELETE);
+ fireTableChanged(ee1);
+ TableModelEvent ee2 = new TableModelEvent(DefaultSortableTableModel.this,newRow,newRow,TableModelEvent.ALL_COLUMNS,TableModelEvent.INSERT);
+ fireTableChanged(ee2);
+ }
+ }
+ }
+ else
+ {
+ for (int i=first; i<=last; i++)
+ {
+ int sortedRow = mapToSorted(i);
+ TableModelEvent ee = new TableModelEvent(DefaultSortableTableModel.this,sortedRow,sortedRow,column,type);
+ fireTableChanged(ee);
+ }
+ }
+ }
+ else throw new UnsupportedOperationException("An unsupported TableModelEvent was found: "+e);
+ }
+ }
+ private class DefaultComparator implements Comparator
+ {
+ public int compare(Object o1, Object o2)
+ {
+ if ((o1 instanceof Comparable) && (o2 instanceof Comparable))
+ return ((Comparable) o1).compareTo((Comparable) o2);
+ else return o1.toString().compareTo(o2.toString());
+ }
+ }
+}
lcsim/src/org/lcsim/plugin/browser/sort
diff -N TableSorter.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ TableSorter.java 1 Jun 2007 23:58:58 -0000 1.1
@@ -0,0 +1,202 @@
+// Copyright 2004, FreeHEP.
+package org.lcsim.plugin.browser.sort;
+
+import java.awt.Component;
+import java.awt.Graphics;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+import javax.swing.Icon;
+import javax.swing.JLabel;
+import javax.swing.JTable;
+import javax.swing.table.JTableHeader;
+import javax.swing.table.TableModel;
+import org.freehep.swing.table.TableColumnHeaderListener;
+import org.freehep.swing.table.TableHeaderCellRenderer;
+
+/**
+ * Utility to add a sorter for columns to a JTable which has a SortableTableModel.
+ * <p>
+ * Example of use:
+ * <pre>
+ * TableModel model = ...
+ * DefaultSortableTableModel sm = new DefaultSortableTableModel(model);
+ * JTable table = new JTable(sm);
+ * TableSorter sorter = new TableSorter(table);
+ * </pre>
+ * @author Mark Donszelmann
+ * @author Tony Johnson
+ * @version $Id: TableSorter.java,v 1.1 2007/06/01 23:58:58 tonyj Exp $
+ * @see org.freehep.swing.table.SortableTableModel
+ */
+public class TableSorter
+{
+ private static Icon downTriangle = new Triangle(false);
+ private static Icon upTriangle = new Triangle(true);
+
+ private SortableTableModel model;
+ private JTableHeader header;
+
+ /**
+ * Create a TableSorter. The table will initially be unsorted.
+ * @param table The table to be sorted
+ */
+ public TableSorter(JTable table)
+ {
+ table.addPropertyChangeListener("model",new ModelChangeListener());
+ modelChanged(table.getModel());
+ header = table.getTableHeader();
+ header.addMouseListener(new HeaderListener());
+ header.setDefaultRenderer(new HeaderRenderer());
+ }
+
+ /**
+ * Create a TableSorter. The table will initially be sorted in ascending order by the given column.
+ * @param table The table to be sorted.
+ * @param column The column on which to sort, or <CODE>SortableTableModel.UNSORTED</CODE>
+ */
+ public TableSorter(JTable table, int column)
+ {
+ this(table, column, true);
+ }
+
+ /**
+ * Create a TableSorter specifiying initial sorting parameters.
+ * @param table The table to be sorted.
+ * @param column The column on which to sort, or <CODE>SortableTableModel.UNSORTED</CODE>
+ * @param ascending <CODE>true</CODE> for ascending order, <CODE>false</CODE> for descending order
+ */
+ public TableSorter(JTable table, int column, boolean ascending)
+ {
+ this(table);
+ sort(column,ascending);
+ }
+
+ /**
+ * Find the current sort column.
+ * @return The current sort column, or <CODE>SortableTableModel.UNSORTED</CODE>
+ */
+ public int getSortOnColumn()
+ {
+ return model == null ? SortableTableModel.UNSORTED : model.getSortOnColumn();
+ }
+
+ /**
+ * Set the sort column.
+ * @param column The column on which to sort, or <CODE>SortableTableModel.UNSORTED</CODE>
+ */
+ public void setSortOnColumn(int column)
+ {
+ if (model != null) model.sort(column,true);
+ }
+
+ /**
+ * Get the current sort order.
+ * @return <CODE>true</CODE> if ascending order, <CODE>false</CODE> for descending order.
+ */
+ public boolean isSortAscending()
+ {
+ return model == null ? true : model.isSortAscending();
+ }
+
+ /**
+ * Set the current sort order.
+ * @param ascending <CODE>true</CODE> for ascending order, <CODE>false</CODE> for descending order
+ */
+ public void setSortAscending(boolean ascending)
+ {
+ if (model != null) model.sort(model.getSortOnColumn(),ascending);
+ }
+
+ private void sort(int sortOnColumn, boolean sortAscending)
+ {
+ if (model != null)
+ {
+ model.sort(sortOnColumn, sortAscending);
+ header.resizeAndRepaint();
+ }
+ }
+ private void modelChanged(TableModel model)
+ {
+ this.model = model instanceof SortableTableModel ? (SortableTableModel) model : null;
+ }
+ private class ModelChangeListener implements PropertyChangeListener
+ {
+ public void propertyChange(PropertyChangeEvent evt)
+ {
+ modelChanged((TableModel) evt.getNewValue());
+ }
+ }
+ private class HeaderListener extends TableColumnHeaderListener
+ {
+
+ public void headerClicked(JTable table, int col)
+ {
+ if (model != null)
+ {
+ if (col != model.getSortOnColumn())
+ {
+ sort(col, true);
+ }
+ else
+ {
+ sort(model.getSortOnColumn(), !model.isSortAscending());
+ }
+ }
+ }
+ }
+
+ private class HeaderRenderer extends TableHeaderCellRenderer
+ {
+
+ public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int col)
+ {
+ JLabel label = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, col);
+ if (model != null && table.convertColumnIndexToModel(col) == model.getSortOnColumn())
+ {
+ label.setIcon(model.isSortAscending() ? downTriangle : upTriangle);
+ }
+ else
+ {
+ label.setIcon(null);
+ }
+ return label;
+ }
+ }
+ private static class Triangle implements Icon
+ {
+ private boolean up;
+ private static final int size = 16;
+ private static final int[] xxdown = { 3 , 12, 7 };
+ private static final int[] yydown = { 5 , 5, 10 };
+ private static final int[] xxup = { 2 , 12, 7 };
+ private static final int[] yyup = { 10 , 10, 4 };
+ Triangle(boolean up)
+ {
+ this.up = up;
+ }
+
+ public int getIconHeight()
+ {
+ return size;
+ }
+
+ public int getIconWidth()
+ {
+ return size;
+ }
+
+ public void paintIcon(Component c, Graphics g, int x, int y)
+ {
+ int[] xp = new int[3];
+ int[] yp = new int[3];
+ for (int i=0; i<3; i++)
+ {
+ xp[i] = x + (up ? xxup[i] : xxdown[i]);
+ yp[i] = y + (up ? yyup[i] : yydown[i]);
+ }
+ g.setColor(c.getForeground());
+ g.fillPolygon(xp,yp,3);
+ }
+ }
+}
lcsim/src/org/lcsim/plugin/browser
diff -u -r1.7 -r1.8
--- CollectionTable.java 16 Feb 2007 01:02:08 -0000 1.7
+++ CollectionTable.java 1 Jun 2007 23:58:58 -0000 1.8
@@ -8,6 +8,7 @@
import java.awt.event.ActionListener;
import java.lang.reflect.Array;
import java.util.Collection;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.swing.JButton;
@@ -21,18 +22,19 @@
import javax.swing.table.TableModel;
import org.freehep.application.Application;
import org.freehep.application.studio.Studio;
-import org.freehep.swing.table.DefaultSortableTableModel;
-import org.freehep.swing.table.TableSorter;
import org.freehep.util.ScientificFormat;
import org.lcsim.event.EventHeader;
import org.lcsim.event.EventHeader.LCMetaData;
+import org.lcsim.plugin.browser.sort.DefaultSortableTableModel;
+import org.lcsim.plugin.browser.sort.SortableTableModel;
+import org.lcsim.plugin.browser.sort.TableSorter;
import org.openide.util.Lookup.Result;
import org.openide.util.Lookup.Template;
/**
*
* @author tonyj
- * @version $Id: CollectionTable.java,v 1.7 2007/02/16 01:02:08 jeremy Exp $
+ * @version $Id: CollectionTable.java,v 1.8 2007/06/01 23:58:58 tonyj Exp $
*/
class CollectionTable extends JPanel implements ActionListener
{
@@ -46,6 +48,8 @@
private EventHeader m_lce;
private Studio m_app;
private Throwable error;
+ private Map<TableModel,SortableTableModel> sortedModels = new HashMap<TableModel,SortableTableModel>();
+ private Map<TableModel,TableColumnModel> columnModels = new HashMap<TableModel,TableColumnModel>();
CollectionTable(Studio app)
{
@@ -67,9 +71,12 @@
m_table.setDefaultRenderer(new double[0].getClass(),new ArrayRenderer());
m_table.setDefaultRenderer(new float[0].getClass(),new ArrayRenderer());
m_table.setDefaultRenderer(new int[0].getClass(),new ArrayRenderer());
+ m_table.setDefaultRenderer(new short[0].getClass(),new ArrayRenderer());
m_table.setDefaultRenderer(new String[0].getClass(),new ArrayRenderer());
m_table.setDefaultRenderer(Hep3Vector.class,new VectorRenderer());
m_table.setDefaultRenderer(Object.class, new LCObjectRenderer());
+
+ new TableSorter(m_table);
}
void setEvent(EventHeader event)
{
@@ -141,10 +148,14 @@
if (model.canDisplay(type))
{
model.setData(meta,coll);
- //DefaultSortableTableModel sm = new DefaultSortableTableModel(model);
- //m_table.setModel(sm);
- //TableSorter sorter = new TableSorter(m_table);
- m_table.setModel(model);
+ SortableTableModel sortedModel = sortedModels.get(model);
+ if (sortedModel == null)
+ {
+ sortedModel = new DefaultSortableTableModel(model);
+ sortedModels.put(model,sortedModel);
+ }
+ // This resets the columns, would be nice to try to keep them
+ m_table.setModel(sortedModel);
ok = true;
break;
}