JTable and Custom Columns

[Ralph Cook]

I apologize in advance for the length of this; I am hoping someone can point me in the right direction, and I include the code in case they want to look at that.

I am studying JTable and want to use a class to represent the columns that might be displayed on a given application. I have uses in mind for this that I will take up later; they do not appear here; the code is long enough as it is. As an example, I want to associate each possible column with a menu item the user can choose.

MyDisplayColumns extends Steven Kelvin's "ExtendedTableColumnModel", which has some code in it for holding references to columns that are not currently visible; I used Mr. Kelvin's code as a starting point.

When I run it now, I get a 5-column table, with left justified strings and right-justified numbers. If I click and drag the fourth column ("gradYr") to the left, it suddenly gets left-justified, and the column that moves to the right suddenly becomes right-justified. Yet, as near as I can tell, the getColumnClass method being called to get the class that determines the default rendering is returning the correct classes (Integer for the number, String for the string).

So if someone can explain to me where I should be looking to fix that, I'd appreciate it. What follows is a bunch of code; I don't know any way to cut it down if someone wants to run it.

package tableplay;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

/**
 * This program displays a table of information 
 * with options to add and remove columns of that information.
 * @author rcook
 *
 */
public class ChangeColumns extends JFrame
{
  private static final long serialVersionUID = 1L;
//  private static ChangeColumns mainFrame = null;
  
  private   MyTableModel  myTableModel    = null;
  private   JTable        myTable         = null;
  private   JScrollPane   mainScrollPane  = null;
  
  public static void main(String[] arguments) 
  { 
    ChangeColumns mainFrame = new ChangeColumns("Change Columns");
    mainFrame.setVisible(true);
  }

  public ChangeColumns(String frameTitle)
  {
    super(frameTitle);
    setSize(300,200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    java.awt.EventQueue.invokeLater
    ( new Runnable()
        { public void run() 
          { createDisplay(); 
          }
        }
    );
  }
  
  private void createDisplay()
  {
    // create the table and all its accutrements
    myTableModel = createTable();
    mainScrollPane = new JScrollPane(myTable);
    getContentPane().add(mainScrollPane, BorderLayout.CENTER);
    pack();
  }

  /**
   * create the table for displaying all this stuff
   */
  private MyTableModel createTable()
  {
    MyDisplayColumns dc = new MyDisplayColumns();
    myTableModel = new MyTableModel(dc);
    myTable = new MyJTable(myTableModel, dc); //nw2
    dc.setJTable(myTable);
    return myTableModel;
  }
}

package tableplay;

import java.util.ArrayList;

import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;

import rcutil.ConvertHexColor;

public class MyTableModel extends AbstractTableModel
{
  private static final long serialVersionUID = 1L;
  private MyDisplayColumns myDisplayColumns;
  private ArrayList<ChangeColumnsData> dataArray = new ArrayList<ChangeColumnsData>();

  public static void say(String msg) { System.out.println(msg); }

  public MyTableModel(MyDisplayColumns mdc)
  {
    myDisplayColumns = mdc;
    addRow("albert", 25, "video",  68, "tall", 42);
    addRow("arthur", 35, "acting", 69, "diff", 99);
  }
  private void addRow(String name, int b, String c, int d, String e, int f)
  {
    ChangeColumnsData ccd = new ChangeColumnsData(name,b,c,d,e,f);
    dataArray.add(ccd);
  }

  @Override
  public int getColumnCount()
  {
    int size = 0;
    // by passing false, we got total columns in model,
    //  not just number of visible columns
    size = myDisplayColumns.getColumnCount(false);
    return size;
  }

  @Override
  public int getRowCount()
  {
    int size = 0;
    size = dataArray.size();
    return size;
  }

  @Override
  public Object getValueAt(int row, int col)
  {
    Object result = null;
    if (row >= 0)
    {
      ChangeColumnsData fcRow = dataArray.get(row);
      switch(col)
      {
      case 0: result = fcRow.getName(); break;
      case 1: result = new Integer(fcRow.getNum1()); break;
      case 2: result = fcRow.getStr1(); break;
      case 3: result = new Integer(fcRow.getNum2()); break;
      case 4: result = fcRow.getStr2(); break;
      case 5: result = new Integer(fcRow.getNum3()); break;
      }
    }
    return result;
  }

