1/*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 *   - Redistributions of source code must retain the above copyright
9 *     notice, this list of conditions and the following disclaimer.
10 *
11 *   - Redistributions in binary form must reproduce the above copyright
12 *     notice, this list of conditions and the following disclaimer in the
13 *     documentation and/or other materials provided with the distribution.
14 *
15 *   - Neither the name of Oracle nor the names of its
16 *     contributors may be used to endorse or promote products derived
17 *     from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*
33 * This source code is provided to illustrate the usage of a given feature
34 * or technique and has been deliberately simplified. Additional steps
35 * required for a production-quality application, such as security checks,
36 * input validation and proper error handling, might not be present in
37 * this sample code.
38 */
39
40
41
42import java.util.EventObject;
43import java.util.List;
44import javax.swing.JTable;
45import javax.swing.table.DefaultTableModel;
46import javax.swing.table.TableCellEditor;
47import javax.swing.table.TableCellRenderer;
48import javax.swing.table.TableColumn;
49
50
51/**
52 *  The OldJTable is an unsupported class containing some methods that were
53 *  deleted from the JTable between releases 0.6 and 0.7
54 */
55@SuppressWarnings("serial")
56public class OldJTable extends JTable
57{
58   /*
59    *  A new convenience method returning the index of the column in the
60    *  co-ordinate space of the view.
61    */
62    public int getColumnIndex(Object identifier) {
63        return getColumnModel().getColumnIndex(identifier);
64    }
65
66//
67//  Methods deleted from the JTable because they only work with the
68//  DefaultTableModel.
69//
70
71    public TableColumn addColumn(Object columnIdentifier, int width) {
72        return addColumn(columnIdentifier, width, null, null, null);
73    }
74
75    public TableColumn addColumn(Object columnIdentifier, List columnData) {
76        return addColumn(columnIdentifier, -1, null, null, columnData);
77    }
78
79    // Override the new JTable implementation - it will not add a column to the
80    // DefaultTableModel.
81    public TableColumn addColumn(Object columnIdentifier, int width,
82                                 TableCellRenderer renderer,
83                                 TableCellEditor editor) {
84        return addColumn(columnIdentifier, width, renderer, editor, null);
85    }
86
87    public TableColumn addColumn(Object columnIdentifier, int width,
88                                 TableCellRenderer renderer,
89                                 TableCellEditor editor, List columnData) {
90        checkDefaultTableModel();
91
92        // Set up the model side first
93        DefaultTableModel m = (DefaultTableModel)getModel();
94        m.addColumn(columnIdentifier, columnData.toArray());
95
96        // The column will have been added to the end, so the index of the
97        // column in the model is the last element.
98        TableColumn newColumn = new TableColumn(
99                m.getColumnCount()-1, width, renderer, editor);
100        super.addColumn(newColumn);
101        return newColumn;
102    }
103
104    // Not possilble to make this work the same way ... change it so that
105    // it does not delete columns from the model.
106    public void removeColumn(Object columnIdentifier) {
107        super.removeColumn(getColumn(columnIdentifier));
108    }
109
110    public void addRow(Object[] rowData) {
111        checkDefaultTableModel();
112        ((DefaultTableModel)getModel()).addRow(rowData);
113    }
114
115    public void addRow(List rowData) {
116        checkDefaultTableModel();
117        ((DefaultTableModel)getModel()).addRow(rowData.toArray());
118    }
119
120    public void removeRow(int rowIndex) {
121        checkDefaultTableModel();
122        ((DefaultTableModel)getModel()).removeRow(rowIndex);
123    }
124
125    public void moveRow(int startIndex, int endIndex, int toIndex) {
126        checkDefaultTableModel();
127        ((DefaultTableModel)getModel()).moveRow(startIndex, endIndex, toIndex);
128    }
129
130    public void insertRow(int rowIndex, Object[] rowData) {
131        checkDefaultTableModel();
132        ((DefaultTableModel)getModel()).insertRow(rowIndex, rowData);
133    }
134
135    public void insertRow(int rowIndex, List rowData) {
136        checkDefaultTableModel();
137        ((DefaultTableModel)getModel()).insertRow(rowIndex, rowData.toArray());
138    }
139
140    public void setNumRows(int newSize) {
141        checkDefaultTableModel();
142        ((DefaultTableModel)getModel()).setNumRows(newSize);
143    }
144
145    public void setDataVector(Object[][] newData, List columnIds) {
146        checkDefaultTableModel();
147        ((DefaultTableModel)getModel()).setDataVector(
148                newData, columnIds.toArray());
149    }
150
151    public void setDataVector(Object[][] newData, Object[] columnIds) {
152        checkDefaultTableModel();
153        ((DefaultTableModel)getModel()).setDataVector(newData, columnIds);
154    }
155
156    protected void checkDefaultTableModel() {
157        if(!(dataModel instanceof DefaultTableModel))
158            throw new InternalError("In order to use this method, the data model must be an instance of DefaultTableModel.");
159    }
160
161//
162//  Methods removed from JTable in the move from identifiers to ints.
163//
164
165    public Object getValueAt(Object columnIdentifier, int rowIndex) {
166        return super.getValueAt(rowIndex, getColumnIndex(columnIdentifier));
167    }
168
169    public boolean isCellEditable(Object columnIdentifier, int rowIndex) {
170        return super.isCellEditable(rowIndex, getColumnIndex(columnIdentifier));
171    }
172
173    public void setValueAt(Object aValue, Object columnIdentifier, int rowIndex) {
174        super.setValueAt(aValue, rowIndex, getColumnIndex(columnIdentifier));
175    }
176
177    public boolean editColumnRow(Object identifier, int row) {
178        return super.editCellAt(row, getColumnIndex(identifier));
179    }
180
181    public void moveColumn(Object columnIdentifier, Object targetColumnIdentifier) {
182        moveColumn(getColumnIndex(columnIdentifier),
183                   getColumnIndex(targetColumnIdentifier));
184    }
185
186    public boolean isColumnSelected(Object identifier) {
187        return isColumnSelected(getColumnIndex(identifier));
188    }
189
190    public TableColumn addColumn(int modelColumn, int width) {
191        return addColumn(modelColumn, width, null, null);
192    }
193
194    public TableColumn addColumn(int modelColumn) {
195        return addColumn(modelColumn, 75, null, null);
196    }
197
198    /**
199     *  Creates a new column with <I>modelColumn</I>, <I>width</I>,
200     *  <I>renderer</I>, and <I>editor</I> and adds it to the end of
201     *  the JTable's array of columns. This method also retrieves the
202     *  name of the column using the model's <I>getColumnName(modelColumn)</I>
203     *  method, and sets the both the header value and the identifier
204     *  for this TableColumn accordingly.
205     *  <p>
206     *  The <I>modelColumn</I> is the index of the column in the model which
207     *  will supply the data for this column in the table. This, like the
208     *  <I>columnIdentifier</I> in previous releases, does not change as the
209     *  columns are moved in the view.
210     *  <p>
211     *  For the rest of the JTable API, and all of its associated classes,
212     *  columns are referred to in the co-ordinate system of the view, the
213     *  index of the column in the model is kept inside the TableColumn
214     *  and is used only to retrieve the information from the appropraite
215     *  column in the model.
216     *  <p>
217     *
218     *  @param  modelColumn     The index of the column in the model
219     *  @param  width           The new column's width.  Or -1 to use
220     *                          the default width
221     *  @param  renderer        The renderer used with the new column.
222     *                          Or null to use the default renderer.
223     *  @param  editor          The editor used with the new column.
224     *                          Or null to use the default editor.
225     */
226    public TableColumn addColumn(int modelColumn, int width,
227                                 TableCellRenderer renderer,
228                                 TableCellEditor editor) {
229        TableColumn newColumn = new TableColumn(
230                modelColumn, width, renderer, editor);
231        addColumn(newColumn);
232        return newColumn;
233    }
234
235//
236//  Methods that had their arguments switched.
237//
238
239// These won't work with the new table package.
240
241/*
242    public Object getValueAt(int columnIndex, int rowIndex) {
243        return super.getValueAt(rowIndex, columnIndex);
244    }
245
246    public boolean isCellEditable(int columnIndex, int rowIndex) {
247        return super.isCellEditable(rowIndex, columnIndex);
248    }
249
250    public void setValueAt(Object aValue, int columnIndex, int rowIndex) {
251        super.setValueAt(aValue, rowIndex, columnIndex);
252    }
253*/
254
255    public boolean editColumnRow(int columnIndex, int rowIndex) {
256        return super.editCellAt(rowIndex, columnIndex);
257    }
258
259    public boolean editColumnRow(int columnIndex, int rowIndex, EventObject e){
260        return super.editCellAt(rowIndex, columnIndex, e);
261    }
262
263
264}  // End Of Class OldJTable
265