JTable manipulation

Hello People!
I have a window with 2 text boxes and a JTable. I am using a persistence model wich return my queries into a Vector, so I would like to populate my JTable with that. When I looked at the API I didn't find a way to do that that is not in the Constructor.
How do you manipulate a JTable to insert a new row, delete row?

The data of the table is held in the data model of the table, which is basically is a vector. Adding/removing to the model's data vector is done via the vector's methods, usually by names ogf addElement/removeElement. The table is displayed according to that model, so once you got your model in order, the display should follow it. Bye, Timo.

Similar Messages

Manipulating tab focus in JTable ??

Hi ,
I am using a JTable with 3 columns out of which 3rd column is non-editable and gets populated based on the values of first 2 columns.
Default tab behaviour traverses through all the columns including the non-editable column. I want to restrict the tabbing to non editable column and want to move tabbing across the editable columns only.
Not able to figure out the exact API's. CAn anybody please help me out ??
thanks in advance

Code for the class which does that magic. It also works for LEFT, RIGHT, UP, and DOWN arrow keys.
import java.awt.Component;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.AbstractButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.JTable;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.EventListenerList;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.event.TableModelEvent;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.text.JTextComponent;
public class MyTable extends JTable{
protected boolean processKeyBinding(KeyStroke stroke, KeyEvent evt,
 int condition,boolean pressed) {
 Component cellEditorComp = this.getEditorComponent();
 // If the editor is a combo box, and the key is down arrow, pass the event to Drop down
 if ((cellEditorComp != null) &&
 (cellEditorComp instanceof JComboBox) &&
 (evt.getKeyCode() == KeyEvent.VK_DOWN))
 return super.processKeyBinding(stroke, evt, condition, pressed);
 // if the current cell is in edit mode, pass the event to editor component
 // for right and left arrow keys
 // For combo box do not pass the event, instead handle left and right arrow key press.
 if ((getCellEditor() != null) &&
 !(cellEditorComp instanceof JComboBox) &&
 ((evt.getKeyCode() == KeyEvent.VK_LEFT) ||
 (evt.getKeyCode() == KeyEvent.VK_RIGHT)))
 return super.processKeyBinding(stroke, evt, condition, pressed);
 // To avoid handling of the keys more than once,
 // the following condition is checked.
 if (pressed)
 return true;
 if ((evt.getKeyCode() == KeyEvent.VK_TAB) &&
 (!evt.isAltDown())) {
 if (evt.isShiftDown())
 processShiftTabKey();
 else
 processTabKey();
 else if (evt.getKeyCode() == KeyEvent.VK_LEFT){
 processShiftTabKey();
 else if (evt.getKeyCode() == KeyEvent.VK_RIGHT){
 processTabKey();
 else if (evt.getKeyCode() == KeyEvent.VK_UP){
 processUpArrow();
 else if (evt.getKeyCode() == KeyEvent.VK_DOWN){
 processDownArrow();
 else
 return super.processKeyBinding(stroke, evt, condition, pressed);
 return true;
* Method to select a table cell
public void setSelectedCell(int pRow, int pCol) {
 try {
 this.grabFocus();
 this.addColumnSelectionInterval(pCol, pCol);
 this.addRowSelectionInterval(pRow,pRow);
 this.editCellAt(pRow,pCol);
 if (this.getEditorComponent() != null)
 this.getEditorComponent().requestFocus();
 // make the cell visible, it may not be visible sometimes.
 scrollRectToVisible(getCellRect(pRow, pCol, true));
 } catch (Exception e) {
 System.out.println("ERROR: attempting to select cell at row " + pRow + " & column " + pCol);
* PROCESS SHIFT + TAB KEY
public void processShiftTabKey(){
 int nRow = this.getEditingRow();
 int nCol = this.getEditingColumn();
 // if the cell is in edit mode, stop it.
 if (this.getCellEditor() != null)
 this.getCellEditor().stopCellEditing();
 int newCol = findPreviousEditableColumn(nRow, nCol);
 while (nCol == newCol){
 nRow--; // check the next row
 nCol = this.getColumnCount(); // to start with last col
 if (nRow < 0){
 this.transferFocus();
 return;
 newCol = findPreviousEditableColumn(nRow, nCol);
 setSelectedCell(nRow, newCol);
public int findPreviousEditableColumn(int nRow, int nCol){
 if ((nRow >= 0) &&
 (nRow < this.getRowCount())&&
 (nCol >= 0)){
 for(int i=nCol-1; i!=-1; i--){
 if (this.isCellEditable(nRow, i)){
 return i;
 return nCol;
* PROCESS TAB KEY
public void processTabKey(){
 int nRow = this.getEditingRow();
 if (nRow == -1)
 return;
 int nCol = this.getEditingColumn();
 // if the cell is in edit mode, stop it.
 if (this.getCellEditor() != null)
 this.getCellEditor().stopCellEditing();
 int newCol = findNextEditableColumn(nRow, nCol);
 while (nCol == newCol){
 nRow++; // check the next row
 nCol = -1; // to start with 1st col
 if (nRow >= this.getRowCount()){
 this.transferFocus();
 return;
 newCol = findNextEditableColumn(nRow, nCol);
 setSelectedCell(nRow, newCol);
* PROCESS UP ARROW KEY
public void processUpArrow(){
 int nRow = this.getEditingRow();
 if (nRow <= 0)
 return;
 int nCol = this.getEditingColumn();
 // if the cell is in edit mode, stop it.
 if (this.getCellEditor() != null)
 this.getCellEditor().stopCellEditing();
 setSelectedCell(nRow-1, nCol);
* PROCESS DOWN ARROW KEY
public void processDownArrow(){
 int nRow = this.getEditingRow();
 if ((nRow == -1) ||
 ((nRow+1) == this.getRowCount()))
 return;
 int nCol = this.getEditingColumn();
 // if the cell is in edit mode, stop it.
 if (this.getCellEditor() != null)
 this.getCellEditor().stopCellEditing();
 setSelectedCell(nRow+1, nCol);
public int findNextEditableColumn(int nRow, int nCol){
 if ((nRow >= 0) &&
 (nRow < this.getRowCount())){
 for(int i=nCol+1; i<this.getColumnCount(); i++){
 if (this.isCellEditable(nRow, i)){
 return i;
 return nCol;
}

JDBC manipulating data with JTable

I have this code where i want to update the status of a student wher ethe cells are checked. Im just not sure what is the best way to do it. How do I go by grabbing the data from the table and updating the database? Here is the code. Certain parts are commented out for testing purposes.public void make_tableCY(){
 /*try {
 // Create a resultset to search for course number entered in the course_num textfield
 PreparedStatement psSearchCourse= conn.prepareStatement("Select certification_date, expiration_date from registration where course_num= ?");
 //psSearchCourse.setString(1, (String) CY.jcbCoursenum.getSelectedItem());
 CY.rsSearchCourse = psSearchCourse.executeQuery();
 CY.rsSearchCourse.next();
 //CY.jtfCertDate.setText(CY.rsSearchCourse.getString(1));
 CY.rsSearchCourse.close();
 psSearchCourse.close();
 catch(SQLException sqlex)
 JOptionPane.showMessageDialog(null,"Please enter a valid course number");
 try
 // Read data from a table
 //PreparedStatement ps =conn.prepareStatement("SELECT Registration.STUDENT_ID , Students.LNAME , Students.FNAME, Registration.Course_Stat_desc FROM Registration, Students WHERE Registration.Student_ID = Students.Student_id AND registration.course_num=?");
 PreparedStatement ps =conn.prepareStatement("SELECT * from students");
 //ps.setString(1, (String) CY.jcbCoursenum.getSelectedItem());
 ResultSet rs = ps.executeQuery();
 ResultSetMetaData md = rs.getMetaData();
 int columns = md.getColumnCount();
 // Get column names
 for (int i = 1; i <= columns; i++)
 CY.columnNames.addElement( md.getColumnName(i) );
 CY.columnNames.addElement("Pass");
 while (rs.next())
 Vector row = new Vector(columns);
 for (int i = 1; i <= columns; i++)
 row.addElement( rs.getObject(i) );
 row.addElement(Boolean.TRUE);
 CY.data.addElement( row);
 rs.close();
 ps.close();
 catch(SQLException sqlex)
 JOptionPane.showMessageDialog(null,"in the certify table");
 CY.table = new JTable( CY.data, CY.columnNames){
 public Class getColumnClass(int column)
 return getValueAt(0, column).getClass();
 CY.table.setSelectionBackground(Color.CYAN);
 /*TableColumn includeColumn = CY.table.getColumnModel().getColumn(0);
 includeColumn.setCellEditor(new DefaultCellEditor(new JCheckBox()));*/
 //adds table to scrollpane
 CY.scrollPane = new JScrollPane( CY.table );
 CY.scrollPane.setBackground(Color.CYAN);
 CY.background.add(CY.scrollPane );
 CY.scrollPane.setBounds (20, 160, 585, 155);
 //CY.jbtSearchCourse.setEnabled(false);
 CY.jbtCertify.setEnabled(true);
 }

Looking for something like this
create or replace type objIncome as object(incomeType varchar2(50), income number(10,2))
create or replace type tblIncome as table of objIncome
declare
lIncomeTbl tblIncome := tblIncome();
begin
lIncomeTbl.extend;
lIncomeTbl(1) := objIncome('cash','500');
lIncomeTbl.extend;
lIncomeTbl(2) := objIncome('Service','100');
lIncomeTbl.extend;
lIncomeTbl(3) := objIncome('cash','100');
lIncomeTbl.extend;
lIncomeTbl(4) := objIncome('penalty','50');
lIncomeTbl.extend;
lIncomeTbl(5) := objIncome('Service','200');
lIncomeTbl.extend;
lIncomeTbl(6) := objIncome('penalty','80');
for i in (select incometype, sum(income) income
 from table(lIncomeTbl)
 group by incometype)
loop
 dbms_output.put_line('Income Type: ' || i.incometype ||' Income: ' || i.income);
end loop;
end;
/

One model for JTree and JTable

Hi.
Is it possible for a JTree and a JTable to share one model?
Thank you

Hope u r not using Comonent TreeTable
If u have Tree & Table different components, just want to have a common model then u can try this,
It is nothing but default implementation given in DefaultTableModel
public class MyTreeTableModel extends DefaultTreeModel implements TableModel, Serializable {
protected Vector dataVector;
/** List of listeners */
protected EventListenerList listenerList = new EventListenerList();
/** The <code>Vector</code> of column identifiers. */
protected Vector columnIdentifiers;
public MyTreeTableModel(TreeNode root) {
this(root, false);
// constructor for TreeModel only
public MyTreeTableModel(TreeNode root, boolean asksAllowsChildren) {
super(root, asksAllowsChildren);
// constructor for TableModel only
public MyTreeTableModel() {
this(0, 0);
private static Vector newVector(int size) {
Vector v = new Vector(size);
v.setSize(size);
return v;
// constructor for TableModel only
public MyTreeTableModel(int rowCount, int columnCount) {
this(newVector(columnCount), rowCount);
// constructor for TableModel only
public MyTreeTableModel(Vector columnNames, int rowCount) {
super(null);
setDataVector(newVector(rowCount), columnNames);
// constructor for TableModel only
public MyTreeTableModel(Object[] columnNames, int rowCount) {
this(convertToVector(columnNames), rowCount);
// constructor for TableModel only
public MyTreeTableModel(Vector data, Vector columnNames) {
super(null);
setDataVector(data, columnNames);
// constructor for TableModel only
public MyTreeTableModel(Object[][] data, Object[] columnNames) {
super(null);
setDataVector(data, columnNames);
* Returns a default name for the column using spreadsheet conventions:
* A, B, C, ... Z, AA, AB, etc. If <code>column</code> cannot be found,
* returns an empty string.
* @param column the column being queried
* @return a string containing the default name of <code>column</code>
private String getDefaultColumnName(int column) {
String result = "";
for (; column >= 0; column = column / 26 - 1) {
result = (char)((char)(column%26)+'A') + result;
return result;
* Returns a column given its name.
* Implementation is naive so this should be overridden if
* this method is to be called often. This method is not
* in the <code>TableModel</code> interface and is not used by the
* <code>JTable</code>.
* @param columnName string containing name of column to be located
* @return the column with <code>columnName</code>, or -1 if not found
public int findColumn(String columnName) {
for (int i = 0; i < getColumnCount(); i++) {
if (columnName.equals(getColumnName(i))) {
return i;
return -1;
* Returns <code>Object.class</code> regardless of <code>columnIndex</code>.
* @param columnIndex the column being queried
* @return the Object.class
public Class getColumnClass(int columnIndex) {
return Object.class;
// Managing Listeners
* Adds a listener to the list that's notified each time a change
* to the data model occurs.
* @param l the TableModelListener
public void addTableModelListener(TableModelListener l) {
listenerList.add(TableModelListener.class, l);
* Removes a listener from the list that's notified each time a
* change to the data model occurs.
* @param l the TableModelListener
public void removeTableModelListener(TableModelListener l) {
listenerList.remove(TableModelListener.class, l);
* Returns an array of all the table model listeners
* registered on this model.
* @return all of this model's <code>TableModelListener</code>s
* or an empty
* array if no table model listeners are currently registered
public TableModelListener[] getTableModelListeners() {
return (TableModelListener[])listenerList.getListeners(
TableModelListener.class);
// Fire methods
* Notifies all listeners that all cell values in the table's
* rows may have changed. The number of rows may also have changed
* and the <code>JTable</code> should redraw the
* table from scratch. The structure of the table (as in the order of the
* columns) is assumed to be the same.
public void fireTableDataChanged() {
fireTableChanged(new TableModelEvent(this));
* Notifies all listeners that the table's structure has changed.
* The number of columns in the table, and the names and types of
* the new columns may be different from the previous state.
* If the <code>JTable</code> receives this event and its
* <code>autoCreateColumnsFromModel</code>
* flag is set it discards any table columns that it had and reallocates
* default columns in the order they appear in the model. This is the
* same as calling <code>setModel(TableModel)</code> on the
* <code>JTable</code>.
public void fireTableStructureChanged() {
fireTableChanged(new TableModelEvent(this, TableModelEvent.HEADER_ROW));
* Notifies all listeners that rows in the range
* <code>[firstRow, lastRow]</code>, inclusive, have been inserted.
* @param firstRow the first row
* @param lastRow the last row
public void fireTableRowsInserted(int firstRow, int lastRow) {
fireTableChanged(new TableModelEvent(this, firstRow, lastRow,
TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT));
* Notifies all listeners that rows in the range
* <code>[firstRow, lastRow]</code>, inclusive, have been updated.
* @param firstRow the first row
* @param lastRow the last row
public void fireTableRowsUpdated(int firstRow, int lastRow) {
fireTableChanged(new TableModelEvent(this, firstRow, lastRow,
TableModelEvent.ALL_COLUMNS, TableModelEvent.UPDATE));
* Notifies all listeners that rows in the range
* <code>[firstRow, lastRow]</code>, inclusive, have been deleted.
* @param firstRow the first row
* @param lastRow the last row
public void fireTableRowsDeleted(int firstRow, int lastRow) {
fireTableChanged(new TableModelEvent(this, firstRow, lastRow,
TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE));
* Notifies all listeners that the value of the cell at
* <code>[row, column]</code> has been updated.
* @param row row of cell which has been updated
* @param column column of cell which has been updated
public void fireTableCellUpdated(int row, int column) {
fireTableChanged(new TableModelEvent(this, row, row, column));
* Forwards the given notification event to all
* <code>TableModelListeners</code> that registered
* themselves as listeners for this table model.
* @param e the event to be forwarded
public void fireTableChanged(TableModelEvent e) {
// Guaranteed to return a non-null array
Object[] listeners = listenerList.getListenerList();
// Process the listeners last to first, notifying
// those that are interested in this event
for (int i = listeners.length-2; i>=0; i-=2) {
if (listeners==TableModelListener.class) {
((TableModelListener)listeners[i+1]).tableChanged(e);
* Returns an array of all the objects currently registered
* as <code>FooListener</code>s
* upon this <code>AbstractTableModel</code>.
* <code>FooListener</code>s are registered using the
* <code>addFooListener</code> method.
* 
* You can specify the <code>listenerType</code> argument
* with a class literal,
* such as
* <code>FooListener.class</code>.
* For example, you can query a
* model <code>m</code>
* for its table model listeners with the following code:
* <pre>TableModelListener[] tmls = (TableModelListener[])(m.getListeners(TableModelListener.class));</pre>
* If no such listeners exist, this method returns an empty array.
* @param listenerType the type of listeners requested; this parameter
* should specify an interface that descends from
* <code>java.util.EventListener</code>
* @return an array of all objects registered as
* <code>FooListener</code>s on this component,
* or an empty array if no such
* listeners have been added
* @exception ClassCastException if <code>listenerType</code>
* doesn't specify a class or interface that implements
* <code>java.util.EventListener</code>
public EventListener[] getListeners(Class listenerType) {
return listenerList.getListeners(listenerType);
* Returns the <code>Vector</code> of <code>Vectors</code>
* that contains the table's
* data values. The vectors contained in the outer vector are
* each a single row of values. In other words, to get to the cell
* at row 1, column 5: 
* <code>((Vector)getDataVector().elementAt(1)).elementAt(5);</code>
* @return the vector of vectors containing the tables data values
public Vector getDataVector() {
return dataVector;
private static Vector nonNullVector(Vector v) {
return (v != null) ? v : new Vector();
* Replaces the current <code>dataVector</code> instance variable
* with the new Vector of rows, <code>dataVector</code>.
* <code>columnIdentifiers</code> are the names of the new
* columns. The first name in <code>columnIdentifiers</code> is
* mapped to column 0 in <code>dataVector</code>. Each row in
* <code>dataVector</code> is adjusted to match the number of
* columns in <code>columnIdentifiers</code>
* either by truncating the <code>Vector</code> if it is too long,
* or adding <code>null</code> values if it is too short.
* Note that passing in a <code>null</code> value for
* <code>dataVector</code> results in unspecified behavior,
* an possibly an exception.
* @param dataVector the new data vector
* @param columnIdentifiers the names of the columns
public void setDataVector(Vector dataVector, Vector columnIdentifiers) {
this.dataVector = nonNullVector(dataVector);
this.columnIdentifiers = nonNullVector(columnIdentifiers);
justifyRows(0, getRowCount());
fireTableStructureChanged();
* Replaces the value in the <code>dataVector</code> instance
* variable with the values in the array <code>dataVector</code>.
* The first index in the <code>Object[][]</code>
* array is the row index and the second is the column index.
* <code>columnIdentifiers</code> are the names of the new columns.
* @param dataVector the new data vector
* @param columnIdentifiers the names of the columns
public void setDataVector(Object[][] dataVector, Object[] columnIdentifiers) {
setDataVector(convertToVector(dataVector), convertToVector(columnIdentifiers));
* Equivalent to <code>fireTableChanged</code>.
* @param event the change event
public void newDataAvailable(TableModelEvent event) {
fireTableChanged(event);
// Manipulating rows
private void justifyRows(int from, int to) {
// Sometimes the MyTreeTableModel is subclassed
// instead of the AbstractTableModel by mistake.
// Set the number of rows for the case when getRowCount
// is overridden.
dataVector.setSize(getRowCount());
for (int i = from; i < to; i++) {
if (dataVector.elementAt(i) == null) {
dataVector.setElementAt(new Vector(), i);
((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
* Ensures that the new rows have the correct number of columns.
* This is accomplished by using the <code>setSize</code> method in
* <code>Vector</code> which truncates vectors
* which are too long, and appends <code>null</code>s if they
* are too short.
* This method also sends out a <code>tableChanged</code>
* notification message to all the listeners.
* @param e this <code>TableModelEvent</code> describes
* where the rows were added.
* If <code>null</code> it assumes
* all the rows were newly added
public void newRowsAdded(TableModelEvent e) {
justifyRows(e.getFirstRow(), e.getLastRow() + 1);
fireTableChanged(e);
* Equivalent to <code>fireTableChanged</code>.
* @param event the change event
public void rowsRemoved(TableModelEvent event) {
fireTableChanged(event);
* Obsolete as of Java 2 platform v1.3. Please use <code>setRowCount</code> instead.
* Sets the number of rows in the model. If the new size is greater
* than the current size, new rows are added to the end of the model
* If the new size is less than the current size, all
* rows at index <code>rowCount</code> and greater are discarded. 
* @param rowCount the new number of rows
public void setNumRows(int rowCount) {
int old = getRowCount();
if (old == rowCount) {
return;
dataVector.setSize(rowCount);
if (rowCount <= old) {
fireTableRowsDeleted(rowCount, old-1);
else {
justifyRows(old, rowCount);
fireTableRowsInserted(old, rowCount-1);
* Sets the number of rows in the model. If the new size is greater
* than the current size, new rows are added to the end of the model
* If the new size is less than the current size, all
* rows at index <code>rowCount</code> and greater are discarded. 
public void setRowCount(int rowCount) {
setNumRows(rowCount);
* Adds a row to the end of the model. The new row will contain
* <code>null</code> values unless <code>rowData</code> is specified.
* Notification of the row being added will be generated.
* @param rowData optional data of the row being added
public void addRow(Vector rowData) {
insertRow(getRowCount(), rowData);
* Adds a row to the end of the model. The new row will contain
* <code>null</code> values unless <code>rowData</code> is specified.
* Notification of the row being added will be generated.
* @param rowData optional data of the row being added
public void addRow(Object[] rowData) {
addRow(convertToVector(rowData));
* Inserts a row at <code>row</code> in the model. The new row
* will contain <code>null</code> values unless <code>rowData</code>
* is specified. Notification of the row being added will be generated.
* @param row the row index of the row to be inserted
* @param rowData optional data of the row being added
* @exception ArrayIndexOutOfBoundsException if the row was invalid
public void insertRow(int row, Vector rowData) {
dataVector.insertElementAt(rowData, row);
justifyRows(row, row+1);
fireTableRowsInserted(row, row);
* Inserts a row at <code>row</code> in the model. The new row
* will contain <code>null</code> values unless <code>rowData</code>
* is specified. Notification of the row being added will be generated.
* @param row the row index of the row to be inserted
* @param rowData optional data of the row being added
* @exception ArrayIndexOutOfBoundsException if the row was invalid
public void insertRow(int row, Object[] rowData) {
insertRow(row, convertToVector(rowData));
private static int gcd(int i, int j) {
return (j == 0) ? i : gcd(j, i%j);
private static void rotate(Vector v, int a, int b, int shift) {
int size = b - a;
int r = size - shift;
int g = gcd(size, r);
for(int i = 0; i < g; i++) {
int to = i;
Object tmp = v.elementAt(a + to);
for(int from = (to + r) % size; from != i; from = (to + r) % size) {
v.setElementAt(v.elementAt(a + from), a + to);
to = from;
v.setElementAt(tmp, a + to);
* Moves one or more rows from the inlcusive range <code>start</code> to
* <code>end</code> to the <code>to</code> position in the model.
* After the move, the row that was at index <code>start</code>
* will be at index <code>to</code>.
* This method will send a <code>tableChanged</code> notification
* message to all the listeners. 
* <pre>
* Examples of moves:
* 
* 1. moveRow(1,3,5);
* a|B|C|D|e|f|g|h|i|j|k - before
* a|e|f|g|h|B|C|D|i|j|k - after
* 
* 2. moveRow(6,7,1);
* a|b|c|d|e|f|G|H|i|j|k - before
* a|G|H|b|c|d|e|f|i|j|k - after
* 
* </pre>
* @param start the starting row index to be moved
* @param end the ending row index to be moved
* @param to the destination of the rows to be moved
* @exception ArrayIndexOutOfBoundsException if any of the elements
* would be moved out of the table's range
public void moveRow(int start, int end, int to) {
int shift = to - start;
int first, last;
if (shift < 0) {
first = to;
last = end;
else {
first = start;
last = to + end - start;
rotate(dataVector, first, last + 1, shift);
fireTableRowsUpdated(first, last);
* Removes the row at <code>row</code> from the model. Notification
* of the row being removed will be sent to all the listeners.
* @param row the row index of the row to be removed
* @exception ArrayIndexOutOfBoundsException if the row was invalid
public void removeRow(int row) {
dataVector.removeElementAt(row);
fireTableRowsDeleted(row, row);
// Manipulating columns
* Replaces the column identifiers in the model. If the number of
* <code>newIdentifier</code>s is greater than the current number
* of columns, new columns are added to the end of each row in the model.
* If the number of <code>newIdentifier</code>s is less than the current
* number of columns, all the extra columns at the end of a row are
* discarded. 
* @param newIdentifiers vector of column identifiers. If
* <code>null</code>, set the model
* to zero columns
public void setColumnIdentifiers(Vector columnIdentifiers) {
setDataVector(dataVector, columnIdentifiers);
* Replaces the column identifiers in the model. If the number of
* <code>newIdentifier</code>s is greater than the current number
* of columns, new columns are added to the end of each row in the model.
* If the number of <code>newIdentifier</code>s is less than the current
* number of columns, all the extra columns at the end of a row are
* discarded. 
* @param newIdentifiers array of column identifiers.
* If <code>null</code>, set
* the model to zero columns
public void setColumnIdentifiers(Object[] newIdentifiers) {
setColumnIdentifiers(convertToVector(newIdentifiers));
* Sets the number of columns in the model. If the new size is greater
* than the current size, new columns are added to the end of the model
* with <code>null</code> cell values.
* If the new size is less than the current size, all columns at index
* <code>columnCount</code> and greater are discarded.
* @param columnCount the new number of columns in the model
public void setColumnCount(int columnCount) {
columnIdentifiers.setSize(columnCount);
justifyRows(0, getRowCount());
fireTableStructureChanged();
* Adds a column to the model. The new column will have the
* identifier <code>columnName</code>, which may be null. This method
* will send a
* <code>tableChanged</code> notification message to all the listeners.
* This method is a cover for <code>addColumn(Object, Vector)</code> which
* uses <code>null</code> as the data vector.
* @param columnName the identifier of the column being added
public void addColumn(Object columnName) {
addColumn(columnName, (Vector)null);
* Adds a column to the model. The new column will have the
* identifier <code>columnName</code>, which may be null.
* <code>columnData</code> is the
* optional vector of data for the column. If it is <code>null</code>
* the column is filled with <code>null</code> values. Otherwise,
* the new data will be added to model starting with the first
* element going to row 0, etc. This method will send a
* <code>tableChanged</code> notification message to all the listeners.
* @param columnName the identifier of the column being added
* @param columnData optional data of the column being added
public void addColumn(Object columnName, Vector columnData) {
columnIdentifiers.addElement(columnName);
if (columnData != null) {
int columnSize = columnData.size();
if (columnSize > getRowCount()) {
dataVector.setSize(columnSize);
justifyRows(0, getRowCount());
int newColumn = getColumnCount() - 1;
for(int i = 0; i < columnSize; i++) {
Vector row = (Vector)dataVector.elementAt(i);
row.setElementAt(columnData.elementAt(i), newColumn);
else {
justifyRows(0, getRowCount());
fireTableStructureChanged();
* Adds a column to the model. The new column will have the
* identifier <code>columnName</code>. <code>columnData</code> is the
* optional array of data for the column. If it is <code>null</code>
* the column is filled with <code>null</code> values. Otherwise,
* the new data will be added to model starting with the first
* element going to row 0, etc. This method will send a
* <code>tableChanged</code> notification message to all the listeners.
public void addColumn(Object columnName, Object[] columnData) {
addColumn(columnName, convertToVector(columnData));
// Implementing the TableModel interface
* Returns the number of rows in this data table.
* @return the number of rows in the model
public int getRowCount() {
return dataVector.size();
* Returns the number of columns in this data table.
* @return the number of columns in the model
public int getColumnCount() {
return columnIdentifiers.size();
* Returns the column name.
* @return a name for this column using the string value of the
* appropriate member in <code>columnIdentifiers</code>.
* If <code>columnIdentifiers</code> does not have an entry
* for this index, returns the default
* name provided by the superclass
public String getColumnName(int column) {
Object id = null;
// This test is to cover the case when
// getColumnCount has been subclassed by mistake ...
if (column < columnIdentifiers.size()) {
id = columnIdentifiers.elementAt(column);
return (id == null) ? getDefaultColumnName(column)
: id.toString();
* Returns true regardless of parameter values.
* @param row the row whose value is to be queried
* @param column the column whose value is to be queried
* @return true
public boolean isCellEditable(int row, int column) {
return true;
* Returns an attribute value for the cell at <code>row</code>
* and <code>column</code>.
* @param row the row whose value is to be queried
* @param column the column whose value is to be queried
* @return the value Object at the specified cell
* @exception ArrayIndexOutOfBoundsException if an invalid row or
* column was given
public Object getValueAt(int row, int column) {
Vector rowVector = (Vector)dataVector.elementAt(row);
return rowVector.elementAt(column);
* Sets the object value for the cell at <code>column</code> and
* <code>row</code>. <code>aValue</code> is the new value. This method
* will generate a <code>tableChanged</code> notification.
* @param aValue the new value; this can be null
* @param row the row whose value is to be changed
* @param column the column whose value is to be changed
* @exception ArrayIndexOutOfBoundsException if an invalid row or
* column was given
public void setValueAt(Object aValue, int row, int column) {
Vector rowVector = (Vector)dataVector.elementAt(row);
rowVector.setElementAt(aValue, column);
fireTableCellUpdated(row, column);
// Protected Methods
* Returns a vector that contains the same objects as the array.
* @param anArray the array to be converted
* @return the new vector; if <code>anArray</code> is <code>null</code>,
* returns <code>null</code>
protected static Vector convertToVector(Object[] anArray) {
if (anArray == null) {
return null;
Vector v = new Vector(anArray.length);
for (int i=0; i < anArray.length; i++) {
v.addElement(anArray[i]);
return v;
* Returns a vector of vectors that contains the same objects as the array.
* @param anArray the double array to be converted
* @return the new vector of vectors; if <code>anArray</code> is
* <code>null</code>, returns <code>null</code>
protected static Vector convertToVector(Object[][] anArray) {
if (anArray == null) {
return null;
Vector v = new Vector(anArray.length);
for (int i=0; i < anArray.length; i++) {
v.addElement(convertToVector(anArray[i]));
return v;

[Feature request] Runtime width of JTable columns based on attribute settings

I'm wondering if it's possible to let 'JClient' dynamically resize the columns in a JTable. Eg: I have set the width of some attribute of some ViewObject to 3. But when I run the application all columns are equally sized. I tried changing the JTable's property autoResizeMode (figuring it might override settings by JClient), but that doesn't seem to have any effect.
Also, 'grabbing' a column from the table through some manual coding and setting the width of that column doesn't seem to work either.
I've posted something regarding JTable Re: for specifically RIZWAN from PAkistan or anyone, but I'm curious to know if this 'Specialised editor for Grid Control (JTable)' that Grant Ronald spoke of, will include some sort of applicable functionality.
It's clear that we need some better (that is, 'any' ;)) way of manipulating columns in a JClient table.
Any comments?
Thanks.
Arno

We are currently looking into that.
The column width should not be controlled from the model, it is a setting on JTable, We are considering providing a JClient control (JUTable ??), which is a JTable in a scrollpane and give you more power over column width, column headers etc....
We are currently evaluating that.
It would mean that you've got a table control with properties allowing you to set these things on the control itself.
Currently you have to set the hints on the TableColumn.
Here is an example :
tableDeptView1.setModel(JUTableBinding.createAttributeListBinding(panelBinding, tableDeptView1, "DeptView1", null, "DeptView1Iter", new String[] {"Deptno", "Dname", "Loc"}));
tableDeptView1.getColumn("Deptno").setMaxWidth(75);
tableDeptView1.getColumn("Loc").setPreferredWidth(200);
tableDeptView1.getColumn("Loc").setMinWidth(100);
tableDeptView1.getColumn("Loc").setMaxWidth(450);

JTable displays string in wrong order : my code problem or Java problem ?

I have the following code that displays data in a JTable, most of the time it works fine, but I've realized when I have a cell with values like : "Snowboarding"+"[123456789]"
It would display it as : [Snowboarding[123456789
For a string like : "Chasing toddlers"+"<123456789>"
It would display it as : <Chasing toddlers<123456789
It not only moved the last bracket to the front, but also changed its direction from "]" to "[" and from ">" to "<"
Is there anything wrong with my code ? Or is this a Java problem ?
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.List;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
public class Table_Panel extends JPanel implements ItemListener
public static final long serialVersionUID=26362862L;
static final int Row_Color_Style_Default=-1,Row_Color_Style_None=0,Row_Color_Style_Blue_Gray=1,Row_Color_Style_Cyan_Gray=2,Row_Color_Style_Blue=3,
 Row_Color_Style_Gray=4,Row_Color_Style_Red_Green=5,Row_Color_Style_Green_Yellow=6,Row_Color_Style_Red_Yellow=7,
 Max_Header_Cell_Width=0,Header_Width=1,Cell_Width=2;
static int Row_Color_Style=Row_Color_Style_Cyan_Gray,Preffered_Width=Header_Width;
// static int Row_Color_Style=Row_Color_Style_None,Preffered_Width=Header_Width;
//boolean Debug=true,
boolean Debug=false,
// Use_Row_Colors=true,
 Use_Row_Colors=false;
JFrame Table_Frame;
TableModel My_Model;
JScrollPane scrollPane=new JScrollPane();
public JTable Table;
static String columnNames[],Default_Delimiter=\",\";
Object[][] data;
static Dimension Screen_Size=Toolkit.getDefaultToolkit().getScreenSize();
int Column_Width[];
static Color Default_Selection_Color=new Color(250,135,200);
Color Selection_Color=Default_Selection_Color;
public Table_Panel(ResultSet RS,String Table_Name,boolean Show_External_Table,int Row_Color_Style,int Preffered_Width,boolean In_Original_Order)
 String Value,Table_Column_Names[]=null;
 Object[][] Table_Data=null;
 int Row_Count,Index=0;
 try
 if (RS==null) return;
 else
 RS.last();
 Row_Count=RS.getRow();
 RS.beforeFirst();
 ResultSetMetaData rsmd=RS.getMetaData();
 int Column_Count=rsmd.getColumnCount();
 Table_Column_Names=new String[Column_Count];
 Table_Data=new Object[Row_Count][Column_Count];
 for (int i=1;i<=Column_Count;i++) Table_Column_Names[i-1]=rsmd.getColumnLabel(i); // Get column names
//Out("Row_Count="+Row_Count+" Column_Count="+Column_Count);
 while (RS.next()) // Get all rows
 for (int i=1;i<=Column_Count;i++)
 Value=RS.getString(i);
 Table_Data[Index][i-1]=(Value==null)?"null":Value;
 Index++;
// if (Test_Ct++>300) break;
 catch (Exception e) { e.printStackTrace(); }
 scrollPane=new Table_Panel(Table_Name,Table_Column_Names,Table_Data,Table_Data.length,false,Show_External_Table,false,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order).scrollPane;
public Table_Panel(String[] Table_Column_Names,Object[][] Table_Data,Color Selection_Color,boolean In_Original_Order)
 this("",Table_Column_Names,Table_Data,Table_Data.length,false,false,false,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order);
public Table_Panel(String Table_Name,String[] Table_Column_Names,Object[][] Table_Data,boolean Show_External_Table,Color Selection_Color,boolean In_Original_Order)
 this(Table_Name,Table_Column_Names,Table_Data,Table_Data.length,false,Show_External_Table,false,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order);
public Table_Panel(String Table_Name,String[] Table_Column_Names,Object[][] Table_Data,int Row_Count,boolean Is_Child,boolean Show_External_Table,boolean Manage_Attachment,int Row_Color_Style,int Preffered_Width,Color Selection_Color,boolean In_Original_Order)
 columnNames=Table_Column_Names;
 if (In_Original_Order) data=Table_Data;
 else
 data=new Object[Table_Data.length][columnNames.length];
 for (int row=0;row<Table_Data.length;row++)
 data[row]=new Object[columnNames.length];
 for (int Column=0;Column<Table_Data[row].length;Column++) data[row][Column]=Table_Data[Table_Data.length-1-row][Column];
 Column_Width=new int[columnNames.length];
 this.Row_Color_Style=Row_Color_Style;
 Use_Row_Colors=(Row_Color_Style!=Row_Color_Style_None);
 this.Preffered_Width=Preffered_Width;
 if (Selection_Color!=null) this.Selection_Color=Selection_Color;
// Out("this.Selection_Color="+this.Selection_Color);
// TableModel My_Model=new DefaultTableModel(Table_Data,columnNames)
 TableModel My_Model=new DefaultTableModel(data,columnNames)
 public int getColumnCount() { return columnNames.length; }
 public int getRowCount() { return data.length; }
 public String getColumnName(int col) { return columnNames[col]; }
 public Object getValueAt(int row,int col)
// Out(row+","+col+"["+data[row][col]+"] data.length="+data.length+" data[0].length="+data[0].length);
 return (data[row][col]==null)?"":((data[row][col] instanceof Boolean)?data[row][col]:data[row][col].toString()); // Non-boolean values will have bgcolor
 public Class getColumnClass(int column)
 Class returnValue;
 if ((column>=0) && (column<getColumnCount())) returnValue=getValueAt(0,column).getClass();
 else returnValue=Object.class;
 return returnValue;
 // JTable uses this method to determine the default renderer/editor for each cell. If we didn't implement this method, then the last column would contain text ("true"/"false"), rather than a check box.
// public Class getColumnClass(int c) { return getValueAt(0,c).getClass(); }
 // Don't need to implement this method unless your table's editable.
 public boolean isCellEditable(int row,int col)
 //Note that the data/cell address is constant, no matter where the cell appears onscreen.
 if (col<0) return false;
 else return true;
 // Don't need to implement this method unless your table's data can change.
 public void setValueAt(Object value,int row,int col)
 String Execution_Dir=getClass().getProtectionDomain().getCodeSource().getLocation().toString();
 if (Debug) System.out.println("Execution_Dir="+Execution_Dir+"\nLast_Value="+Table_Grid_Cell_Renderer.Last_Value+" Setting value at [ "+row+","+col+" ] to "+value+" (an instance of "+value.getClass()+")");
 if (Execution_Dir.toLowerCase().indexOf("c:/")!=-1 || value.getClass()==Boolean.class || !Use_Row_Colors) data[row][col]=value;
// else data[row][col]=(Table_Grid_CellRenderer.Last_Value==null)?value:value.toString().substring(Table_Grid_CellRenderer.Last_Value.toString().length());
 fireTableCellUpdated(row,col);
 if (Debug)
 System.out.println("New value of data :");
 printDebugData();
 private void printDebugData()
 int numRows=getRowCount();
 int numCols=getColumnCount();
 for (int i=0;i<numRows;i++)
 System.out.print(" row "+i+":");
 for (int j=0;j<numCols;j++) System.out.print(" "+data[i][j]);
 System.out.println();
 System.out.println("--------------------------------------------------------------------------");
 TableSorter sorter=new TableSorter(My_Model);
 Table=new JTable(sorter)
// Table=new JTable(My_Model)
 public static final long serialVersionUID=26362862L;
 public String getToolTipText(MouseEvent e) // Implement table cell tool tips.
 Object Cell_Tip;
 String tip=null;
 java.awt.Point p=e.getPoint();
 int rowIndex=rowAtPoint(p);
 int colIndex=columnAtPoint(p);
 int realColumnIndex=convertColumnIndexToModel(colIndex);
 Cell_Tip=getValueAt(rowIndex,colIndex);
// if (realColumnIndex == 2) //Sport column
 tip=Cell_Tip.toString();
 else if (realColumnIndex == 4) //Veggie column
 TableModel model=getModel();
 String firstName=(String)model.getValueAt(rowIndex,0);
 String lastName=(String)model.getValueAt(rowIndex,1);
 Boolean veggie=(Boolean)model.getValueAt(rowIndex,4);
 if (Boolean.TRUE.equals(veggie)) tip=firstName+" "+lastName+" is a vegetarian";
 else tip=firstName+" "+lastName+" is not a vegetarian";
 else
 // You can omit this part if you know you don't have any renderers that supply their own tool tips.
 tip=super.getToolTipText(e);
 return tip;
// RowSorter<TableModel> sorter=new TableRowSorter<TableModel>(My_Model);
// Table.setRowSorter(sorter);
 Table.setSelectionBackground(this.Selection_Color);
 int Table_Height=Table.getRowHeight()*Row_Count;
 // sorter.addMouseListenerToHeaderInTable(Table); // ADDED THIS
 sorter.setTableHeader(Table.getTableHeader());
 if (Table_Column_Names.length>20) Table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
 if (Manage_Attachment) Table.setPreferredScrollableViewportSize(new Dimension(500,(Table_Height>850)?850:Table_Height));
 else Table.setPreferredScrollableViewportSize(new Dimension(1000,(Table_Height>850)?850:Table_Height));
 if (Use_Row_Colors) Table.setDefaultRenderer(Object.class,new Table_Grid_Cell_Renderer());
 //Create the scroll pane and add the table to it.
 scrollPane=new JScrollPane(Table);
 //Set up column sizes.
 initColumnSizes(Table,My_Model);
 //Add the scroll pane to this window.
 if (Show_External_Table)
 Table_Frame=new JFrame(Table_Name);
 Table_Frame.getContentPane().add(scrollPane);
 Table_Frame.addWindowListener(new WindowAdapter()
 public void windowActivated(WindowEvent e) { }
 public void windowClosed(WindowEvent e) { }
 public void windowClosing(WindowEvent e) { System.exit(0); }
 public void windowDeactivated(WindowEvent e) { }
 public void windowDeiconified(WindowEvent e) { scrollPane.repaint(); }
 public void windowGainedFocus(WindowEvent e) { scrollPane.repaint(); }
 public void windowIconified(WindowEvent e) { }
 public void windowLostFocus(WindowEvent e) { }
 public void windowOpening(WindowEvent e) { scrollPane.repaint(); }
 public void windowOpened(WindowEvent e) { }
 public void windowResized(WindowEvent e) { scrollPane.repaint(); }
 public void windowStateChanged(WindowEvent e) { scrollPane.repaint(); }
 Table_Frame.pack();
 Table_Frame.setBounds((Screen_Size.width-Table_Frame.getWidth())/2,(Screen_Size.height-Table_Frame.getHeight())/2,Table_Frame.getWidth(),Table_Frame.getHeight());
 Table_Frame.setVisible(true);
 if (Is_Child) Table_Frame.addComponentListener(new ComponentAdapter() { public void componentClosing(ComponentEvent e) { System.exit(0); } });
 else add(scrollPane);
public Table_Panel(String File_Name) { this(File_Name,false,Row_Color_Style_Cyan_Gray,Preffered_Width,null,Default_Selection_Color,true); }
public Table_Panel(String File_Name,int Row_Color_Style,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style,Preffered_Width,null,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,String Delimiter,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style_Cyan_Gray,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,int Preffered_Width,String Delimiter,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,int Row_Color_Style,int Preffered_Width,String Delimiter,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,boolean Show_External_Table,boolean In_Original_Order) { this(File_Name,Show_External_Table,Row_Color_Style,Preffered_Width,null,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,boolean Show_External_Table,String Delimiter,boolean In_Original_Order) { this(File_Name,Show_External_Table,Row_Color_Style,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,boolean Show_External_Table,int Row_Color_Style,int Preffered_Width,String Delimiter,Color Selection_Color,boolean In_Original_Order)
 String Table_Column_Names[],Column_Name_Line="";
 int Row_Count=0,Index=0;
 boolean Is_Child=false,Manage_Attachment=false;
 StringTokenizer ST;
 if (Delimiter==null) Delimiter=Default_Delimiter;
 if (new File(File_Name).exists())
 try
 String Line,Str=Tool_Lib.Read_File(File_Name).toString();
 ST=new StringTokenizer(Str,"\n");
 Line=ST.nextToken();
 Row_Count=ST.countTokens();
 Object[][] Table_Data=new Object[Row_Count][];
 if (Delimiter.equals(" ")) Line=Line.replaceAll(" {2,}"," ").trim(); // Replace multiple spaces with the delimiter space
 Table_Column_Names=Line.split(Delimiter);
 columnNames=Table_Column_Names;
 for (int i=0;i<Table_Column_Names.length;i++) Column_Name_Line+=Table_Column_Names[i]+" ";
//Out("Column_Name_Line [ "+Table_Column_Names.length+" ]="+Column_Name_Line);
 while (ST.hasMoreTokens())
 Line=ST.nextToken();
//Out(Line);
 if (Delimiter.equals(" ")) Line=Line.replaceAll(" {2,}"," ").trim(); // Replace multiple spaces with the delimiter space
 if (Line.indexOf(Delimiter)!=-1) Table_Data[Index]=Line.split(Delimiter);
 else
 Table_Data[Index]=new Object[Table_Column_Names.length];
 Table_Data[Index][0]=Line;
 for (int i=1;i<Table_Column_Names.length;i++) Table_Data[Index]="";
Index++;
Line="";
for (int i=0;i<Table_Data.length;i++)
Line+="[ "+Table_Data[i].length+" ] ";
for (int j=0;j<Table_Data[i].length;j++) Line+=Table_Data[i][j]+" ";
Line+="\n";
Out(Line);
Table_Panel A_Table_Panel=new Table_Panel(File_Name,Table_Column_Names,Table_Data,Row_Count,Is_Child,Show_External_Table,Manage_Attachment,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order);
Table=A_Table_Panel.Table;
scrollPane=A_Table_Panel.scrollPane;
Column_Width=A_Table_Panel.Column_Width;
data=A_Table_Panel.data;
catch (Exception e) { e.printStackTrace(); }
public void setPreferredSize(Dimension A_Dimension) { scrollPane.setPreferredSize(A_Dimension); }
// This method picks good column sizes. If all column heads are wider than the column's cells' contents, then you can just use column.sizeWidthToFit().
void initColumnSizes(JTable table,TableModel model)
TableColumn column=null;
Component comp=null;
int headerWidth=0,cellWidth=0;
Object[] longValues=(data.length>0)?data[0]:null;
TableCellRenderer headerRenderer=table.getTableHeader().getDefaultRenderer();
if (data.length<1) return;
for (int i=0;i<model.getColumnCount();i++)
column=table.getColumnModel().getColumn(i);
comp=headerRenderer.getTableCellRendererComponent(null,column.getHeaderValue(),false,false,0,0);
headerWidth=comp.getPreferredSize().width;
comp=table.getDefaultRenderer(model.getColumnClass(i)).
getTableCellRendererComponent(table,longValues[i],false,false,0,i);
cellWidth=comp.getPreferredSize().width;
switch (Preffered_Width)
case Max_Header_Cell_Width : column.setPreferredWidth(Math.max(headerWidth,cellWidth));break;
case Header_Width : column.setPreferredWidth(headerWidth);break;
case Cell_Width : column.setPreferredWidth(cellWidth);break;
Column_Width[i]=column.getPreferredWidth();
if (Debug) Out("Initializing width of column "+i+". "+"headerWidth="+headerWidth+"; cellWidth="+cellWidth+" Column_Width["+i+"]="+Column_Width[i]);
// Detects a state change in any of the Lists. Resets the variable corresponding to the selected item in a particular List. Invokes changeFont with the currently selected fontname, style and size attributes.
public void itemStateChanged(ItemEvent e)
Out(e.toString());
if (e.getStateChange() != ItemEvent.SELECTED) return;
Object list=e.getSource();
public static void Out(String message) { System.out.println(message); }
// Create the GUI and show it. For thread safety, this method should be invoked from the event-dispatching thread.
static void Create_And_Show_GUI()
boolean Demo_External_Table=true;
// boolean Demo_External_Table=false;
final Table_Panel demo;
String[] columnNames={"First Names","Last Names","Sport","Num of Years","Vegetarian"};
Object[][] data={{"Mary","Campione","Snowboarding"+"[123456789]",new Integer(5),new Boolean(false)},
{"Alison","Huml","Rowing"+":123456789]",new Integer(3),new Boolean(true)},
{"Frank","Ni","Running"+":123456789", new Integer(12), new Boolean(false)},
{"Kathy","Walrath","Chasing toddlers"+"<123456789>", new Integer(2), new Boolean(false)},
{"Mark", "Andrews","Speed reading",new Integer(20),new Boolean(true)},
{"Angela","Lih","Teaching high school",new Integer(36),new Boolean(false)} };
// Row_Color_Style=Row_Color_Style_Default;
// Row_Color_Style=Row_Color_Style_None;
// Row_Color_Style=Row_Color_Style_Blue_Gray;
Row_Color_Style=Row_Color_Style_Cyan_Gray;
// Row_Color_Style=Row_Color_Style_Blue;
// Row_Color_Style=Row_Color_Style_Gray;
// Row_Color_Style=Row_Color_Style_Red_Green;
// Row_Color_Style=Row_Color_Style_Green_Yellow;
// Row_Color_Style=Row_Color_Style_Red_Yellow;
Preffered_Width=Max_Header_Cell_Width;
if (Demo_External_Table) demo=new Table_Panel("External Table Demo",columnNames,data,data.length,false,Demo_External_Table,false,Row_Color_Style,Max_Header_Cell_Width,Default_Selection_Color,true);
else
JFrame Table_Frame=new JFrame("Internal Table Demo");
// demo=new Table_Panel(Nm_Lib.Dir_A_Test+"ELX.csv",false,Row_Color_Style,Preffered_Width,null);
// demo=new Table_Panel(Nm_Lib.Dir_Stock_Data+"ABV_Data.txt",false,Row_Color_Style,Preffered_Width," ");
demo=new Table_Panel("C:/Dir_Stock_Data/EOP.txt",",",false);
// demo=new Table_Panel(Nm_Lib.Dir_Stock_Data+"ABV_Data.txt"," ",false);
Table_Frame.getContentPane().add(demo.scrollPane);
Table_Frame.addWindowListener(new WindowAdapter()
public void windowActivated(WindowEvent e) { }
public void windowClosed(WindowEvent e) { }
public void windowClosing(WindowEvent e) { System.exit(0); }
public void windowDeactivated(WindowEvent e) { }
public void windowDeiconified(WindowEvent e) { demo.repaint(); }
public void windowGainedFocus(WindowEvent e) { demo.repaint(); }
public void windowIconified(WindowEvent e) { }
public void windowLostFocus(WindowEvent e) { }
public void windowOpening(WindowEvent e) { demo.repaint(); }
public void windowOpened(WindowEvent e) { }
public void windowResized(WindowEvent e) { demo.repaint(); }
public void windowStateChanged(WindowEvent e) { demo.repaint(); }
Table_Frame.pack();
Table_Frame.setBounds((Screen_Size.width-Table_Frame.getWidth())/2,(Screen_Size.height-Table_Frame.getHeight())/2,Table_Frame.getWidth(),Table_Frame.getHeight());
Table_Frame.setVisible(true);
public static void main(String[] args)
// Schedule a job for the event-dispatching thread : creating and showing this application's GUI.
SwingUtilities.invokeLater(new Runnable() { public void run() { Create_And_Show_GUI(); } });
* TableSorter is a decorator for TableModels; adding sorting functionality to a supplied TableModel. TableSorter does not store
* or copy the data in its TableModel; instead it maintains a map from the row indexes of the view to the row indexes of the
* model. As requests are made of the sorter (like getValueAt(row, col)) they are passed to the underlying model after the row numbers
* have been translated via the internal mapping array. This way, the TableSorter appears to hold another copy of the table
* with the rows in a different order.
* 
* TableSorter registers itself as a listener to the underlying model, just as the JTable itself would. Events recieved from the model
* are examined, sometimes manipulated (typically widened), and then passed on to the TableSorter's listeners (typically the JTable).
* If a change to the model has invalidated the order of TableSorter's rows, a note of this is made and the sorter will resort the
* rows the next time a value is requested.
* 
* When the tableHeader property is set, either by using the setTableHeader() method or the two argument constructor, the table
* header may be used as a complete UI for TableSorter. The default renderer of the tableHeader is decorated with a renderer
* that indicates the sorting status of each column. In addition, a mouse listener is installed with the following behavior:
* <ul>
* <li>
* Mouse-click: Clears the sorting status of all other columns and advances the sorting status of that column through three
* values: {NOT_SORTED, ASCENDING, DESCENDING} (then back to NOT_SORTED again).
* <li>
* SHIFT-mouse-click: Clears the sorting status of all other columns and cycles the sorting status of the column through the same
* three values, in the opposite order: {NOT_SORTED, DESCENDING, ASCENDING}.
* <li>
* CONTROL-mouse-click and CONTROL-SHIFT-mouse-click: as above except that the changes to the column do not cancel the statuses of columns
* that are already sorting - giving a way to initiate a compound sort.
* </ul>
* 
* This is a long overdue rewrite of a class of the same name that first appeared in the swing table demos in 1997.
* @author Philip Milne
* @author Brendon McLean
* @author Dan van Enckevort
* @author Parwinder Sekhon
* @version 2.0 02/27/04
class TableSorter extends AbstractTableModel
public static final long serialVersionUID=26362862L;
protected TableModel tableModel;
public static final int DESCENDING = -1;
public static final int NOT_SORTED = 0;
public static final int ASCENDING = 1;
private static Directive EMPTY_DIRECTIVE = new Directive(-1, NOT_SORTED);
public static final Comparator COMPARABLE_COMAPRATOR = new Comparator() { public int compare(Object o1, Object o2) { return ((Comparable) o1).compareTo(o2); } };
public static final Comparator LEXICAL_COMPARATOR = new Comparator() { public int compare(Object o1, Object o2) { return o1.toString().compareTo(o2.toString()); } };
private Row[] viewToModel;
private int[] modelToView;
private JTableHeader tableHeader;
private MouseListener mouseListener;
private TableModelListener tableModelListener;
private Map<Class,Comparator> columnComparators = new HashMap<Class,Comparator>();
private List<Directive> sortingColumns = new ArrayList<Directive>();
public TableSorter()
this.mouseListener = new MouseHandler();
this.tableModelListener = new TableModelHandler();
public TableSorter(TableModel tableModel)
this();
setTableModel(tableModel);
public TableSorter(TableModel tableModel, JTableHeader tableHeader)
this();
setTableHeader(tableHeader);
setTableModel(tableModel);
private void clearSortingState()
viewToModel = null;
modelToView = null;
public TableModel getTableModel() { return tableModel; }
public void setTableModel(TableModel tableModel)
if (this.tableModel != null) { this.tableModel.removeTableModelListener(tableModelListener); }
this.tableModel = tableModel;
if (this.tableModel != null) { this.tableModel.addTableModelListener(tableModelListener); }
clearSortingState();
fireTableStructureChanged();
public JTableHeader getTableHeader() { return tableHeader; }
public void setTableHeader(JTableHeader tableHeader)
if (this.tableHeader != null)
this.tableHeader.removeMouseListener(mouseListener);
TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();
if (defaultRenderer instanceof SortableHeaderRenderer) this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
this.tableHeader = tableHeader;
if (this.tableHeader != null)
this.tableHeader.addMouseListener(mouseListener);
this.tableHeader.setDefaultRenderer(
new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));
public boolean isSorting() { return sortingColumns.size() != 0; }
private Directive getDirective(int column)
for (int i = 0; i < sortingColumns.size(); i++)
Directive directive = (Directive)sortingColumns.get(i);
if (directive.column == column) { return directive; }
return EMPTY_DIRECTIVE;
public int getSortingStatus(int column) { return getDirective(column).direction; }
private void sortingStatusChanged()
clearSortingState();
fireTableDataChanged();
if (tableHeader != null) { tableHeader.repaint(); }
public void setSortingStatus(int column, int status)
Directive directive = getDirective(column);
if (directive != EMPTY_DIRECTIVE) { sortingColumns.remove(directive); }
if (status != NOT_SORTED) { sortingColumns.add(new Directive(column, status)); }
sortingStatusChanged();
protected Icon getHeaderRendererIcon(int column, int size)
Directive directive = getDirective(column);
if (directive == EMPTY_DIRECTIVE) { return null; }
return new Arrow(directive.direction == DESCENDING, size, sortingColumns.indexOf(directive));
private void cancelSorting()
sortingColumns.clear();
sortingStatusChanged();
public void setColumnComparator(Class type, Comparator comparator)
if (comparator == null) { columnComparators.remove(type); }
else { columnComparators.put(type, comparator); }
protected Comparator getComparator(int column)
Class columnType = tableModel.getColumnClass(column);
Comparator comparator = (Comparator) columnComparators.get(columnType);
if (comparator != null) { return comparator; }
if (Comparable.class.isAssignableFrom(columnType)) { return COMPARABLE_COMAPRATOR; }
return LEXICAL_COMPARATOR;
private Row[] getViewToModel()
if (viewToModel == null)
int tableModelRowCount = tableModel.getRowCount();
viewToModel = new Row[tableModelRowCount];
for (int row = 0; row < tableModelRowCount; row++) { viewToModel[row] = new Row(row); }
if (isSorting()) { Arrays.sort(viewToModel); }
return viewToModel;
public int modelIndex(int viewIndex) { return getViewToModel()[viewIndex].modelIndex; }
private int[] getModelToView()
if (modelToView == null)
int n = getViewToModel().length;
modelToView = new int[n];
for (int i = 0; i < n; i++) { modelToView[modelIndex(i)] = i; }
return modelToView;
// TableModel interface methods
public int getRowCount() { return (tableModel == null) ? 0 : tableModel.getRowCount(); }
public int getColumnCount() { return (tableModel == null) ? 0 : tableModel.getColumnCount(); }
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(modelIndex(row), column); }
public Object getValueAt(int row, int column) { return tableModel.getValueAt(modelIndex(row), column); }
public void setValueAt(Object aValue, int row, int column) { tableModel.setValueAt(aValue, modelIndex(row), column); }
// Helper classes
private class Row implements Comparable
private int modelIndex;
public Row(int index) { this.modelIndex = index; }
public int compareTo(Object o)
int row1 = modelIndex;
int row2 = ((Row) o).modelIndex;
for (Iterator it = sortingColumns.iterator(); it.hasNext();)
Directive directive = (Directive) it.next();
int column = directive.column;
Object o1 = tableModel.getValueAt(row1, column);
Object o2 = tableModel.getValueAt(row2, column);
int comparison = 0;
// Define null less than everything, except null.

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.List;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
public class Table_Panel extends JPanel implements ItemListener
public static final long serialVersionUID=26362862L;
static final int Row_Color_Style_Default=-1,Row_Color_Style_None=0,Row_Color_Style_Blue_Gray=1,Row_Color_Style_Cyan_Gray=2,Row_Color_Style_Blue=3,
 Row_Color_Style_Gray=4,Row_Color_Style_Red_Green=5,Row_Color_Style_Green_Yellow=6,Row_Color_Style_Red_Yellow=7,
 Max_Header_Cell_Width=0,Header_Width=1,Cell_Width=2;
static int Row_Color_Style=Row_Color_Style_Cyan_Gray,Preffered_Width=Header_Width;
// static int Row_Color_Style=Row_Color_Style_None,Preffered_Width=Header_Width;
//boolean Debug=true,
boolean Debug=false,
// Use_Row_Colors=true,
 Use_Row_Colors=false;
JFrame Table_Frame;
TableModel My_Model;
JScrollPane scrollPane=new JScrollPane();
public JTable Table;
static String columnNames[],Default_Delimiter=",";
Object[][] data;
static Dimension Screen_Size=Toolkit.getDefaultToolkit().getScreenSize();
int Column_Width[];
static Color Default_Selection_Color=new Color(250,135,200);
Color Selection_Color=Default_Selection_Color;
public Table_Panel(ResultSet RS,String Table_Name,boolean Show_External_Table,int Row_Color_Style,int Preffered_Width,boolean In_Original_Order)
 String Value,Table_Column_Names[]=null;
 Object[][] Table_Data=null;
 int Row_Count,Index=0;
 try
 if (RS==null) return;
 else
 RS.last();
 Row_Count=RS.getRow();
 RS.beforeFirst();
 ResultSetMetaData rsmd=RS.getMetaData();
 int Column_Count=rsmd.getColumnCount();
 Table_Column_Names=new String[Column_Count];
 Table_Data=new Object[Row_Count][Column_Count];
 for (int i=1;i<=Column_Count;i++) Table_Column_Names[i-1]=rsmd.getColumnLabel(i); // Get column names
//Out("Row_Count="+Row_Count+" Column_Count="+Column_Count);
 while (RS.next()) // Get all rows
 for (int i=1;i<=Column_Count;i++)
 Value=RS.getString(i);
 Table_Data[Index][i-1]=(Value==null)?"null":Value;
 Index++;
// if (Test_Ct++>300) break;
 catch (Exception e) { e.printStackTrace(); }
 scrollPane=new Table_Panel(Table_Name,Table_Column_Names,Table_Data,Table_Data.length,false,Show_External_Table,false,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order).scrollPane;
public Table_Panel(String[] Table_Column_Names,Object[][] Table_Data,Color Selection_Color,boolean In_Original_Order)
 this("",Table_Column_Names,Table_Data,Table_Data.length,false,false,false,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order);
public Table_Panel(String Table_Name,String[] Table_Column_Names,Object[][] Table_Data,boolean Show_External_Table,Color Selection_Color,boolean In_Original_Order)
 this(Table_Name,Table_Column_Names,Table_Data,Table_Data.length,false,Show_External_Table,false,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order);
public Table_Panel(String Table_Name,String[] Table_Column_Names,Object[][] Table_Data,int Row_Count,boolean Is_Child,boolean Show_External_Table,boolean Manage_Attachment,int Row_Color_Style,int Preffered_Width,Color Selection_Color,boolean In_Original_Order)
 columnNames=Table_Column_Names;
 if (In_Original_Order) data=Table_Data;
 else
 data=new Object[Table_Data.length][columnNames.length];
 for (int row=0;row<Table_Data.length;row++)
 data[row]=new Object[columnNames.length];
 for (int Column=0;Column<Table_Data[row].length;Column++) data[row][Column]=Table_Data[Table_Data.length-1-row][Column];
 Column_Width=new int[columnNames.length];
 this.Row_Color_Style=Row_Color_Style;
 Use_Row_Colors=(Row_Color_Style!=Row_Color_Style_None);
 this.Preffered_Width=Preffered_Width;
 if (Selection_Color!=null) this.Selection_Color=Selection_Color;
// Out("this.Selection_Color="+this.Selection_Color);
// TableModel My_Model=new DefaultTableModel(Table_Data,columnNames)
 TableModel My_Model=new DefaultTableModel(data,columnNames)
 public int getColumnCount() { return columnNames.length; }
 public int getRowCount() { return data.length; }
 public String getColumnName(int col) { return columnNames[col]; }
 public Object getValueAt(int row,int col)
// Out(row+","+col+"["+data[row][col]+"] data.length="+data.length+" data[0].length="+data[0].length);
 return (data[row][col]==null)?"":((data[row][col] instanceof Boolean)?data[row][col]:data[row][col].toString()); // Non-boolean values will have bgcolor
 public Class getColumnClass(int column)
 Class returnValue;
 if ((column>=0) && (column<getColumnCount())) returnValue=getValueAt(0,column).getClass();
 else returnValue=Object.class;
 return returnValue;
 // JTable uses this method to determine the default renderer/editor for each cell. If we didn't implement this method, then the last column would contain text ("true"/"false"), rather than a check box.
// public Class getColumnClass(int c) { return getValueAt(0,c).getClass(); }
 // Don't need to implement this method unless your table's editable.
 public boolean isCellEditable(int row,int col)
 //Note that the data/cell address is constant, no matter where the cell appears onscreen.
 if (col<0) return false;
 else return true;
 // Don't need to implement this method unless your table's data can change.
 public void setValueAt(Object value,int row,int col)
 String Execution_Dir=getClass().getProtectionDomain().getCodeSource().getLocation().toString();
 if (Debug) System.out.println("Execution_Dir="+Execution_Dir+"\nLast_Value="+Table_Grid_Cell_Renderer.Last_Value+" Setting value at [ "+row+","+col+" ] to "+value+" (an instance of "+value.getClass()+")");
 if (Execution_Dir.toLowerCase().indexOf("c:/")!=-1 || value.getClass()==Boolean.class || !Use_Row_Colors) data[row][col]=value;
// else data[row][col]=(Table_Grid_CellRenderer.Last_Value==null)?value:value.toString().substring(Table_Grid_CellRenderer.Last_Value.toString().length());
 fireTableCellUpdated(row,col);
 if (Debug)
 System.out.println("New value of data :");
 printDebugData();
 private void printDebugData()
 int numRows=getRowCount();
 int numCols=getColumnCount();
 for (int i=0;i<numRows;i++)
 System.out.print(" row "+i+":");
 for (int j=0;j<numCols;j++) System.out.print(" "+data[i][j]);
 System.out.println();
 System.out.println("--------------------------------------------------------------------------");
 TableSorter sorter=new TableSorter(My_Model);
 Table=new JTable(sorter)
// Table=new JTable(My_Model)
 public static final long serialVersionUID=26362862L;
 public String getToolTipText(MouseEvent e) // Implement table cell tool tips.
 Object Cell_Tip;
 String tip=null;
 java.awt.Point p=e.getPoint();
 int rowIndex=rowAtPoint(p);
 int colIndex=columnAtPoint(p);
 int realColumnIndex=convertColumnIndexToModel(colIndex);
 Cell_Tip=getValueAt(rowIndex,colIndex);
// if (realColumnIndex == 2) //Sport column
 tip=Cell_Tip.toString();
 else if (realColumnIndex == 4) //Veggie column
 TableModel model=getModel();
 String firstName=(String)model.getValueAt(rowIndex,0);
 String lastName=(String)model.getValueAt(rowIndex,1);
 Boolean veggie=(Boolean)model.getValueAt(rowIndex,4);
 if (Boolean.TRUE.equals(veggie)) tip=firstName+" "+lastName+" is a vegetarian";
 else tip=firstName+" "+lastName+" is not a vegetarian";
 else
 // You can omit this part if you know you don't have any renderers that supply their own tool tips.
 tip=super.getToolTipText(e);
 return tip;
// RowSorter<TableModel> sorter=new TableRowSorter<TableModel>(My_Model);
// Table.setRowSorter(sorter);
 Table.setSelectionBackground(this.Selection_Color);
 int Table_Height=Table.getRowHeight()*Row_Count;
 // sorter.addMouseListenerToHeaderInTable(Table); // ADDED THIS
 sorter.setTableHeader(Table.getTableHeader());
 if (Table_Column_Names.length>20) Table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
 if (Manage_Attachment) Table.setPreferredScrollableViewportSize(new Dimension(500,(Table_Height>850)?850:Table_Height));
 else Table.setPreferredScrollableViewportSize(new Dimension(1000,(Table_Height>850)?850:Table_Height));
 if (Use_Row_Colors) Table.setDefaultRenderer(Object.class,new Table_Grid_Cell_Renderer());
 //Create the scroll pane and add the table to it.
 scrollPane=new JScrollPane(Table);
 //Set up column sizes.
 initColumnSizes(Table,My_Model);
 //Add the scroll pane to this window.
 if (Show_External_Table)
 Table_Frame=new JFrame(Table_Name);
 Table_Frame.getContentPane().add(scrollPane);
 Table_Frame.addWindowListener(new WindowAdapter()
 public void windowActivated(WindowEvent e) { }
 public void windowClosed(WindowEvent e) { }
 public void windowClosing(WindowEvent e) { System.exit(0); }
 public void windowDeactivated(WindowEvent e) { }
 public void windowDeiconified(WindowEvent e) { scrollPane.repaint(); }
 public void windowGainedFocus(WindowEvent e) { scrollPane.repaint(); }
 public void windowIconified(WindowEvent e) { }
 public void windowLostFocus(WindowEvent e) { }
 public void windowOpening(WindowEvent e) { scrollPane.repaint(); }
 public void windowOpened(WindowEvent e) { }
 public void windowResized(WindowEvent e) { scrollPane.repaint(); }
 public void windowStateChanged(WindowEvent e) { scrollPane.repaint(); }
 Table_Frame.pack();
 Table_Frame.setBounds((Screen_Size.width-Table_Frame.getWidth())/2,(Screen_Size.height-Table_Frame.getHeight())/2,Table_Frame.getWidth(),Table_Frame.getHeight());
 Table_Frame.setVisible(true);
 if (Is_Child) Table_Frame.addComponentListener(new ComponentAdapter() { public void componentClosing(ComponentEvent e) { System.exit(0); } });
 else add(scrollPane);
public Table_Panel(String File_Name) { this(File_Name,false,Row_Color_Style_Cyan_Gray,Preffered_Width,null,Default_Selection_Color,true); }
public Table_Panel(String File_Name,int Row_Color_Style,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style,Preffered_Width,null,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,String Delimiter,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style_Cyan_Gray,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,int Preffered_Width,String Delimiter,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,int Row_Color_Style,int Preffered_Width,String Delimiter,boolean In_Original_Order) { this(File_Name,false,Row_Color_Style,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,boolean Show_External_Table,boolean In_Original_Order) { this(File_Name,Show_External_Table,Row_Color_Style,Preffered_Width,null,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,boolean Show_External_Table,String Delimiter,boolean In_Original_Order) { this(File_Name,Show_External_Table,Row_Color_Style,Preffered_Width,Delimiter,Default_Selection_Color,In_Original_Order); }
public Table_Panel(String File_Name,boolean Show_External_Table,int Row_Color_Style,int Preffered_Width,String Delimiter,Color Selection_Color,boolean In_Original_Order)
 String Table_Column_Names[],Column_Name_Line="";
 int Row_Count=0,Index=0;
 boolean Is_Child=false,Manage_Attachment=false;
 StringTokenizer ST;
 if (Delimiter==null) Delimiter=Default_Delimiter;
 if (new File(File_Name).exists())
 try
 String Line,Str=Tool_Lib.Read_File(File_Name).toString();
 ST=new StringTokenizer(Str,"\n");
 Line=ST.nextToken();
 Row_Count=ST.countTokens();
 Object[][] Table_Data=new Object[Row_Count][];
 if (Delimiter.equals(" ")) Line=Line.replaceAll(" {2,}"," ").trim(); // Replace multiple spaces with the delimiter space
 Table_Column_Names=Line.split(Delimiter);
 columnNames=Table_Column_Names;
 for (int i=0;i<Table_Column_Names.length;i++) Column_Name_Line+=Table_Column_Names[i]+" ";
//Out("Column_Name_Line [ "+Table_Column_Names.length+" ]="+Column_Name_Line);
 while (ST.hasMoreTokens())
 Line=ST.nextToken();
//Out(Line);
 if (Delimiter.equals(" ")) Line=Line.replaceAll(" {2,}"," ").trim(); // Replace multiple spaces with the delimiter space
 if (Line.indexOf(Delimiter)!=-1) Table_Data[Index]=Line.split(Delimiter);
 else
 Table_Data[Index]=new Object[Table_Column_Names.length];
 Table_Data[Index][0]=Line;
 for (int i=1;i<Table_Column_Names.length;i++) Table_Data[Index]="";
Index++;
Line="";
for (int i=0;i<Table_Data.length;i++)
Line+="[ "+Table_Data[i].length+" ] ";
for (int j=0;j<Table_Data[i].length;j++) Line+=Table_Data[i][j]+" ";
Line+="\n";
Out(Line);
Table_Panel A_Table_Panel=new Table_Panel(File_Name,Table_Column_Names,Table_Data,Row_Count,Is_Child,Show_External_Table,Manage_Attachment,Row_Color_Style,Preffered_Width,Selection_Color,In_Original_Order);
Table=A_Table_Panel.Table;
scrollPane=A_Table_Panel.scrollPane;
Column_Width=A_Table_Panel.Column_Width;
data=A_Table_Panel.data;
catch (Exception e) { e.printStackTrace(); }
public void setPreferredSize(Dimension A_Dimension) { scrollPane.setPreferredSize(A_Dimension); }
// This method picks good column sizes. If all column heads are wider than the column's cells' contents, then you can just use column.sizeWidthToFit().
void initColumnSizes(JTable table,TableModel model)
TableColumn column=null;
Component comp=null;
int headerWidth=0,cellWidth=0;
Object[] longValues=(data.length>0)?data[0]:null;
TableCellRenderer headerRenderer=table.getTableHeader().getDefaultRenderer();
if (data.length<1) return;
for (int i=0;i<model.getColumnCount();i++)
column=table.getColumnModel().getColumn(i);
comp=headerRenderer.getTableCellRendererComponent(null,column.getHeaderValue(),false,false,0,0);
headerWidth=comp.getPreferredSize().width;
comp=table.getDefaultRenderer(model.getColumnClass(i)).
getTableCellRendererComponent(table,longValues[i],false,false,0,i);
cellWidth=comp.getPreferredSize().width;
switch (Preffered_Width)
case Max_Header_Cell_Width : column.setPreferredWidth(Math.max(headerWidth,cellWidth));break;
case Header_Width : column.setPreferredWidth(headerWidth);break;
case Cell_Width : column.setPreferredWidth(cellWidth);break;
Column_Width[i]=column.getPreferredWidth();
if (Debug) Out("Initializing width of column "+i+". "+"headerWidth="+headerWidth+"; cellWidth="+cellWidth+" Column_Width["+i+"]="+Column_Width[i]);
// Detects a state change in any of the Lists. Resets the variable corresponding to the selected item in a particular List. Invokes changeFont with the currently selected fontname, style and size attributes.
public void itemStateChanged(ItemEvent e)
Out(e.toString());
if (e.getStateChange() != ItemEvent.SELECTED) return;
Object list=e.getSource();
public static void Out(String message) { System.out.println(message); }
// Create the GUI and show it. For thread safety, this method should be invoked from the event-dispatching thread.
static void Create_And_Show_GUI()
boolean Demo_External_Table=true;
// boolean Demo_External_Table=false;
final Table_Panel demo;
String[] columnNames={"First Names","Last Names","Sport","Num of Years","Vegetarian"};
Object[][] data={{"Mary","Campione","Snowboarding"+"[123456789]",new Integer(5),new Boolean(false)},
{"Alison","Huml","Rowing"+":123456789]",new Integer(3),new Boolean(true)},
{"Frank","Ni","Running"+":123456789", new Integer(12), new Boolean(false)},
{"Kathy","Walrath","Chasing toddlers"+"<123456789>", new Integer(2), new Boolean(false)},
{"Mark", "Andrews","Speed reading",new Integer(20),new Boolean(true)},
{"Angela","Lih","Teaching high school",new Integer(36),new Boolean(false)} };
// Row_Color_Style=Row_Color_Style_Default;
// Row_Color_Style=Row_Color_Style_None;
// Row_Color_Style=Row_Color_Style_Blue_Gray;
Row_Color_Style=Row_Color_Style_Cyan_Gray;
// Row_Color_Style=Row_Color_Style_Blue;
// Row_Color_Style=Row_Color_Style_Gray;
// Row_Color_Style=Row_Color_Style_Red_Green;
// Row_Color_Style=Row_Color_Style_Green_Yellow;
// Row_Color_Style=Row_Color_Style_Red_Yellow;
Preffered_Width=Max_Header_Cell_Width;
if (Demo_External_Table) demo=new Table_Panel("External Table Demo",columnNames,data,data.length,false,Demo_External_Table,false,Row_Color_Style,Max_Header_Cell_Width,Default_Selection_Color,true);
else
JFrame Table_Frame=new JFrame("Internal Table Demo");
// demo=new Table_Panel(Nm_Lib.Dir_A_Test+"ELX.csv",false,Row_Color_Style,Preffered_Width,null);
// demo=new Table_Panel(Nm_Lib.Dir_Stock_Data+"ABV_Data.txt",false,Row_Color_Style,Preffered_Width," ");
demo=new Table_Panel("C:/Dir_Stock_Data/EOP.txt",",",false);
// demo=new Table_Panel(Nm_Lib.Dir_Stock_Data+"ABV_Data.txt"," ",false);
Table_Frame.getContentPane().add(demo.scrollPane);
Table_Frame.addWindowListener(new WindowAdapter()
public void windowActivated(WindowEvent e) { }
public void windowClosed(WindowEvent e) { }
public void windowClosing(WindowEvent e) { System.exit(0); }
public void windowDeactivated(WindowEvent e) { }
public void windowDeiconified(WindowEvent e) { demo.repaint(); }
public void windowGainedFocus(WindowEvent e) { demo.repaint(); }
public void windowIconified(WindowEvent e) { }
public void windowLostFocus(WindowEvent e) { }
public void windowOpening(WindowEvent e) { demo.repaint(); }
public void windowOpened(WindowEvent e) { }
public void windowResized(WindowEvent e) { demo.repaint(); }
public void windowStateChanged(WindowEvent e) { demo.repaint(); }
Table_Frame.pack();
Table_Frame.setBounds((Screen_Size.width-Table_Frame.getWidth())/2,(Screen_Size.height-Table_Frame.getHeight())/2,Table_Frame.getWidth(),Table_Frame.getHeight());
Table_Frame.setVisible(true);
public static void main(String[] args)
// Schedule a job for the event-dispatching thread : creating and showing this application's GUI.
SwingUtilities.invokeLater(new Runnable() { public void run() { Create_And_Show_GUI(); } });
* TableSorter is a decorator for TableModels; adding sorting functionality to a supplied TableModel. TableSorter does not store
* or copy the data in its TableModel; instead it maintains a map from the row indexes of the view to the row indexes of the
* model. As requests are made of the sorter (like getValueAt(row, col)) they are passed to the underlying model after the row numbers
* have been translated via the internal mapping array. This way, the TableSorter appears to hold another copy of the table
* with the rows in a different order.
* 
* TableSorter registers itself as a listener to the underlying model, just as the JTable itself would. Events recieved from the model
* are examined, sometimes manipulated (typically widened), and then passed on to the TableSorter's listeners (typically the JTable).
* If a change to the model has invalidated the order of TableSorter's rows, a note of this is made and the sorter will resort the
* rows the next time a value is requested.
* 
* When the tableHeader property is set, either by using the setTableHeader() method or the two argument constructor, the table
* header may be used as a complete UI for TableSorter. The default renderer of the tableHeader is decorated with a renderer
* that indicates the sorting status of each column. In addition, a mouse listener is installed with the following behavior:
* <ul>
* <li>
* Mouse-click: Clears the sorting status of all other columns and advances the sorting status of that column through three
* values: {NOT_SORTED, ASCENDING, DESCENDING} (then back to NOT_SORTED again).
* <li>
* SHIFT-mouse-click: Clears the sorting status of all other columns and cycles the sorting status of the column through the same
* three values, in the opposite order: {NOT_SORTED, DESCENDING, ASCENDING}.
* <li>
* CONTROL-mouse-click and CONTROL-SHIFT-mouse-click: as above except that the changes to the column do not cancel the statuses of columns
* that are already sorting - giving a way to initiate a compound sort.
* </ul>
* 
* This is a long overdue rewrite of a class of the same name that first appeared in the swing table demos in 1997.
* @author Philip Milne
* @author Brendon McLean
* @author Dan van Enckevort
* @author Parwinder Sekhon
* @version 2.0 02/27/04
class TableSorter extends AbstractTableModel
public static final long serialVersionUID=26362862L;
protected TableModel tableModel;
public static final int DESCENDING = -1;
public static final int NOT_SORTED = 0;
public static final int ASCENDING = 1;
private static Directive EMPTY_DIRECTIVE = new Directive(-1, NOT_SORTED);
public static final Comparator COMPARABLE_COMAPRATOR = new Comparator() { public int compare(Object o1, Object o2) { return ((Comparable) o1).compareTo(o2); } };
public static final Comparator LEXICAL_COMPARATOR = new Comparator() { public int compare(Object o1, Object o2) { return o1.toString().compareTo(o2.toString()); } };
private Row[] viewToModel;
private int[] modelToView;
private JTableHeader tableHeader;
private MouseListener mouseListener;
private TableModelListener tableModelListener;
private Map<Class,Comparator> columnComparators = new HashMap<Class,Comparator>();
private List<Directive> sortingColumns = new ArrayList<Directive>();
public TableSorter()
this.mouseListener = new MouseHandler();
this.tableModelListener = new TableModelHandler();
public TableSorter(TableModel tableModel)
this();
setTableModel(tableModel);
public TableSorter(TableModel tableModel, JTableHeader tableHeader)
this();
setTableHeader(tableHeader);
setTableModel(tableModel);
private void clearSortingState()
viewToModel = null;
modelToView = null;
public TableModel getTableModel() { return tableModel; }
public void setTableModel(TableModel tableModel)
if (this.tableModel != null) { this.tableModel.removeTableModelListener(tableModelListener); }
this.tableModel = tableModel;
if (this.tableModel != null) { this.tableModel.addTableModelListener(tableModelListener); }
clearSortingState();
fireTableStructureChanged();
public JTableHeader getTableHeader() { return tableHeader; }
public void setTableHeader(JTableHeader tableHeader)
if (this.tableHeader != null)
this.tableHeader.removeMouseListener(mouseListener);
TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();
if (defaultRenderer instanceof SortableHeaderRenderer) this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
this.tableHeader = tableHeader;
if (this.tableHeader != null)
this.tableHeader.addMouseListener(mouseListener);
this.tableHeader.setDefaultRenderer(
new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));
public boolean isSorting() { return sortingColumns.size() != 0; }
private Directive getDirective(int column)
for (int i = 0; i < sortingColumns.size(); i++)
Directive directive = (Directive)sortingColumns.get(i);
if (directive.column == column) { return directive; }
return EMPTY_DIRECTIVE;
public int getSortingStatus(int column) { return getDirective(column).direction; }
private void sortingStatusChanged()
clearSortingState();
fireTableDataChanged();
if (tableHeader != null) { tableHeader.repaint(); }
public void setSortingStatus(int column, int status)
Directive directive = getDirective(column);
if (directive != EMPTY_DIRECTIVE) { sortingColumns.remove(directive); }
if (status != NOT_SORTED) { sortingColumns.add(new Directive(column, status)); }
sortingStatusChanged();
protected Icon getHeaderRendererIcon(int column, int size)
Directive directive = getDirective(column);
if (directive == EMPTY_DIRECTIVE) { return null; }
return new Arrow(directive.direction == DESCENDING, size, sortingColumns.indexOf(directive));
private void cancelSorting()
sortingColumns.clear();
sortingStatusChanged();
public void setColumnComparator(Class type, Comparator comparator)
if (comparator == null) { columnComparators.remove(type); }
else { columnComparators.put(type, comparator); }
protected Comparator getComparator(int column)
Class columnType = tableModel.getColumnClass(column);
Comparator comparator = (Comparator) columnComparators.get(columnType);
if (comparator != null) { return comparator; }
if (Comparable.class.isAssignableFrom(columnType)) { return COMPARABLE_COMAPRATOR; }
return LEXICAL_COMPARATOR;
private Row[] getViewToModel()
if (viewToModel == null)
int tableModelRowCount = tableModel.getRowCount();
viewToModel = new Row[tableModelRowCount];
for (int row = 0; row < tableModelRowCount; row++) { viewToModel[row] = new Row(row); }
if (isSorting()) { Arrays.sort(viewToModel); }
return viewToModel;
public int modelIndex(int viewIndex) { return getViewToModel()[viewIndex].modelIndex; }
private int[] getModelToView()
if (modelToView == null)
int n = getViewToModel().length;
modelToView = new int[n];
for (int i = 0; i < n; i++) { modelToView[modelIndex(i)] = i; }
return modelToView;
// TableModel interface methods
public int getRowCount() { return (tableModel == null) ? 0 : tableModel.getRowCount(); }
public int getColumnCount() { return (tableModel == null) ? 0 : tableModel.getColumnCount(); }
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(modelIndex(row), column); }
public Object getValueAt(int row, int column) { return tableModel.getValueAt(modelIndex(row), column); }
public void setValueAt(Object aValue, int row, int column) { tableModel.setValueAt(aValue, modelIndex(row), column); }
// Helper classes
private class Row implements Comparable
private int modelIndex;
public Row(int index) { this.modelIndex = index; }
public int compareTo(Object o)
int row1 = modelIndex;
int row2 = ((Row) o).modelIndex;
for (Iterator it = sortingColumns.iterator(); it.hasNext();)
Directive directive = (Directive) it.next();
int column = directive.column;
Object o1 = tableModel.getValueAt(row1, column);
Object o2 = tableModel.getValueAt(row2, column);
int comparison = 0;
// Define null less than everything, except null.
if (o1 == null && o2 == null) { comparison = 0; }
else if (o1 == null) { comparison = -1; }
else if (o2 == null) { comparison = 1; }
else { comparison = getComparator(column).compare(o1, o2); }
if (comparison != 0) { return directive.direction == DESCENDING ? -comparison : comparison; }
return 0;
private class TableModelHandler implements TableModelListener
public void tableChanged(TableModelEvent e)
// If we're not sorting by anything

Problem with adding a new row in JTable

Hi,
I've created a JTable using DefaultTableModel with DefaultTableModel(Object[][] obj,Object[] col) constructor.I've written actionListener for a JButton which should add new row to the tablemodel.Now, the listener adds the row to the model.But its throwing an ArrayOutofBoundsException and the added row is not visible unless I click on any column of the table.
Kindly help me to resolve this problem
TIA
Regards
Gopi

Thanks a lot for the reply. Here is the complete code
TableImpl.java
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.table.*;
import java.util.Vector;
public class TableImpl extends JFrame {
DefaultTableModel dataModel; // TableModel Variable
/* Constructor to add table and button to the frame */
TableImpl() {
 getContentPane().setLayout(null);
 setSize(800,600);
 myModel();
 final JTable table = new JTable(dataModel);
 JScrollPane scrollpane = new JScrollPane(table);
 getContentPane().add(scrollpane);
 scrollpane.setBounds(10,10,700,300);
 TableColumn tcCol = table.getColumnModel().getColumn(1);
 /* Adding ComboBox to the CellEditor of Column 2 of table */
 JComboBox jcbComboBox = new JComboBox();
 final ReturnVector vctDBAccess = new ReturnVector();
 jcbComboBox.addItem(vctDBAccess.vctGetOidList().elementAt(0).toString());
 jcbComboBox.addItem(vctDBAccess.vctGetOidList().elementAt(2).toString());
 jcbComboBox.addItem(vctDBAccess.vctGetOidList().elementAt(4).toString());
 tcCol.setCellEditor(new DefaultCellEditor(jcbComboBox));
 /* Adding Listener for Table */
 dataModel.addTableModelListener(new TableModelListener() {
 public void tableChanged(TableModelEvent e) {
 /* Columns Manipulation */
 if(dataModel.getColumnName(e.getColumn()).equals("Second")) {
 int iRow = e.getFirstRow();
 int iColumn = e.getColumn();
 String strColName = dataModel.getColumnName(iColumn);
 String strData = (String)dataModel.getValueAt(iRow,iColumn);
 String strNextColumn = dataModel.getColumnName(iColumn+1);
 dataModel.setValueAt(vctDBAccess.vctGetOidList().elementAt(vctDBAccess.iGetIndex(strData)+1),iRow,iColumn+1);
 /* Adding button to Frame */
 JButton jbInsert = new JButton("Insert");
 /* Adding new row to the Tablemodel -- Probelm is here */
 jbInsert.addActionListener(new ActionListener(){
 public void actionPerformed(ActionEvent e){
 try {
 Object[] nrow = {"what", "ever", "you"};
 dataModel.addRow(nrow);
 }catch(Exception ex) {
 System.out.println("Exception at adding row = " + ex);
getContentPane().add(jbInsert);
jbInsert.setBounds(100,350,100,20);
addWindowListener(new WindowAdapter() {
 public void windowClosing(WindowEvent e) {
 System.exit(0);
 /* Method to initialise new tablemodel */
 public void myModel() {
 Object[][] data = { {new Integer(10),"two","three"},
 {new Integer(5),"two","three"},
 {new Integer(4),"two","three"},
 String[] col = { "First", "Second", "Third"};
 dataModel = new DefaultTableModel(data,col);
public static void main(String arg[]) {
 TableImpl ct = new TableImpl();
 ct.setVisible(true);
/* Class that returns a Vector of String for populating ComboBox entries and
 for getting the index of a particular element of the vector */
class ReturnVector {
 Vector vctOidName=null;
 ReturnVector() {
 this.vctOidName = new Vector();
 vAddOidList();
 public void vAddOidList() {
 String[] dbResult = { "system", "1.3.6.1.2.1.1" ,
 "interface", "1.3.6.1.2.1.2" ,
 "snmp", "1.3.6.1.2.1.3" };
 for(int i=0;i<dbResult.length;i++) {
 System.out.println("Value = " + dbResult);
 vctOidName.addElement(dbResult[i]);
 public Vector vctGetOidList() {
 return vctOidName;
 public int iGetIndex(String strData) {
 System.out.println("Index = " + vctOidName.indexOf(strData));
 return vctOidName.indexOf(strData);

Another JTable/buttons in cells query - event forwarding

Hi Everyone.
Apologies in advance for yet another thread on this subject. I realise this has been discussed a number of times but I can't find what seems like a definitive solution.
I understand what the fundamental issue is with putting JComponents in table cells - i.e. that the cells are rendered essentially as static visual entities, that they're not "components" as such and will not receive events.
I'd like to implement JButtons in table cells so that they behave as "normally" as possible - i.e. handle their own roll-over appearance, handle their own pressed appearance, and fire action events when pressed, with as little manual intervention in these mechanisms (e.g. in mouse listener code) as possible. I'm trying to do this by forwarding mouse events from the table to the button, but this doesn't seem to work as I'd hoped and I have various questions...
(Background: I have implemented JButton objects in the data model, and the getTableCellRendererComponent() method returns *(JButton)value*.)
My first question concerns the interception of mouse events. The usual technique would be to add a mouse listener and/or mouse motion listener to the table, and implement mouseClicked(), mousePressed() etc. However, can I override the table's processMouseEvent() and processMouseMotionEvent() methods instead, and from here forward events to buttons where appropriate, or process normally with super.processMouseEvent()? My motivation for doing this would be specifically not to invoke the super methods where events were forwarded to buttons - effectively consuming the event. Is this correct technique?
My second question concerns attempts to reproduce button roll-over appearances. The JTable is of course considered a single entity as far as mouse events are concerned, and MOUSE_ENTERED and MOUSE_EXITED events aren't generated as the pointer moves from cell to cell. Merely forwarding mouse events to buttons - which will mostly be MOUSE_MOVED events - seems to be insufficient and presumably the roll-over appearance change relies upon ENTERED and EXITED events occurring at the proper times.
I mimicked this behaviour in my override of processMouseMotionEvent() by calculating the value (i.e. JButton reference) of the cell under the mouse pointer, and if it wasn't the same as for the previous event, manually creating a MOUSE_ENTERED event and forwarding it to the new button. This seemed to work - the rollovers were happening (provided a table repaint() was performed), but it seemed to work without needing to explicitly sending a MOUSE_EXITED to the previous button before sending MOUSE_ENTERED to the new. I'm unclear why this is so - I was half-expecting both buttons to acquire the roll-over state, and they didn't.
Also, I had assumed that having taken care of this, I should forward MOUSE_MOVED events occurring within the confines of a cell's area to the button verbatim, but this seems to instantly cancel out any roll-over (visually the button would briefly flash a roll-over appearance as the pointer moved into its cell bounds). Why might this be so?
My last question is about the actual pressing of the button. I had hoped that forwarding MOUSE_CLICKED, MOUSE_PRESSED and MOUSE_RELEASED would cause the button to (a) acquire the button-pressed state, and (b) fire an action event to its action listeners. Neither of these things occur, and I don't understand why not.
In summary, is interception and forwarding of events like this a viable technique for implementing table cell buttons? The various solutions that a Google trawl throws up all reproduce button-pressing mechanics in varying degrees, some just detecting a click and calling some user function, others manually manipulating the button model in the mouse handler etc. If possible I'd like to avoid this, and leave as much processing as possible to the button's native code.
Thanks in advance for any suggestions received.
Regards,
A.

try to look on this
http://java.sun.com/docs/books/tutorial/uiswing/components/table.html#editrender

How to manipulate jtable cell?

Hi experts,
I created a jtable with a BC4J related to the jtable.
I do not know how to update a cell and how to insert a new row in the jtable.
Would someone please tell me where I can find the document about manipulating a jtable?

Have a look at the source code of JUNavigationBar. In that class, look for JUActionBinding(_buttons[BUTTON_FIRST] , bind, JUActionBinding.ACTION_FIRST, false);As you can see you will need the JUActionBinding class.

Some Java 6 quirks (JTable and non-proportional fonts)

Hi,
I just downloaded JDK 6 to check how hard it will be to replace Java 5 on our project. I realized it won't be painless =/
So far, the problems I found were:
1. one of our JTables simply stopped showing its content. It's a two-column table, with plain text cells. Weird thing is that we have much more complicated tables on the application, and they are all fine (detailed investigation still pending, I am just posting first impressions)
2. one of our "reports" is simply a JTextArea with fixed-width font (Courier), so that we can align text at specific positions just by inserting the right amount of spaces. Java 6 antialiased fonts somehow broke this, text can't be aligned anymore. Now, that's weird, antialiasing shouldn't mess with fixed-width fonts, just improve their rendering AFAIK.
Anyone else seeing similar behavior? Any tips?
Regards,
Andre

Create your GUI and start your app on the EDT. Also only do row manipulation on the EDT. Most Swing operations are not threadsafe and must be done on the EDT. If this app worked prior to Java 6, it was only by chance.
In other words:
1. Wrap your main() method's contents in a SwingUtilities.invokeLater().
2. Wrap your addRow(), removeRow(), JScrollBar.setValue() and any other GUI-related calls in a SwingUtilities.invokeLater().
Note that your Thread is so simple that it might be better to use a javax.swing.Timer instead of a Thread. Then your addRow() and removeRow() calls wouldn't need to be in SwingUtilities.invokeLater() since the Timer would only be called on the EDT.

Coloring row problem of JTable

Hi!
I'm the beginer and have a problem while coloring rows in my table. The problem is as follows:
i need to color the whole row when i click a single cell of this row. Everything is ok until i click another cell of another row. When i do it all the row between first and last clicked become colored!
I tryed manipulating table.setSelectionMode(i) - but nothing!
My very simple code:
DefaultTableCellRenderer renderer = new DefaultTableCellRenderer()
 public Component getTableCellRendererComponent(JTable table,Object value, boolean isSelected, boolean hasFocus, int row, int column)
 Component cell = super.getTableCellRendererComponent(table,value, isSelected, hasFocus, row, column);
 if (isSelected) {cell.setBackground(Color.LIGHT_GRAY);return cell;}
 return cell;
for(int i=0; i<table.getColumnCount(); i++)
 table.getColumnModel().getColumn(i).setCellRenderer(renderer);
Please help!
PS I cant use Ctrl button in my program because all the changes in table are in table.isEnable(false)-mode-it is the condition of my work.

Karl already gave the correct answer: once you touched any Color property of a DefaultTableCellRenderer, you have to do it always, that is in any of the logic branches. That's because DTCR has a nasty color "memory" which basically is the net result of inapproriate subclassing (no compelling reason for a renderer to-be a component) and frozen api (couldn't add a setRendererXXColor) at the particular moment of evolution when it was needed. (Our SwingX wiki about swingx renderer/highlighter support has more details)
BTW, if I interpret your code snippet correctly, you are after a different selection color for all columns? If so you can set that color globally for your table instance (hint: api doc is your friend :-), no need for a custom renderer.
HTH
Jeanette

JTable without JScrollPane behavior crippled

I want column width of JTable t1 goes parallel with the width resizing on
JTable t2. If tables are put in JScrollPanes, this has no problem. But if I put
those tables in simpler container, which is JPanel in this case, t2 shows a
funny behavior -- with user's mouse operation on t2 column, their width
never changes but t1 column width changes properly. Could I have
succeeded in communicating the funniness with these sentences?
Please try this code and give cause and solution if you could:
import java.awt.*;
import java.beans.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.event.*;
public class TableColumnWidthResize{
JFrame frame;
JTable t1, t2;
TableColumnModel tcm1, tcm2;
Enumeration columns1, columns2;
String[] t1h = {"Road", "Length", "City"};
String[][] t1c
   = {{"NW2", "800", "Dora"},
     {"Iban", "600", "Weiho"},
     {"ENE2", "500","Porso"}};
String[] t2h = {"Flower", "Curse", "Priest"};
String[][] t2c
    = {{"Fang", "7.00", "EggChar"},
      {"Shaoma", "5.00", "ScaCra"},
      {"Jiao", "4.00", "PorCabb"}};
public TableColumnWidthResize(){
    frame = new JFrame();
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Container con = frame.getContentPane();
    con.setLayout(new GridLayout(2, 1));
    t1 = new JTable(t1c, t1h); //target table -- 'resized from t2'
    t2 = new JTable(t2c, t2h); //source table -- 'initiate resize'
    t1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
    t2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
    /* you can compare two methods of table placement*/
    useScrollPane(t1, t2, con); //works fine
//    nouseScrollPane(t1, t2, con); //resize behavior weird
    frame.pack();
    frame.setVisible(true);
    tcm1 = t1.getColumnModel();
    tcm2 = t2.getColumnModel();
    columns2 = tcm2.getColumns(); // all columns of t2
    TableColumnListener tcl = new TableColumnListener();
    while (columns2.hasMoreElements()){
      TableColumn tc = (TableColumn)(columns2.nextElement());
      tc.addPropertyChangeListener(tcl);
class TableColumnListener implements PropertyChangeListener{
    // achieve 'interlocking-column-resizing' from t2 to t1
    public void propertyChange(PropertyChangeEvent pce){
      TableColumn tc = (TableColumn)(pce.getSource());
      int i = tc.getModelIndex();
      tcm1.getColumn(i).setPreferredWidth(tc.getWidth());
void useScrollPane(JTable ta, JTable tb, Container c){
    JScrollPane jsc1 = new JScrollPane(ta);
    ta.setPreferredScrollableViewportSize(new Dimension(225, 50));
    JScrollPane jsc2 = new JScrollPane(tb);
    tb.setPreferredScrollableViewportSize(new Dimension(225, 50));
    c.add(jsc1); c.add(jsc2);
void nouseScrollPane(JTable ta, JTable tb, Container c){
    JPanel p1 = new JPanel(); JPanel p2 = new JPanel();
    p1.setLayout(new BorderLayout());
    p2.setLayout(new BorderLayout());
    p1.add(ta.getTableHeader(), BorderLayout.PAGE_START);
    p2.add(tb.getTableHeader(), BorderLayout.PAGE_START);
    p1.add(ta, BorderLayout.CENTER);
    p2.add(tb, BorderLayout.CENTER);
    c.add(p1); c.add(p2);
public static void main(String[] args){
    new TableColumnWidthResize();
}

Hey hiwa,
I don't see anything mysterious going on. If you think about it, how many components can we resize at run-time/dynamically with a mouse - none, except for the columns in a JTable, Frames and Dialogs. Note the latter two are top level and answer to no-one (except the screen i guess).
If you have ever implemented a component that can be 'dragged' and manipulated by the mouse, have you ever done so outside, that is, not using a JScrollPane? I doubt it.
I do not think it has anything to do with mouse precision. Maybe you are just experiencing undefined behaviour, unreliable behaviour. I imagine the Swing team didn't bother themselves with a usage scenario that would yield lesser results for a simple task. Using AUTO_RESIZE_OFF and requesting more room than the Container has to offer may upset that containers LayoutManager i.e. their algorithms may contain code that will shrink child components to fit, or nab space from sibling components.
Basically, in my experience, how ever long it takes me to realise it, when Swing goes on the blink it is usually a programming error.
BTW, did my suggestion work ok?
Sorry if I come across forceful. I'm glad I read and tested your code - the synchronization effect will be very useful.
Warm regards,
Darren

Print JTable with multi line header

I need to print a JTable with multi line header, I want to know if I can use the method jTable.print(int, MessajeFormat, MessageFormat) by manipulation of the MessageFormat. How I can manipulate it?
Otherwise, How I can print this?

hi again,
To print pdf in a swing application you don't need servlet.jar.
You'll only need itext.jar and a printer connected to your pc.
Download the iText source code and unzip it. See the following classes:
com.lowagie.tools.LPR and com.lowagie.tools.BuildTutorial. This latter is the main class of a swing tool that you can run.
Silent Print:
You have only to embed this javascript code in your pdf:
writer.addJavaScript("this.print(false);", false);
                    document.add(new Chunk("Silent Auto Print"));Then, you have to send the document to the printer.
Google : java print pdf
http://forum.java.sun.com/thread.jspa?threadID=523898 or
http://www.exampledepot.com/egs/javax.print/pkg.html for printing task.
Under unix system, I used this:
                       String PRINTER = ...;
               try {
                    String cmd = "lp -d " + PRINTER + " " + PDF_PATH;
                    Runtime.getRuntime().exec(new String[] { "sh", "-c", cmd });
               } catch (Exception e) {
                             //handle the exception
                             e.printStackTrace();
               }hth

JTable (dynamic columns)

Well guys, voil� my problem...
I've a Person class, who has some methods to get the person information, like getName(), getAge(), getAdresse(), etc... I would display the information of all the persons in the diary in a JTable... Ok, it's all right, i made a class who extends AbstractModelTable, overriding the getValueAt(int, int) with a switch:
// private static final int COLUMN_NAME = 0;
// private static final int COLUMN_NAME = 1;
switch (column) {
 case COLUMN_NAME:
 return cols[rowIndex].getName();
 case COLUMN_AGE:
 return cols[rowIndex].getAge();
 default:
 return;
}The code it's something like that... I'm sorry i don't show the code, i've not the source here!
It works very fine!... But now, i want to let the user choose witch columns to display...
I made a lot of tries, but i could not get the solution... The only one thing I could, was to eliminate the columns with zero value in the conf file, but the headers were not in the correct order!... And there's another problem too, when I switch the columnIndex, if it equals to COLUMN_EMAIL = 15 means that JTree is getting the value of the 15th column, but if the user had removed the 2 column for example, the 15th column is not more the email column, it's the 15+1 columns :S... is it clair? I think it's a little difficult to explain, and as you see, i don't speak english very well :P...
Summary: I would create a class extending JTable with columns configurables, i mean, let the user choose witch columns should be showed... Any idea ?... I can avoid the JTable component, so If you've another solution, it will be ok...
Greetings and thank you guys...

Your requirement is very general so we can't give you an exact solution, but I can try explaining how JTable works.
The TableModel is used to store the data. The JTable is used to display the data. When a table is first created using a TableModel a TableColumnModel is created. Each TableColumn in the TableColumnModel maps directly to a column in the TableModel.
Now what happens if the user moves column 15 to the first column in the table? The data hasn't changed, only the view of the data has changed. So even though the column is in column 0 of the table, the data must still come from column 15 in the TableModel. The TableColumns of the TableColumnModel do the mapping for you so you don't need to worry about the reordering of columns.
However, if you have some code in your program that accesses the data directly, then you need to be aware of this situation. Fortunately JTable has some methods to make this mapping easy.
table.getValueAt(...) will get data from the requested column in the view of the table
table.getModel().getValueAt(...) will get data form the requested column in the TableModel.
You can also do the mapping between "view" and "model" columns using the methods:
table.convertColumnIndexToModel(...)
table.convertColumnIndexToView(...) So what does this mean with dynamic columns? Well, you would build your table normally, then you would remove the TableColumns from the TableColumnModel that the user does not want to see.
The following example is so code I wrote a while ago that will help in manipulating the TableColumnModel. Right click on the TableHeader to see the visible/hidden status of each column:
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
public class TableColumnManager implements MouseListener, ActionListener
 private static final String HIDDEN_COLUMN = "HiddenColumn:";
 // Reference to the Singleton instance of this class
 private static TableColumnManager singleton;
 * Use a private constructor so we can create a Singleton.
 private TableColumnManager()
 * Get the Singleton instance of the <code>TableColumnManager</code>.
 * @return the Singlton instance of <code>TableColumnManager</code>
 private static TableColumnManager getInstance()
 if (singleton == null)
 singleton = new TableColumnManager();
 return singleton;
 * Add support for the management of visible <code>TableColumns</code>
 * for a given <code>JTable</code>.
 * @param table the table to provide support for
 public static void install(JTable table)
 table.getTableHeader().addMouseListener( getInstance() );
 * Remove support for the management of visible <code>TableColumns</code>
 * for a given <code>JTable</code>.
 * @param table the table to remove support from
 public static void uninstall(JTable table)
 table.getTableHeader().removeMouseListener( getInstance() );
 * Hide a column from view in the table.
 * @param table the table from which the column is removed
 * @param modelColumn the column index from the TableModel
 * of the column to be removed
 public static void hideColumn(JTable table, int modelColumn)
 int viewColumn = table.convertColumnIndexToView( modelColumn );
 if (viewColumn != -1)
 TableColumn column = table.getColumnModel().getColumn(viewColumn);
 hideColumn(table, column);
 * Hide a column from view in the table.
 * @param table the table from which the column is removed
 * @param columnName the column name of the column to be removed
 public static void hideColumn(JTable table, String columnName)
 try
 TableColumnModel tcm = table.getColumnModel();
 int index = tcm.getColumnIndex( columnName );
 TableColumn column = tcm.getColumn( index );
 hideColumn(table, column);
 catch(IllegalArgumentException e) {}
 * Hide a column from view in the table.
 * @param table the table from which the column is removed
 * @param column the TableColumn to be removed from the
 * TableColumnModel of the specified table
 public static void hideColumn(JTable table, TableColumn column)
 table.getColumnModel().removeColumn( column );
 // Save the column so it can be redisplayed
 ArrayList list = (ArrayList)table.getClientProperty(HIDDEN_COLUMN);
 if (list == null)
 list = new ArrayList();
 table.putClientProperty(HIDDEN_COLUMN, list);
 list.add(column);
 * Show a hidden column in the table.
 * @param table the table to which the column is added
 * @param modelColumn the column index from the <code>TableModel</code>
 * of the column to be added
 public static void showColumn(JTable table, int modelColumn)
 ArrayList list = (ArrayList)table.getClientProperty(HIDDEN_COLUMN);
 if (list == null) return;
 ListIterator it = list.listIterator();
 while (it.hasNext())
 TableColumn column = (TableColumn)it.next();
 if (column.getModelIndex() == modelColumn)
 table.getColumnModel().addColumn( column );
 it.remove();
 break;
 * Show a hidden column in the table.
 * @param table the table to which the column is added
 * @param columnName the column name from the <code>TableModel</code>
 * of the column to be added
 public static void showColumn(JTable table, String columnName)
 ArrayList list = (ArrayList)table.getClientProperty(HIDDEN_COLUMN);
 if (list == null) return;
 ListIterator it = list.listIterator();
 while (it.hasNext())
 TableColumn column = (TableColumn)it.next();
 if (column.getHeaderValue().equals(columnName))
 table.getColumnModel().addColumn( column );
 it.remove();
 break;
 // Implement the MouseListener
 public void mousePressed(MouseEvent e)
 checkForPopup( e );
 public void mouseReleased(MouseEvent e)
 checkForPopup( e );
 public void mouseClicked(MouseEvent e) {}
 public void mouseEntered(MouseEvent e) {}
 public void mouseExited(MouseEvent e) {}
 private void checkForPopup(MouseEvent e)
 if (e.isPopupTrigger())
 JTableHeader header = (JTableHeader)e.getComponent();
 int column = header.columnAtPoint( e.getPoint() );
 showPopup(header.getTable(), column);
 * Show a hidden column in the table.
 * @param table the table to which the column is added
 * @param columnName the column name from the <code>TableModel</code>
 * of the column to be added
 public static void showPopup(JTable table, int tableColumn)
 int columns = table.getModel().getColumnCount();
 JCheckBoxMenuItem[] items = new JCheckBoxMenuItem[columns];
 // Create menu items for hidden columns
 ArrayList list = (ArrayList)table.getClientProperty(HIDDEN_COLUMN);
 if (list != null)
 ListIterator it = list.listIterator();
 while (it.hasNext())
 TableColumn column = (TableColumn)it.next();
 String columnName = column.getHeaderValue().toString();
 JCheckBoxMenuItem item = new JCheckBoxMenuItem( columnName );
 item.setSelected( false );
 item.addActionListener(getInstance());
 items[column.getModelIndex()] = item;
 // Create menu items for visible columns
 TableColumnModel columnModel = table.getColumnModel();
 int columnCount = columnModel.getColumnCount();
 for (int i = 0; i < columnCount; i++)
 TableColumn column = columnModel.getColumn(i);
 String columnName = column.getHeaderValue().toString();
 JCheckBoxMenuItem item = new JCheckBoxMenuItem( columnName );
 item.setSelected( true );
 item.addActionListener(getInstance());
 items[column.getModelIndex()] = item;
 // Create popup menu from array of menu items.
 // Override the setSelected method to select the
 // specified menu item. (ie. this is a bug fix)
 JPopupMenu popup = new JPopupMenu()
 public void setSelected(Component sel)
 int index = getComponentIndex( sel );
 getSelectionModel().setSelectedIndex(index);
 final MenuElement me[] = new MenuElement[2];
 me[0]=(MenuElement)this;
 me[1]=getSubElements()[index];
 SwingUtilities.invokeLater(new Runnable()
 public void run()
 MenuSelectionManager.defaultManager()
 .setSelectedPath(me);
 for (int i = 0; i < items.length; i++)
 if (items[i] != null)
 popup.add( items[i] );
 // Display the popup below the TableHeader
 JTableHeader header = table.getTableHeader();
 Rectangle r = header.getHeaderRect( tableColumn );
 popup.show(header, r.x, r.height);
 int modelColumn = table.convertColumnIndexToModel( tableColumn );
 popup.setSelected( items[modelColumn] );
 * Responsible for processing the ActionEvent. A column will either be
 * added to the table or removed from the table depending on the state
 * of the menu item that was clicked.
 * @param event the ActionEvent.
 public void actionPerformed(ActionEvent event)
 JMenuItem item = (JMenuItem)event.getSource();
 JPopupMenu popup = (JPopupMenu)item.getParent();
 JTableHeader header = (JTableHeader)popup.getInvoker();
 JTable table = header.getTable();
 if (item.isSelected())
 showColumn(table, item.getText());
 else
 hideColumn(table, item.getText());
 public static void main(String[] args)
 JTable table = new JTable( new DefaultTableModel(5, 10) );
 TableColumnManager.install(table);
 TableColumnManager.hideColumn(table, 2);
 TableColumnManager.hideColumn(table, "E");
 JFrame frame = new JFrame();
 frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
 frame.getContentPane().add( new JScrollPane(table) );
 frame.pack();
 frame.setVisible( true );
}Hopefully I've made some sense.

How to display/render JTable?

Can anyone show me how to display/render a JTable with most compact codes.
Just set size, Scrollable. No need for manipulation, or others.
JTable has been created:
JTable table = new JTable(rows, columns);
I have read the tutorial: http://java.sun.com/docs/books/tutorial/uiswing/components/table.html#editrender
But they are still really complex. I do not need many functions, just display.
Thx

xcomme wrote:
I have tried for hours:
table.setPreferredScrollableViewportSize(new Dimension(300, 80));
table.setGridColor(Color.black);
table.setVisible(true);
None of them works.
A JTable is a Swing component. Swing components have to be displayed as children of a frame object, typically JFrame, JDialog or the like. JTable, in particular, really expects to be part of a JScrollPane component. If you try and display it without you won't get a header.
The minimal steps to see a JTable:
Create a JFrame object set it's size and position with setBounds(). Get it's content pane with getContentPane()
Set a layout manager, I suggest a BorderLayoutManager to start with, it's about the simplest to use.
Create your JTable
Wrap it in a JScrollPane.
Add the JScrollPane to the content pane. Use BorderLayout.CENTER as the second argument of the add.
Call setVisible(true) on the JFrame.
The standard way to organise this is to create a subclass of JFrame and set up the content in the constructor or an initGui method.

JTable manipulation

Similar Messages

Maybe you are looking for