  // return column name, used to init column header
  public String getColumnName(int col)
  {
    return myDisplayColumns.getColumnName(col);
  }

  // part of TableModel;
  // in AbstractTableModel, just returns Object.class
  public Class<?> getColumnClass(int col)
  {
    Class<?> cl = myDisplayColumns.getColumnClass(col);
    return cl;
  }
}

package tableplay;
import javax.swing.table.*;
import java.util.Vector;
import java.util.Enumeration;

/**
 * <code>ExtendedTableColumnModel</code> extends the DefaultTableColumnModel .
 * It provides a comfortable way to hide/show columns.
 * Columns keep their positions when hidden and shown again.
 *
 *
 * In order to work with JTable it cannot add any events to
 * <code>TableColumnModelListener</code>.  Therefore hiding a column will
 * result in <code>columnRemoved</code> event and showing it again will
 * notify listeners of a <code>columnAdded</code>, and possibly a
 * <code>columnMoved</code> event.For the same reason the following
 * methods still deal with visible columns only: getColumnCount(),
 * getColumns(), getColumnIndex(), getColumn() There are overloaded
 * versions of these methods that take a parameter <code>onlyVisible</code> 
 * which lets you specify whether you want invisible columns taken into account.
 *
 *
 * @version 0.9 04/03/01 as XTableColumnModel
 * @author Stephen Kelvin, [e-mail]
 * @see DefaultTableColumnModel
 * 
 * @version 0.9.1 21/05/11
 * @author Ralph Cook
 * Corrected some comment spellings, reformatted.
 * added addColumn(TableColumn newColumn, boolean visible), so that
 * columns can be added without making them visible immediately.
 */

public class ExtendedTableColumnModel extends DefaultTableColumnModel
{
  private static final long serialVersionUID = 1L;
  private static final void say(String msg) { System.out.println(msg); }
  
  /** Array of TableColumn objects in this model.
   *  Holds all column objects, regardless of their visibility
   */
  protected Vector allTableColumns            = new Vector();

  /**
   * Creates an extended table column model.
   */
  ExtendedTableColumnModel()
  {
  }

  /**
   * Sets the visibility of the specified TableColumn.
   * The call is ignored if the TableColumn is not found in this column model
   * or its visibility status did not change.
   * <p>
   *
   * @param aColumn        the column to show/hide
   * @param visible its new visibility status
   */
  // listeners will receive columnAdded()/columnRemoved() event
  public void setColumnVisible(TableColumn column, boolean visible)
  {
    say("setColumnVisible called");
    if (!visible)
    {
      super.removeColumn(column);
    }
    else
    {
      // find the visible index of the column:
      // iterate through both collections of visible and all columns, counting
      // visible columns up to the one that's about to be shown again
      int noVisibleColumns    = tableColumns.size();
      int noInvisibleColumns  = allTableColumns.size();
      int visibleIndex        = 0;

      for (int invisibleIndex = 0; invisibleIndex < noInvisibleColumns; ++invisibleIndex)
      {
        TableColumn visibleColumn   = (visibleIndex < noVisibleColumns ? (TableColumn)tableColumns.get(visibleIndex) : null);
        TableColumn testColumn      = (TableColumn)allTableColumns.get(invisibleIndex);

        if (testColumn == column)
        {
          if (visibleColumn != column)
          {
            super.addColumn(column);
            super.moveColumn(tableColumns.size() - 1, visibleIndex);
          }
          return; // ####################
        }
        if (testColumn == visibleColumn)
        {
          ++visibleIndex;
        }
      }
    }
  }

