package javax.swing;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.util.Hashtable;
import java.util.Vector;
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleContext;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.event.TableColumnModelListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.plaf.TableUI;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableColumnModel;
import javax.swing.table.DefaultTableModel;
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.table.TableModel;
public class JTable extends JComponent
implements TableModelListener, Scrollable, TableColumnModelListener,
ListSelectionListener, CellEditorListener, Accessible
{
private static final long serialVersionUID = 3876025080382781659L;
public static final int AUTO_RESIZE_OFF = 0;
public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
public static final int AUTO_RESIZE_LAST_COLUMN = 3;
protected Hashtable defaultEditorsByColumnClass;
protected Hashtable defaultRenderersByColumnClass;
protected int editingColumn;
protected int editingRow;
protected transient Component editorComp;
protected boolean autoCreateColumnsFromModel;
protected int autoResizeMode;
protected int rowHeight;
protected int rowMargin;
protected boolean rowSelectionAllowed;
protected boolean cellSelectionEnabled;
protected TableModel dataModel;
protected TableColumnModel columnModel;
protected ListSelectionModel selectionModel;
protected AccessibleContext accessibleContext;
protected TableCellEditor cellEditor;
private boolean dragEnabled;
protected Color gridColor;
protected Dimension preferredViewportSize;
protected Color selectionBackground;
private static final String SELECTION_BACKGROUND_CHANGED_PROPERTY = "selectionBackground";
protected Color selectionForeground;
private static final String SELECTION_FOREGROUND_CHANGED_PROPERTY = "selectionForeground";
protected boolean showHorizontalLines;
protected boolean showVerticalLines;
protected JTableHeader tableHeader;
public JTable ()
{
this(null, null, null);
}
public JTable (int numRows, int numColumns)
{
this(new DefaultTableModel(numRows, numColumns));
}
public JTable(Object[][] data, Object[] columnNames)
{
this(new DefaultTableModel(data, columnNames));
}
public JTable (TableModel dm)
{
this(dm, null, null);
}
public JTable (TableModel dm, TableColumnModel cm)
{
this(dm, cm, null);
}
public JTable (TableModel dm, TableColumnModel cm, ListSelectionModel sm)
{
this.dataModel = dm == null ? createDefaultDataModel() : dm;
setSelectionModel(sm == null ? createDefaultSelectionModel() : sm);
this.columnModel = cm;
initializeLocalVars();
updateUI();
}
protected void initializeLocalVars()
{
this.autoCreateColumnsFromModel = false;
if (columnModel == null)
{
this.autoCreateColumnsFromModel = true;
createColumnsFromModel();
}
this.columnModel.addColumnModelListener(this);
this.defaultRenderersByColumnClass = new Hashtable();
createDefaultRenderers();
this.defaultEditorsByColumnClass = new Hashtable();
createDefaultEditors();
this.autoResizeMode = AUTO_RESIZE_ALL_COLUMNS;
this.rowHeight = 16;
this.rowMargin = 1;
this.rowSelectionAllowed = true;
this.cellEditor = null;
this.dragEnabled = false;
this.preferredViewportSize = new Dimension(450,400);
this.showHorizontalLines = true;
this.showVerticalLines = true;
this.editingColumn = -1;
this.editingRow = -1;
setIntercellSpacing(new Dimension(1,1));
setTableHeader(createDefaultTableHeader());
}
public JTable(Vector data, Vector columnNames)
{
this(new DefaultTableModel(data, columnNames));
}
public void addColumn(TableColumn column)
{
if (column.getHeaderValue() == null)
{
String name = getColumnName(column.getModelIndex());
column.setHeaderValue(name);
}
columnModel.addColumn(column);
}
protected void createDefaultEditors()
{
}
protected void createDefaultRenderers()
{
}
public static JScrollPane createScrollPaneForTable(JTable table)
{
return new JScrollPane(table);
}
protected TableColumnModel createDefaultColumnModel()
{
return new DefaultTableColumnModel();
}
protected TableModel createDefaultDataModel()
{
return new DefaultTableModel();
}
protected ListSelectionModel createDefaultSelectionModel()
{
return new DefaultListSelectionModel();
}
protected JTableHeader createDefaultTableHeader()
{
return new JTableHeader(columnModel);
}
private void createColumnsFromModel()
{
if (dataModel == null)
return;
TableColumnModel cm = createDefaultColumnModel();
for (int i = 0; i < dataModel.getColumnCount(); ++i)
{
cm.addColumn(new TableColumn(i));
}
this.setColumnModel(cm);
}
public void columnAdded (TableColumnModelEvent event)
{
revalidate();
repaint();
}
public void columnMarginChanged (ChangeEvent event)
{
revalidate();
repaint();
}
public void columnMoved (TableColumnModelEvent event)
{
revalidate();
repaint();
}
public void columnRemoved (TableColumnModelEvent event)
{
revalidate();
repaint();
}
public void columnSelectionChanged (ListSelectionEvent event)
{
repaint();
}
public void editingCanceled (ChangeEvent event)
{
repaint();
}
public void editingStopped (ChangeEvent event)
{
repaint();
}
public void tableChanged (TableModelEvent event)
{
repaint();
}
public void valueChanged (ListSelectionEvent event)
{
repaint();
}
public int columnAtPoint(Point point)
{
int x0 = getLocation().x;
int ncols = getColumnCount();
Dimension gap = getIntercellSpacing();
TableColumnModel cols = getColumnModel();
int x = point.x;
for (int i = 0; i < ncols; ++i)
{
int width = cols.getColumn(i).getWidth() + (gap == null ? 0 : gap.width);
if (0 <= x && x < width)
return i;
x -= width;
}
return -1;
}
public int rowAtPoint(Point point)
{
int y0 = getLocation().y;
int nrows = getRowCount();
Dimension gap = getIntercellSpacing();
int height = getRowHeight() + (gap == null ? 0 : gap.height);
int y = point.y;
for (int i = 0; i < nrows; ++i)
{
if (0 <= y && y < height)
return i;
y -= height;
}
return -1;
}
public Rectangle getCellRect(int row,
int column,
boolean includeSpacing)
{
int height = getHeight();
int width = columnModel.getColumn(column).getWidth();
int x_gap = columnModel.getColumnMargin();
int y_gap = rowMargin;
column = Math.max(0, Math.min(column, getColumnCount() - 1));
row = Math.max(0, Math.min(row, getRowCount() - 1));
int x = 0;
int y = (height + y_gap) * row;
for (int i = 0; i < column; ++i)
{
x += columnModel.getColumn(i).getWidth();
x += x_gap;
}
if (includeSpacing)
return new Rectangle(x, y, width, height);
else
return new Rectangle(x, y, width - x_gap, height - y_gap);
}
public void clearSelection()
{
selectionModel.clearSelection();
}
public int getSelectedRow ()
{
return selectionModel.getMinSelectionIndex();
}
public ListSelectionModel getSelectionModel()
{
if (! rowSelectionAllowed)
return null;
return selectionModel;
}
public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction)
{
if (orientation == SwingConstants.VERTICAL)
return visibleRect.height * direction;
else
return visibleRect.width * direction;
}
public boolean getScrollableTracksViewportHeight()
{
return false;
}
public boolean getScrollableTracksViewportWidth()
{
if (autoResizeMode == AUTO_RESIZE_OFF)
return false;
else
return true;
}
public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction)
{
if (orientation == SwingConstants.VERTICAL)
return rowHeight;
else
{
int sum = 0;
for (int i = 0; i < getColumnCount(); ++i)
sum += columnModel.getColumn(0).getWidth();
return getColumnCount() == 0 ? 10 : sum / getColumnCount();
}
}
public TableCellEditor getCellEditor(int row, int column)
{
TableCellEditor editor = columnModel.getColumn(column).getCellEditor();
if (editor == null)
editor = getDefaultEditor(dataModel.getColumnClass(column));
return editor;
}
public TableCellEditor getDefaultEditor(Class columnClass)
{
if (defaultEditorsByColumnClass.containsKey(columnClass))
return (TableCellEditor) defaultEditorsByColumnClass.get(columnClass);
else
{
TableCellEditor r = new DefaultCellEditor(new JTextField());
defaultEditorsByColumnClass.put(columnClass, r);
return r;
}
}
public TableCellRenderer getCellRenderer(int row, int column)
{
TableCellRenderer renderer =
columnModel.getColumn(column).getCellRenderer();
if (renderer == null)
renderer = getDefaultRenderer(dataModel.getColumnClass(column));
return renderer;
}
public void setDefaultRenderer(Class columnClass, TableCellRenderer rend)
{
defaultRenderersByColumnClass.put(columnClass, rend);
}
public TableCellRenderer getDefaultRenderer(Class columnClass)
{
if (defaultRenderersByColumnClass.containsKey(columnClass))
return (TableCellRenderer) defaultRenderersByColumnClass.get(columnClass);
else
{
TableCellRenderer r = new DefaultTableCellRenderer();
defaultRenderersByColumnClass.put(columnClass, r);
return r;
}
}
public int convertColumnIndexToModel(int vc)
{
if (vc < 0)
return vc;
else if (vc > getColumnCount())
return -1;
else
return columnModel.getColumn(vc).getModelIndex();
}
public int convertColumnIndexToView(int mc)
{
if (mc < 0)
return mc;
int ncols = getColumnCount();
for (int vc = 0; vc < ncols; ++vc)
{
if (columnModel.getColumn(vc).getModelIndex() == mc)
return vc;
}
return -1;
}
public Component prepareRenderer(TableCellRenderer renderer,
int row,
int column)
{
boolean rsa = getRowSelectionAllowed();
boolean csa = getColumnSelectionAllowed();
boolean rs = rsa ? getSelectionModel().isSelectedIndex(row) : false;
boolean cs = csa ? columnModel.getSelectionModel().isSelectedIndex(column) : false;
boolean isSelected = ((rsa && csa && rs && cs)
|| (rsa && !csa && rs)
|| (!rsa && csa && cs));
return renderer.getTableCellRendererComponent(this,
dataModel.getValueAt(row,
convertColumnIndexToModel(column)),
isSelected,
false, row, column);
}
public boolean getAutoCreateColumnsFromModel()
{
return autoCreateColumnsFromModel;
}
public int getAutoResizeMode()
{
return autoResizeMode;
}
public int getRowHeight()
{
return rowHeight;
}
public int getRowMargin()
{
return rowMargin;
}
public boolean getRowSelectionAllowed()
{
return rowSelectionAllowed;
}
public boolean getCellSelectionEnabled()
{
return getColumnSelectionAllowed() && getRowSelectionAllowed();
}
public TableModel getModel()
{
return dataModel;
}
public int getColumnCount()
{
return columnModel.getColumnCount();
}
public int getRowCount()
{
return dataModel.getRowCount();
}
public TableColumnModel getColumnModel()
{
return columnModel;
}
public int getSelectedColumn()
{
return columnModel.getSelectionModel().getMinSelectionIndex();
}
private static int countSelections(ListSelectionModel lsm)
{
int lo = lsm.getMinSelectionIndex();
int hi = lsm.getMaxSelectionIndex();
int sum = 0;
if (lo != -1 && hi != -1)
{
switch (lsm.getSelectionMode())
{
case ListSelectionModel.SINGLE_SELECTION:
sum = 1;
break;
case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
sum = hi - lo + 1;
break;
case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
for (int i = lo; i <= hi; ++i)
if (lsm.isSelectedIndex(i))
++sum;
break;
}
}
return sum;
}
private static int[] getSelections(ListSelectionModel lsm)
{
int sz = countSelections(lsm);
int [] ret = new int[sz];
int lo = lsm.getMinSelectionIndex();
int hi = lsm.getMaxSelectionIndex();
int j = 0;
java.util.ArrayList ls = new java.util.ArrayList();
if (lo != -1 && hi != -1)
{
switch (lsm.getSelectionMode())
{
case ListSelectionModel.SINGLE_SELECTION:
ret[0] = lo;
break;
case ListSelectionModel.SINGLE_INTERVAL_SELECTION:
for (int i = lo; i <= hi; ++i)
ret[j++] = i;
break;
case ListSelectionModel.MULTIPLE_INTERVAL_SELECTION:
for (int i = lo; i <= hi; ++i)
if (lsm.isSelectedIndex(i))
ret[j++] = i;
break;
}
}
return ret;
}
public int getSelectedColumnCount()
{
return countSelections(columnModel.getSelectionModel());
}
public int[] getSelectedColumns()
{
return getSelections(columnModel.getSelectionModel());
}
public boolean getColumnSelectionAllowed()
{
return getColumnModel().getColumnSelectionAllowed();
}
public int getSelectedRowCount()
{
return countSelections(selectionModel);
}
public int[] getSelectedRows()
{
return getSelections(selectionModel);
}
public AccessibleContext getAccessibleContext()
{
return accessibleContext;
}
public TableCellEditor getCellEditor()
{
return cellEditor;
}
public boolean getDragEnabled()
{
return dragEnabled;
}
public Color getGridColor()
{
return gridColor;
}
public Dimension getIntercellSpacing()
{
return new Dimension(columnModel.getColumnMargin(), rowMargin);
}
public Dimension getPreferredScrollableViewportSize()
{
return preferredViewportSize;
}
public Color getSelectionBackground()
{
return selectionBackground;
}
public Color getSelectionForeground()
{
return selectionForeground;
}
public boolean getShowHorizontalLines()
{
return showHorizontalLines;
}
public boolean getShowVerticalLines()
{
return showVerticalLines;
}
public JTableHeader getTableHeader()
{
return tableHeader;
}
public void removeColumn(TableColumn column)
{
columnModel.removeColumn(column);
}
public void moveColumn(int column,int targetColumn)
{
columnModel.moveColumn(column, targetColumn);
}
public void setAutoCreateColumnsFromModel(boolean a)
{
autoCreateColumnsFromModel = a;
}
public void setAutoResizeMode(int a)
{
autoResizeMode = a;
revalidate();
repaint();
}
public void setRowHeight(int r)
{
if (rowHeight < 1)
throw new IllegalArgumentException();
rowHeight = r;
revalidate();
repaint();
}
public void setRowMargin(int r)
{
rowMargin = r;
revalidate();
repaint();
}
public void setRowSelectionAllowed(boolean r)
{
rowSelectionAllowed = r;
repaint();
}
public void setCellSelectionEnabled(boolean c)
{
setColumnSelectionAllowed(c);
setRowSelectionAllowed(c);
cellSelectionEnabled = true;
}
public void setModel(TableModel m)
{
if (m == null)
throw new IllegalArgumentException();
if (dataModel == m)
return;
if (dataModel != null)
dataModel.removeTableModelListener(this);
if (m != null)
{
dataModel = m;
dataModel.addTableModelListener(this);
if (autoCreateColumnsFromModel)
createColumnsFromModel();
}
revalidate();
repaint();
}
public void setColumnModel(TableColumnModel c)
{
if (c == null)
throw new IllegalArgumentException();
TableColumnModel tmp = columnModel;
if (tmp != null)
tmp.removeColumnModelListener(this);
if (c != null)
c.addColumnModelListener(this);
columnModel = c;
if (dataModel != null && columnModel != null)
{
int ncols = getColumnCount();
for (int i = 0; i < ncols; ++i)
columnModel.getColumn(i).setHeaderValue(dataModel.getColumnName(i));
}
revalidate();
repaint();
}
public void setColumnSelectionAllowed(boolean c)
{
getColumnModel().setColumnSelectionAllowed(c);
repaint();
}
public void setSelectionModel(ListSelectionModel s)
{
if (s == null)
throw new IllegalArgumentException();
ListSelectionModel tmp = selectionModel;
if (tmp != null)
tmp.removeListSelectionListener(this);
if (s != null)
s.addListSelectionListener(this);
selectionModel = s;
}
public void setSelectionMode(int s)
{
selectionModel.setSelectionMode(s);
columnModel.getSelectionModel().setSelectionMode(s);
repaint();
}
public void setCellEditor(TableCellEditor c)
{
TableCellEditor tmp = cellEditor;
if (tmp != null)
tmp.removeCellEditorListener(this);
if (c != null)
c.addCellEditorListener(this);
cellEditor = c;
}
public void setDragEnabled(boolean d)
{
dragEnabled = d;
}
public void setGridColor(Color g)
{
gridColor = g;
repaint();
}
public void setIntercellSpacing(Dimension i)
{
rowMargin = i.height;
columnModel.setColumnMargin(i.width);
repaint();
}
public void setPreferredScrollableViewportSize(Dimension p)
{
preferredViewportSize = p;
revalidate();
repaint();
}
public void setSelectionBackground(Color s)
{
Color tmp = selectionBackground;
selectionBackground = s;
if (((tmp == null && s != null)
|| (s == null && tmp != null)
|| (tmp != null && s != null && !tmp.equals(s))))
firePropertyChange(SELECTION_BACKGROUND_CHANGED_PROPERTY, tmp, s);
repaint();
}
public void setSelectionForeground(Color s)
{
Color tmp = selectionForeground;
selectionForeground = s;
if (((tmp == null && s != null)
|| (s == null && tmp != null)
|| (tmp != null && s != null && !tmp.equals(s))))
firePropertyChange(SELECTION_FOREGROUND_CHANGED_PROPERTY, tmp, s);
repaint();
}
public void setShowGrid(boolean s)
{
setShowVerticalLines(s);
setShowHorizontalLines(s);
}
public void setShowHorizontalLines(boolean s)
{
showHorizontalLines = s;
repaint();
}
public void setShowVerticalLines(boolean s)
{
showVerticalLines = s;
repaint();
}
public void setTableHeader(JTableHeader t)
{
if (tableHeader != null)
tableHeader.setTable(null);
tableHeader = t;
if (tableHeader != null)
tableHeader.setTable(this);
revalidate();
repaint();
}
protected void configureEnclosingScrollPane()
{
JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
if (jsp != null && tableHeader != null)
{
jsp.setColumnHeaderView(tableHeader);
}
}
protected void unconfigureEnclosingScrollPane()
{
JScrollPane jsp = (JScrollPane) SwingUtilities.getAncestorOfClass(JScrollPane.class, this);
if (jsp != null)
{
jsp.setColumnHeaderView(null);
}
}
public void addNotify()
{
super.addNotify();
configureEnclosingScrollPane();
}
public void removeNotify()
{
super.addNotify();
unconfigureEnclosingScrollPane();
}
private void distributeSpill(TableColumn[] cols, int spill)
{
int MIN = 0;
int MAX = 0;
int PREF = 0;
int[] min = new int[cols.length];
int[] max = new int[cols.length];
int[] pref = new int[cols.length];
for (int i = 0; i < cols.length; ++i)
{
pref[i] = cols[i].getPreferredWidth();
min[i] = cols[i].getMinWidth();
max[i] = cols[i].getMaxWidth();
PREF += pref[i];
MIN += min[i];
MAX += max[i];
}
for (int i = 0; i < cols.length; ++i)
{
int adj = 0;
if (spill > 0)
adj = (spill * (pref[i] - min[i])) / (PREF - MIN);
else
adj = (spill * (max[i] - pref[i])) / (MAX - PREF);
cols[i].setWidth(pref[i] + adj);
}
}
public void doLayout()
{
TableColumn resizingColumn = null;
int ncols = getColumnCount();
if (ncols < 1)
return;
int[] pref = new int[ncols];
int prefSum = 0;
int rCol = -1;
if (tableHeader != null)
resizingColumn = tableHeader.getResizingColumn();
for (int i = 0; i < ncols; ++i)
{
TableColumn col = columnModel.getColumn(i);
int p = col.getWidth();
pref[i] = p;
prefSum += p;
if (resizingColumn == col)
rCol = i;
}
int spill = prefSum - getWidth();
if (resizingColumn != null)
{
TableColumn col;
TableColumn [] cols;
switch (getAutoResizeMode())
{
case AUTO_RESIZE_LAST_COLUMN:
col = columnModel.getColumn(ncols-1);
col.setWidth(col.getPreferredWidth() + spill);
break;
case AUTO_RESIZE_NEXT_COLUMN:
col = columnModel.getColumn(ncols-1);
col.setWidth(col.getPreferredWidth() + spill);
break;
case AUTO_RESIZE_ALL_COLUMNS:
cols = new TableColumn[ncols];
for (int i = 0; i < ncols; ++i)
cols[i] = columnModel.getColumn(i);
distributeSpill(cols, spill);
break;
case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
cols = new TableColumn[ncols];
for (int i = rCol; i < ncols; ++i)
cols[i] = columnModel.getColumn(i);
distributeSpill(cols, spill);
break;
case AUTO_RESIZE_OFF:
default:
}
}
else
{
TableColumn [] cols = new TableColumn[ncols];
for (int i = 0; i < ncols; ++i)
cols[i] = columnModel.getColumn(i);
distributeSpill(cols, spill);
}
}
public void sizeColumnsToFit(boolean lastColumnOnly)
{
doLayout();
}
public void sizeColumnsToFit(int resizingColumn)
{
doLayout();
}
public String getUIClassID()
{
return "TableUI";
}
public TableUI getUI()
{
return (TableUI) ui;
}
public void setUI(TableUI ui)
{
super.setUI(ui);
}
public void updateUI()
{
setUI((TableUI) UIManager.getUI(this));
revalidate();
repaint();
}
public Class getColumnClass(int column)
{
return dataModel.getColumnClass(column);
}
public String getColumnName(int column)
{
return dataModel.getColumnName(column);
}
public int getEditingColumn()
{
return editingColumn;
}
public void setEditingColumn(int column)
{
editingColumn = column;
}
public int getEditingRow()
{
return editingRow;
}
public void setEditingRow(int column)
{
editingRow = column;
}
public Component getEditorComponent()
{
return editorComp;
}
public boolean isEditing()
{
return editorComp != null;
}
public void setDefaultEditor(Class columnClass, TableCellEditor editor)
{
if (editor != null)
defaultEditorsByColumnClass.put(columnClass, editor);
else
defaultEditorsByColumnClass.remove(columnClass);
}
public void addColumnSelectionInterval(int index0, int index1)
{
if ((index0 < 0 || index0 > (getColumnCount()-1)
|| index1 < 0 || index1 > (getColumnCount()-1)))
throw new IllegalArgumentException("Column index out of range.");
getColumnModel().getSelectionModel().addSelectionInterval(index0, index1);
}
public void addRowSelectionInterval(int index0, int index1)
{
if ((index0 < 0 || index0 > (getRowCount()-1)
|| index1 < 0 || index1 > (getRowCount()-1)))
throw new IllegalArgumentException("Row index out of range.");
getSelectionModel().addSelectionInterval(index0, index1);
}
public void setColumnSelectionInterval(int index0, int index1)
{
if ((index0 < 0 || index0 > (getColumnCount()-1)
|| index1 < 0 || index1 > (getColumnCount()-1)))
throw new IllegalArgumentException("Column index out of range.");
getColumnModel().getSelectionModel().setSelectionInterval(index0, index1);
}
public void setRowSelectionInterval(int index0, int index1)
{
if ((index0 < 0 || index0 > (getRowCount()-1)
|| index1 < 0 || index1 > (getRowCount()-1)))
throw new IllegalArgumentException("Row index out of range.");
getSelectionModel().setSelectionInterval(index0, index1);
}
public void removeColumnSelectionInterval(int index0, int index1)
{
if ((index0 < 0 || index0 > (getColumnCount()-1)
|| index1 < 0 || index1 > (getColumnCount()-1)))
throw new IllegalArgumentException("Column index out of range.");
getColumnModel().getSelectionModel().removeSelectionInterval(index0, index1);
}
public void removeRowSelectionInterval(int index0, int index1)
{
if ((index0 < 0 || index0 > (getRowCount()-1)
|| index1 < 0 || index1 > (getRowCount()-1)))
throw new IllegalArgumentException("Row index out of range.");
getSelectionModel().removeSelectionInterval(index0, index1);
}
public boolean isColumnSelected(int column)
{
return getColumnModel().getSelectionModel().isSelectedIndex(column);
}
public boolean isRowSelected(int row)
{
return getSelectionModel().isSelectedIndex(row);
}
public boolean isCellSelected(int row, int column)
{
return isRowSelected(row) && isColumnSelected(column);
}
public void selectAll()
{
setColumnSelectionInterval(0, getColumnCount() - 1);
setRowSelectionInterval(0, getRowCount() - 1);
}
public Object getValueAt(int row, int column)
{
return dataModel.getValueAt(row, convertColumnIndexToModel(column));
}
public void setValueAt(Object value, int row, int column)
{
dataModel.setValueAt(value, row, convertColumnIndexToModel(column));
}
public TableColumn getColumn(Object identifier)
{
return columnModel.getColumn(columnModel.getColumnIndex(identifier));
}
}