JTable addColumn into original position

Question

Hi,
I have wriiten a generic dialog box to allow a user to select the visible columns in a JTable.
Basically a TableColumnModel is passed to the routine to dynamically create a grid of JCheckBox's using the info from getHeaderValue().
I create a list of TableColumn's that are in the TableColumnModel so that I can add a removed column back in again.
My problem is that I cannot add the columns into the required locations.
In the code below:
tcm = TableColumnModel
tc = TableColumn
col = original position of table column
public void setColumnStatus(int col, boolean status)
if (col > -1 && col <= columnNames.length)
int index = col > tcm.getColumnCount() ? tcm.getColumnCount() : col ;
if (status)
tcm.addColumn(tc[col]);
System.err.println("New Column Index :" + tcm.getColumnIndex(tc[col].getIdentifier()));
System.err.println("Original Column Index :" + col);
tcm.moveColumn(tcm.getColumnIndex(tc[col].getIdentifier()), index);
else
tcm.removeColumn(tc[col]);
If I have approached this in the wrong way, I would appreciate some pointers in the right direction.
Things would be so much easier if they would have implemented an isVisible for TableColumnModel.
Regards
Chris

Answer 1

I can't think of a reference that would be appropriate since I made the solution up during a few quiet minutes.
I suppose the closest analogy I can imagine at the moment is that of a SortableTableModel (stay with me for this). The sortable table model wraps a table model and reorders its rows without changing the underlying model. This has proven quite effective in the past and is quite easy to use. You're right, though, the concept can be quite confusing.
Think of the table model being transformed by the sortable table model like this:
ORIGINAL TABLE MODEL     SORTABLE TABLE MODEL
1. goodbye               3. adios
2. see ya                1. goodbye
3. adios                 2. see ya
4. ta ta                 4. ta taAll the sortable table model does is maintain a mapping from its row numbers to the wrapped model's row numbers (ie, row 1 is actually row 3)
I'll post the complete code at the end so that you can have a good look at it.
What I'm suggesting is that something similar can be done for the table column model but rather than "reordering" them we actually add/remove them. But not actually add/remove them, just wrap them in something that makes them appear to be added/removed.
If you'd like me to go further into this then I'd be happy to give it a go.
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
import javax.swing.event.TableModelListener;
import javax.swing.event.TableModelEvent;
import java.util.Comparator;
import java.util.ArrayList;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.HashMap;
* Wrapper for a table model that provides the ability to sort the rows by the values in a particular column.
* @author Kevin Seal
public class SortableTableModel extends AbstractTableModel implements TableModelListener
     protected TableModel tableModel;
     protected int[] sortableColumns;
     protected HashMap comparatorMap;
     private int sortColumn;
     private boolean sortAscending;
     private Comparator comparator;
     private int[] fromModelRow;
     private int[] toModelRow;
     private class ComparableValue implements Comparable
          private Object value;
          private int row;
          private ComparableValue(Object value, int row)
               this.value = value;
               this.row = row;
          private int getRow()
               return row;
          private Object getValue()
               return value;
          public int compareTo(Object obj)
               ComparableValue c = (ComparableValue)obj;
               int i;
               if(comparator == null)
                    if(value == null)
                    i = (c.getValue() == null)?0:-1;
                    else
                         i = ((Comparable)value).compareTo(c.getValue());
               else
                    i = comparator.compare(value, c.getValue());
               if(i == 0)
                    i = c.getRow() - row;
               return sortAscending?i:-i;
     public SortableTableModel(TableModel tableModel, int[] sortableColumns)
          super();
          this.tableModel = tableModel;
             this.sortableColumns = new int[sortableColumns.length];
          System.arraycopy(sortableColumns, 0, this.sortableColumns, 0, sortableColumns.length);
          comparatorMap = new HashMap();
          sortColumn = -1;
          // If the underlying data changes - we wanna know about it!!
          tableModel.addTableModelListener(this);
     public void setComparator(int column, Comparator comparator)
          if(!isColumnSortable(column))
               throw new IllegalArgumentException("Cannot set the Comparator for a column that isn't sortable");
          comparatorMap.put(new Integer(column), comparator);
     public int getRowCount()
          return tableModel.getRowCount();
     public int getColumnCount()
          return tableModel.getColumnCount();
     public boolean isColumnSortable(int column)
          for(int idx = 0; idx < sortableColumns.length; idx++)
               if(sortableColumns[idx] == column)
                    return true;
          return false;
     public void setSorting(int sortColumn, boolean sortAscending)
          if(!isColumnSortable(sortColumn))
               throw new IllegalArgumentException("Cannot sort by unsortable column: " + sortColumn);
          this.sortColumn = sortColumn;
          this.sortAscending = sortAscending;
          comparator = (Comparator)comparatorMap.get(new Integer(sortColumn));
          calculateSorting();
          fireTableDataChanged();
     public void clearSorting()
          sortColumn = -1;
          calculateSorting();
          fireTableDataChanged();
     public int getSortColumn()
          return sortColumn;
     public boolean isSortAscending()
          return sortAscending;
     protected void calculateSorting()
          if(sortColumn < 0)
               toModelRow = null;
               fromModelRow = null;
               return;
          ArrayList columnValues = new ArrayList(tableModel.getRowCount());
          for(int row = 0; row < tableModel.getRowCount(); row++)
               columnValues.add(new ComparableValue(tableModel.getValueAt(row, sortColumn), row));
          TreeSet sortedSet = new TreeSet(columnValues);
          toModelRow = new int[sortedSet.size()];
          fromModelRow = new int[sortedSet.size()];
          int idx = 0;
          int row;
          for(Iterator i = sortedSet.iterator(); i.hasNext(); )
               row = ((ComparableValue)i.next()).getRow();
               toModelRow[idx] = row;
               fromModelRow[row] = idx;
               idx++;
     public int convertToModelRow(int row)
          if((toModelRow == null) || (row >= toModelRow.length))
               return row;
          return toModelRow[row];
     public int convertFromModelRow(int row)
          if((fromModelRow == null) || (row >= fromModelRow.length))
               return row;
          return fromModelRow[row];
     public Object getValueAt(int row, int column)
          return tableModel.getValueAt(convertToModelRow(row), column);
     public void setValueAt(Object value, int row, int column)
          tableModel.setValueAt(value, convertToModelRow(row), column);
     public String getColumnName(int column)
          return tableModel.getColumnName(column);
     public Class getColumnClass(int column)
          return tableModel.getColumnClass(column);
     public boolean isCellEditable(int row, int column)
          return tableModel.isCellEditable(convertToModelRow(row), column);
     public void tableChanged(TableModelEvent e)
          calculateSorting();
          // Since this class is essentially a proxy for the table model we propogate the change of data to
          // all of our registered listeners
          // For now we tell them that all data has changed
          // (the mapping between changes in the underlying model and the sorted view should be implemented later)
          fireTableDataChanged();
}