  /**
   * Makes all columns in this model visible
   */
  public void setAllColumnsVisible()
  {
    say("setAllColumnsVisible called");
    int noColumns       = allTableColumns.size();

    for (int columnIndex = 0; columnIndex < noColumns; ++columnIndex)
    {
      TableColumn visibleColumn = (columnIndex < tableColumns.size() ? (TableColumn)tableColumns.get(columnIndex) : null);
      TableColumn invisibleColumn = (TableColumn)allTableColumns.get(columnIndex);

      if (visibleColumn != invisibleColumn)
      {
        super.addColumn(invisibleColumn);
        super.moveColumn(tableColumns.size() - 1, columnIndex);
      }
    }
  }

  /**
   * Maps the index of the column in the table model at
   * <code>modelColumnIndex</code> to the TableColumn object.
   * There may me multiple TableColumn objects showing the same model column, though this is uncommon.
   * This method will always return the first visible or else the first invisible column with the specified index.
   * @param modelColumnIndex index of column in table model
   * @return table column object or null if no such column in this column model
*/
  public TableColumn getColumnByModelIndex(int modelColumnIndex)
  {
    say("getColumnByModelIndex called");
    for (int columnIndex = 0; columnIndex < allTableColumns.size(); ++columnIndex)
    {
      TableColumn column = (TableColumn)allTableColumns.elementAt(columnIndex);
      if (column.getModelIndex() == modelColumnIndex)
      {
        return column;
      }
    }
    return null;
  }

/** Checks wether the specified column is currently visible.
 * @param aColumn column to check
 * @return visibility of specified column (false if there is no such column at all. [It's not visible, right?])
 */    
  public boolean isColumnVisible(TableColumn aColumn)
  {
    return(tableColumns.indexOf(aColumn) >= 0);
  }

/** Append <code>column</code> to the right of exisiting columns.
 * Posts <code>columnAdded</code> event.
 * @param column The column to be added
 * @see #removeColumn
 * @exception IllegalArgumentException if <code>column</code> is <code>null</code>
 */    
  public void addColumn(TableColumn column)
  {
    say("addColumn called; added to columnView and columnModel");
    allTableColumns.addElement(column);
    super.addColumn(column);
  }

/** Append <code>column</code> to the right of existing columns; if
 * <code>visible</code> is false, add it to possible columns but keep it 
 * @param column column to be added
 * @visible indicates whether column is to be visible immediately
 * @see #setColumnVisible
 */
 public void addColumn(TableColumn column, boolean visible)
 {
   say("addColumn called, visible = " + (visible?"t":"f"));
   if (visible) 
        { addColumn(column); }
   else { allTableColumns.addElement(column); }
 }

/** Removes <code>column</code> from this column model.
 * Posts <code>columnRemoved</code> event.
 * Will do nothing if the column is not in this model.
 * @param column the column to be added
 * @see #addColumn
 */    
  public void removeColumn(TableColumn column)
  {
    int allColumnsIndex = allTableColumns.indexOf(column);
    if (allColumnsIndex != -1)
    {
      allTableColumns.removeElementAt(allColumnsIndex);
    }
    super.removeColumn(column);
  }

  /** Moves the column from <code>oldIndex</code> to <code>newIndex</code>.
   * Posts  <code>columnMoved</code> event.
   * Will not move any columns if <code>oldIndex</code> equals <code>newIndex</code>.
   *
   * @param oldIndex      index of column to be moved
   * @param newIndex      new index of the column
   * @exception IllegalArgumentException  if either <code>oldIndex</code> or
   *            <code>newIndex</code>
   *            are not in [0, getColumnCount() - 1]
   */
  public void moveColumn(int oldIndex, int newIndex)
  {
    if (oldIndex != newIndex)
    { say(String.format("move column from %d to %d", oldIndex, newIndex));
    }
    
    if ((oldIndex < 0) || (oldIndex >= getColumnCount()) ||
        (newIndex < 0) || (newIndex >= getColumnCount()))
      throw new IllegalArgumentException("moveColumn() - Index out of range");

    TableColumn fromColumn  = (TableColumn) tableColumns.get(oldIndex);
    TableColumn toColumn    = (TableColumn) tableColumns.get(newIndex);

    int allColumnsOldIndex  = allTableColumns.indexOf(fromColumn);
    int allColumnsNewIndex  = allTableColumns.indexOf(toColumn);

    if (oldIndex != newIndex)
    {
      allTableColumns.removeElementAt(allColumnsOldIndex);
      allTableColumns.insertElementAt(fromColumn, allColumnsNewIndex);
    }

    super.moveColumn(oldIndex, newIndex);
  }

