Quelle  OldJTable.java   Sprache: JAVA

/*
 * 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