| /* |
| * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * - Neither the name of Oracle nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS |
| * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /* |
| * This source code is provided to illustrate the usage of a given feature |
| * or technique and has been deliberately simplified. Additional steps |
| * required for a production-quality application, such as security checks, |
| * input validation and proper error handling, might not be present in |
| * this sample code. |
| */ |
| |
| |
| |
| import java.util.EventObject; |
| import java.util.List; |
| import javax.swing.JTable; |
| import javax.swing.table.DefaultTableModel; |
| import javax.swing.table.TableCellEditor; |
| import javax.swing.table.TableCellRenderer; |
| import javax.swing.table.TableColumn; |
| |
| |
| /** |
| * The OldJTable is an unsupported class containing some methods that were |
| * deleted from the JTable between releases 0.6 and 0.7 |
| */ |
| @SuppressWarnings("serial") |
| public class OldJTable extends JTable |
| { |
| /* |
| * A new convenience method returning the index of the column in the |
| * co-ordinate space of the view. |
| */ |
| public int getColumnIndex(Object identifier) { |
| return getColumnModel().getColumnIndex(identifier); |
| } |
| |
| // |
| // Methods deleted from the JTable because they only work with the |
| // DefaultTableModel. |
| // |
| |
| public TableColumn addColumn(Object columnIdentifier, int width) { |
| return addColumn(columnIdentifier, width, null, null, null); |
| } |
| |
| public TableColumn addColumn(Object columnIdentifier, List columnData) { |
| return addColumn(columnIdentifier, -1, null, null, columnData); |
| } |
| |
| // Override the new JTable implementation - it will not add a column to the |
| // DefaultTableModel. |
| public TableColumn addColumn(Object columnIdentifier, int width, |
| TableCellRenderer renderer, |
| TableCellEditor editor) { |
| return addColumn(columnIdentifier, width, renderer, editor, null); |
| } |
| |
| public TableColumn addColumn(Object columnIdentifier, int width, |
| TableCellRenderer renderer, |
| TableCellEditor editor, List columnData) { |
| checkDefaultTableModel(); |
| |
| // Set up the model side first |
| DefaultTableModel m = (DefaultTableModel)getModel(); |
| m.addColumn(columnIdentifier, columnData.toArray()); |
| |
| // The column will have been added to the end, so the index of the |
| // column in the model is the last element. |
| TableColumn newColumn = new TableColumn( |
| m.getColumnCount()-1, width, renderer, editor); |
| super.addColumn(newColumn); |
| return newColumn; |
| } |
| |
| // Not possilble to make this work the same way ... change it so that |
| // it does not delete columns from the model. |
| public void removeColumn(Object columnIdentifier) { |
| super.removeColumn(getColumn(columnIdentifier)); |
| } |
| |
| public void addRow(Object[] rowData) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).addRow(rowData); |
| } |
| |
| public void addRow(List rowData) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).addRow(rowData.toArray()); |
| } |
| |
| public void removeRow(int rowIndex) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).removeRow(rowIndex); |
| } |
| |
| public void moveRow(int startIndex, int endIndex, int toIndex) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).moveRow(startIndex, endIndex, toIndex); |
| } |
| |
| public void insertRow(int rowIndex, Object[] rowData) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).insertRow(rowIndex, rowData); |
| } |
| |
| public void insertRow(int rowIndex, List rowData) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).insertRow(rowIndex, rowData.toArray()); |
| } |
| |
| public void setNumRows(int newSize) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).setNumRows(newSize); |
| } |
| |
| public void setDataVector(Object[][] newData, List columnIds) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).setDataVector( |
| newData, columnIds.toArray()); |
| } |
| |
| public void setDataVector(Object[][] newData, Object[] columnIds) { |
| checkDefaultTableModel(); |
| ((DefaultTableModel)getModel()).setDataVector(newData, columnIds); |
| } |
| |
| protected void checkDefaultTableModel() { |
| if(!(dataModel instanceof DefaultTableModel)) |
| throw new InternalError("In order to use this method, the data model must be an instance of DefaultTableModel."); |
| } |
| |
| // |
| // Methods removed from JTable in the move from identifiers to ints. |
| // |
| |
| public Object getValueAt(Object columnIdentifier, int rowIndex) { |
| return super.getValueAt(rowIndex, getColumnIndex(columnIdentifier)); |
| } |
| |
| public boolean isCellEditable(Object columnIdentifier, int rowIndex) { |
| return super.isCellEditable(rowIndex, getColumnIndex(columnIdentifier)); |
| } |
| |
| public void setValueAt(Object aValue, Object columnIdentifier, int rowIndex) { |
| super.setValueAt(aValue, rowIndex, getColumnIndex(columnIdentifier)); |
| } |
| |
| public boolean editColumnRow(Object identifier, int row) { |
| return super.editCellAt(row, getColumnIndex(identifier)); |
| } |
| |
| public void moveColumn(Object columnIdentifier, Object targetColumnIdentifier) { |
| moveColumn(getColumnIndex(columnIdentifier), |
| getColumnIndex(targetColumnIdentifier)); |
| } |
| |
| public boolean isColumnSelected(Object identifier) { |
| return isColumnSelected(getColumnIndex(identifier)); |
| } |
| |
| public TableColumn addColumn(int modelColumn, int width) { |
| return addColumn(modelColumn, width, null, null); |
| } |
| |
| public TableColumn addColumn(int modelColumn) { |
| return addColumn(modelColumn, 75, null, null); |
| } |
| |
| /** |
| * Creates a new column with <I>modelColumn</I>, <I>width</I>, |
| * <I>renderer</I>, and <I>editor</I> and adds it to the end of |
| * the JTable's array of columns. This method also retrieves the |
| * name of the column using the model's <I>getColumnName(modelColumn)</I> |
| * method, and sets the both the header value and the identifier |
| * for this TableColumn accordingly. |
| * <p> |
| * The <I>modelColumn</I> is the index of the column in the model which |
| * will supply the data for this column in the table. This, like the |
| * <I>columnIdentifier</I> in previous releases, does not change as the |
| * columns are moved in the view. |
| * <p> |
| * For the rest of the JTable API, and all of its associated classes, |
| * columns are referred to in the co-ordinate system of the view, the |
| * index of the column in the model is kept inside the TableColumn |
| * and is used only to retrieve the information from the appropraite |
| * column in the model. |
| * <p> |
| * |
| * @param modelColumn The index of the column in the model |
| * @param width The new column's width. Or -1 to use |
| * the default width |
| * @param renderer The renderer used with the new column. |
| * Or null to use the default renderer. |
| * @param editor The editor used with the new column. |
| * Or null to use the default editor. |
| */ |
| public TableColumn addColumn(int modelColumn, int width, |
| TableCellRenderer renderer, |
| TableCellEditor editor) { |
| TableColumn newColumn = new TableColumn( |
| modelColumn, width, renderer, editor); |
| addColumn(newColumn); |
| return newColumn; |
| } |
| |
| // |
| // Methods that had their arguments switched. |
| // |
| |
| // These won't work with the new table package. |
| |
| /* |
| public Object getValueAt(int columnIndex, int rowIndex) { |
| return super.getValueAt(rowIndex, columnIndex); |
| } |
| |
| public boolean isCellEditable(int columnIndex, int rowIndex) { |
| return super.isCellEditable(rowIndex, columnIndex); |
| } |
| |
| public void setValueAt(Object aValue, int columnIndex, int rowIndex) { |
| super.setValueAt(aValue, rowIndex, columnIndex); |
| } |
| */ |
| |
| public boolean editColumnRow(int columnIndex, int rowIndex) { |
| return super.editCellAt(rowIndex, columnIndex); |
| } |
| |
| public boolean editColumnRow(int columnIndex, int rowIndex, EventObject e){ |
| return super.editCellAt(rowIndex, columnIndex, e); |
| } |
| |
| |
| } // End Of Class OldJTable |