  /**
   * Returns number of either shown or total columns.
   *
   * @param   onlyVisible   if set only visible columns will be counted
   * @return  the number of columns in the <code>tableColumns</code> array
   * @see #getColumns
   */
  public int getColumnCount(boolean onlyVisible)
  {
    Vector columns = (onlyVisible ? tableColumns : allTableColumns);
    return columns.size();
  }

  /**
   * Returns an <code>Enumeration</code> of all the columns in the model.
   *
   * @param   onlyVisible   if set all invisible columns will be missing from the enumeration.
   * @return an <code>Enumeration</code> of the columns in the model
   */
  public Enumeration getColumns(boolean onlyVisible)
  {
    Vector columns = (onlyVisible ? tableColumns : allTableColumns);

    return columns.elements();
  }

  /**
   * Returns the position of the first column whose identifier equals <code>identifier</code>.
   * Position is the the index in all visible columns if <code>onlyVisible</code> is true or
   * else the index in all columns.
   *
   * @param identifier   the identifier object to search for
   * @param onlyVisible  if set searches only visible columns
   *
   * @return    the index of the first column whose identifier
   *      equals <code>identifier</code>
   *
   * @exception       IllegalArgumentException  if <code>identifier</code>
   *        is <code>null</code>, or if no
   *        <code>TableColumn</code> has this
   *        <code>identifier</code>
   * @see   #getColumn
   */
  public int getColumnIndex(Object identifier, boolean onlyVisible)
  {
    say("calling getColumnIndex");
    if (identifier == null)
    {
      throw new IllegalArgumentException("Identifier is null");
    }

    Vector      columns     = (onlyVisible ? tableColumns : allTableColumns);
    int         noColumns   = columns.size();
    TableColumn column;

    for (int columnIndex = 0; columnIndex < noColumns; ++columnIndex)
    {
      column = (TableColumn)columns.get(columnIndex);

      if (identifier.equals(column.getIdentifier()))
        return columnIndex;
    }

    throw new IllegalArgumentException("Identifier not found");
  }

  /**
   * Returns the <code>TableColumn</code> object for the column
   * at <code>columnIndex</code>.
   *
   * @param columnIndex the index of the column desired
   * @param onlyVisible if set columnIndex is meant to be relative to all visible columns only
   *                          else it is the index in all columns
   *
   * @return  the <code>TableColumn</code> object for the column
   *        at <code>columnIndex</code>
   */
  public TableColumn getColumn(int columnIndex, boolean onlyVisible)
  {
    return(TableColumn)tableColumns.elementAt(columnIndex);
  }
}

package tableplay;

import javax.swing.JTable;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;

/**
 * Class representing the columns that may be displayed for this app.
 * @author rcook
 */
public class MyDisplayColumns extends ExtendedTableColumnModel
{
  private static final long serialVersionUID = 1L;

  private static int currentModelIndex = 0;
  public static void say(String msg) { System.out.println(msg); }
  
  private JTable table = null;
  
  public MyDisplayColumns()
  {
    createColumns();
  }

  // used in ChangeColumns.createTable()
  public void setJTable(JTable givenTable)
  {
    table = givenTable;
  }
  
  // just mine
  private void createColumns()
  {
    addColumn("Name",    125, null, String.class,  true);
    addColumn("%",        25, null, Integer.class, true);
    addColumn("primary",  40, null, String.class,  true);
    addColumn("gradYr",   25, null, Integer.class, true);
    addColumn("desc",     50, null, String.class,  true);
    addColumn("lastNum",  50, null, Integer.class, true);
  }
  
  // just mine
  private void addColumn(String           header,
                        int               width,
                        TableCellRenderer renderer,
                        Class<?>          clazz,
                        boolean           initiallyVisible)
  {
    ExtendedTableColumn currentColumn 
          = new ExtendedTableColumn(header, width, renderer, clazz);
    currentColumn.setHeaderValue(header);
    addColumn(currentColumn, initiallyVisible);
  }

  public void moveColumn(int oldIndex, int newIndex)
  {
    super.moveColumn(oldIndex, newIndex);
  }
  
  public void removeColumn(ExtendedTableColumn column)
  {
    int tableColumnsIndex = tableColumns.indexOf(column);
    if (tableColumnsIndex != -1)
    {
      tableColumns.remove(tableColumnsIndex);
    }
    super.removeColumn(column);
  }

  public int getModelColumnsCount()
  {
    return tableColumns.size();
  }
  
  public String getModelColumnName(int modelIndex)
  {
    return tableColumns.get(modelIndex).getHeaderValue().toString();
  }
  
  public String getColumnName(int givenIndex)
  {
    say("getColumnName for index " + givenIndex);
    ExtendedTableColumn thisColumn = (ExtendedTableColumn)tableColumns.get(givenIndex);
    return thisColumn.getHeader();
  }
  
  // used by MyTableModel, which is implementing a method for
  // which the AbstractTableModel just returns Object.class
  public Class<?> getColumnClass(int givenIndex)
  {
//    int otherIndex  = table.convertColumnIndexToModel(givenIndex);
//    if (givenIndex != otherIndex) 
//      { say(String.format("converted %d to %d, using %d", givenIndex, otherIndex, otherIndex)); 
//      }

    ExtendedTableColumn etc = (ExtendedTableColumn)tableColumns.get(givenIndex);
    Class<?> clazz = etc.getClazz();
    say(String.format("getColumnClass %d:%-8s %s", givenIndex, etc.getHeaderValue(), clazz.getName()));
    return clazz;
  }
  
  public class ExtendedTableColumn extends TableColumn
  {
    private static final long serialVersionUID = 1L;
    
    private String   header; public String   getHeader() { return header; }
    private Class<?> clazz;  public Class<?> getClazz()  { return clazz; }
    
    public ExtendedTableColumn(String givenName, 
                                int givenWidth,  
                                TableCellRenderer givenRenderer, 
                                Class<?> givenClazz)
    {
      super(currentModelIndex++, givenWidth, givenRenderer, null);
      header = givenName;
      clazz = givenClazz;
    }
  }
}

[Rob Camick]

Yes, the getColumnClass() method is use to determine the renderer/editor to be used for a given column.

You are overriding the getColumnClass() method of the TableModel. The order of the columns in the TableModel never changes. The TableModel is just used to store data and should not know anything about the TableColumnModel. Therefore you should not be referencing the custom TableColumnModel. Just return the proper Class based on the data in the TableModel. The fact that columns may be reordered is irrelevant to the TableModel.

For what its worth the Table Column Manager, allows you to hide/show columns and gives the users the ability to do this as well.

[Ralph Cook]

In case someone wanted an answer closer to my question:

The class I started with, ExtendedTableColumnModel, extends TableColumnModel with the express purpose of storing non-visible columns and managing visibility based on method calls. Unfortunately, that class re-implemented moveColumn(int, int), which meant that moving a column in the view also changed its order in the list of all columns. As Rob pointed out, the order of the columns in "the model" is not supposed to change; I haven't figured out yet why the ETCM author did that. When I commented out the moveColumn (and removeColumn, for good measure) methods, it started working fine (i.e., the Integer and String data items were always justified correctly as I moved them around on the UI.

Thanks also for the pointer to another way to do this; I see it was posted *after* I was asking about this same subject some weeks ago. I didn't really like extending the TableColumnModel, but I'm still trying to get a conceptual understanding of column-handling in JTable, and that's turning out to be a lot more difficult than it should be...

rc

[Rob Camick]

Unfortunately, that class re-implemented moveColumn(int, int), which meant that moving a column in the view also changed its order in the list of all columns.

That is correct, that is what should happen.

As Rob pointed out, the order of the columns in "the model" is not supposed to change;

That is not what I said. I said the order of the columns in the TABLE model is not supposed to change.

I suggested the problem was with you getColumnClass() method because it references your TableColumnModel. The TableModel should not access or care about the TableColumnModel.

but I'm still trying to get a conceptual understanding of column-handling in JTable, and that's turning out to be a lot more difficult than it should be...

The TableColumnModel is just a sequential List of how TableColumns are to be displayed for the table. When the TableColumnModel is created, the TableColumn's are displayed in the order in which the data in the TableModel is defined. Each TableColumn contains a column index back to the TableModel. So even if TableColum 5 is moved to the start of the TableColumnModel (and therefore the start of the table), the data for that coumn is still obtained by accessing the data from column 5 in the TableModel.

All table methods are relative to the table. Lets use the above example of column 5 being moved to the start of the table. If you invoke:

table.getValueAt(row, 0);

then the table must first convert the "0" to "5" so it can acess the data in column 5 of the TableModel. To do this is uses the

convertColumnIndexToModel(...) method.

The convertColumnIndexToModel() method uses the TableColumnModel (TCM) and TableColumn at position 0 of the TCM, to get the appropriate model index.

So any table method must first convert the "view" index to a "model" index.

The TableModel know nothing about the view so it always just uses the model index.

[Ralph Cook]

Rob Camick wrote:

Unfortunately, that class re-implemented moveColumn(int, int), which meant that moving a column in the view also changed its order in the list of all columns.

That is correct, that is what should happen.

No, that was a bug. I said it was a bug; when I took that out, the program started working correctly. Evidently you are missing that the list that it was changing was the one you said should not change -- all the columns in the application, without regard to visibility. I can tell you think this list belongs in TableModel, but it isn't contained there in this example.

Rob Camick wrote:

As Rob pointed out, the order of the columns in "the model" is not supposed to change;

That is not what I said. I said the order of the columns in the TABLE model is not supposed to change.

Quite right, sorry.

Rob Camick wrote:
I suggested the problem was with you getColumnClass() method because it references your TableColumnModel. The TableModel should not access or care about the TableColumnModel.

But this TableColumnModel is extended by the class that handles all the columns. The TableModel cannot reference them separately. You wouldn't have needed to read the code to know this, I said it in the text.

[Rob Camick]

MyDisplayColumns extends Steven Kelvin's "ExtendedTableColumnModel", which has some code in it for holding references to columns that are not currently visible; I used Mr. Kelvin's code as a starting point.

I have no idea what you started with and what you added. All I can tell you is that the final solution, although it may work, is WRONG from a design point of view.

You should NOT be creating a TableModel using a TableColumnModel. I don't know how to say this any differently: the TableModel should know nothing about the TableColumnModel. The whole point about MCV design is to separate the "model" from the "view".

No, that was a bug. I said it was a bug; when I took that out, the program started working correctly.

Maybe commenting out the moveColumn() method fixes your problem, but it doesn't fix your design. It is still wrong and I've explained why its wrong mulitple times.

[Ralph Cook]

What you have said about the design is off-topic. I asked a question, and was able to figure out an answer for myself from something you said, for which I thank you (again).

It's normally called MVC, by the way. And I have no evidence that you know more about it than I do, no matter how many words you put in caps and boldface.

rc

[Rob Camick]

It's normally called MVC,

That would be a typo on my par, but I'm impressed you do know how to spell it. Now all you have to do is learn what it means.

And I have no evidence that you know more about it than I do, no matter how many words you put in caps and boldface.

The evidence is in your code. You have absolutely no idea what you are doing. It does not follow MVC.

What you have said about the design is off-topic.

No it isn't because your stated goal is:

but I'm still trying to get a conceptual understanding of column-handling in JTable,

If you actually understood MVC then you would have a better chance at understanding why JTable works the way it does with the TCM and TC and TM.

A brute force solution is not a good solution. Even you have admitted you don't know why it works only that it does. If you look at my solution you will notice that I also have code related to moving columns. That is because this is the way the TCM was designed to be used.

I was asking about this same subject some weeks ago.

I saw that posting and did not offer my solution then because of your attitude towards Rob who was the only person who attempted to help you then. I see my original instinct was correct as you haven't learned anything.