1 /*
2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package javax.swing;
26
27 import java.util.*;
28
29 import java.applet.Applet;
30 import java.awt.*;
31 import java.awt.event.*;
32 import java.awt.print.*;
33
34 import java.beans.JavaBean;
35 import java.beans.BeanProperty;
36 import java.beans.PropertyChangeEvent;
37 import java.beans.PropertyChangeListener;
38
39 import java.io.ObjectOutputStream;
40 import java.io.ObjectInputStream;
41 import java.io.IOException;
42 import java.io.InvalidObjectException;
43
44 import javax.accessibility.*;
45
46 import javax.swing.event.*;
47 import javax.swing.plaf.*;
48 import javax.swing.table.*;
49 import javax.swing.border.*;
50
51 import java.text.NumberFormat;
52 import java.text.DateFormat;
53 import java.text.MessageFormat;
54 import java.util.List;
55
56 import javax.print.attribute.*;
57 import javax.print.PrintService;
58
59 import sun.awt.AWTAccessor;
60 import sun.awt.AWTAccessor.MouseEventAccessor;
61 import sun.reflect.misc.ReflectUtil;
62
63 import sun.swing.SwingUtilities2;
64 import sun.swing.SwingUtilities2.Section;
65 import static sun.swing.SwingUtilities2.Section.*;
66 import sun.swing.PrintingStatus;
67
68 /**
69 * The <code>JTable</code> is used to display and edit regular two-dimensional tables
70 * of cells.
71 * See <a href="http://docs.oracle.com/javase/tutorial/uiswing/components/table.html">How to Use Tables</a>
72 * in <em>The Java Tutorial</em>
73 * for task-oriented documentation and examples of using <code>JTable</code>.
74 *
75 * <p>
76 * The <code>JTable</code> has many
77 * facilities that make it possible to customize its rendering and editing
78 * but provides defaults for these features so that simple tables can be
79 * set up easily. For example, to set up a table with 10 rows and 10
80 * columns of numbers:
81 *
82 * <pre>
83 * TableModel dataModel = new AbstractTableModel() {
84 * public int getColumnCount() { return 10; }
85 * public int getRowCount() { return 10;}
86 * public Object getValueAt(int row, int col) { return Integer.valueOf(row*col); }
87 * };
88 * JTable table = new JTable(dataModel);
89 * JScrollPane scrollpane = new JScrollPane(table);
90 * </pre>
91 * <p>
92 * {@code JTable}s are typically placed inside of a {@code JScrollPane}. By
93 * default, a {@code JTable} will adjust its width such that
94 * a horizontal scrollbar is unnecessary. To allow for a horizontal scrollbar,
95 * invoke {@link #setAutoResizeMode} with {@code AUTO_RESIZE_OFF}.
96 * Note that if you wish to use a <code>JTable</code> in a standalone
97 * view (outside of a <code>JScrollPane</code>) and want the header
98 * displayed, you can get it using {@link #getTableHeader} and
99 * display it separately.
100 * <p>
101 * To enable sorting and filtering of rows, use a
102 * {@code RowSorter}.
103 * You can set up a row sorter in either of two ways:
104 * <ul>
105 * <li>Directly set the {@code RowSorter}. For example:
106 * {@code table.setRowSorter(new TableRowSorter(model))}.
107 * <li>Set the {@code autoCreateRowSorter}
108 * property to {@code true}, so that the {@code JTable}
109 * creates a {@code RowSorter} for
110 * you. For example: {@code setAutoCreateRowSorter(true)}.
111 * </ul>
112 * <p>
113 * When designing applications that use the <code>JTable</code> it is worth paying
114 * close attention to the data structures that will represent the table's data.
115 * The <code>DefaultTableModel</code> is a model implementation that
116 * uses a <code>Vector</code> of <code>Vector</code>s of <code>Object</code>s to
117 * store the cell values. As well as copying the data from an
118 * application into the <code>DefaultTableModel</code>,
119 * it is also possible to wrap the data in the methods of the
120 * <code>TableModel</code> interface so that the data can be passed to the
121 * <code>JTable</code> directly, as in the example above. This often results
122 * in more efficient applications because the model is free to choose the
123 * internal representation that best suits the data.
124 * A good rule of thumb for deciding whether to use the <code>AbstractTableModel</code>
125 * or the <code>DefaultTableModel</code> is to use the <code>AbstractTableModel</code>
126 * as the base class for creating subclasses and the <code>DefaultTableModel</code>
127 * when subclassing is not required.
128 * <p>
129 * The "TableExample" directory in the demo area of the source distribution
130 * gives a number of complete examples of <code>JTable</code> usage,
131 * covering how the <code>JTable</code> can be used to provide an
132 * editable view of data taken from a database and how to modify
133 * the columns in the display to use specialized renderers and editors.
134 * <p>
135 * The <code>JTable</code> uses integers exclusively to refer to both the rows and the columns
136 * of the model that it displays. The <code>JTable</code> simply takes a tabular range of cells
137 * and uses <code>getValueAt(int, int)</code> to retrieve the
138 * values from the model during painting. It is important to remember that
139 * the column and row indexes returned by various <code>JTable</code> methods
140 * are in terms of the <code>JTable</code> (the view) and are not
141 * necessarily the same indexes used by the model.
142 * <p>
143 * By default, columns may be rearranged in the <code>JTable</code> so that the
144 * view's columns appear in a different order to the columns in the model.
145 * This does not affect the implementation of the model at all: when the
146 * columns are reordered, the <code>JTable</code> maintains the new order of the columns
147 * internally and converts its column indices before querying the model.
148 * <p>
149 * So, when writing a <code>TableModel</code>, it is not necessary to listen for column
150 * reordering events as the model will be queried in its own coordinate
151 * system regardless of what is happening in the view.
152 * In the examples area there is a demonstration of a sorting algorithm making
153 * use of exactly this technique to interpose yet another coordinate system
154 * where the order of the rows is changed, rather than the order of the columns.
155 * <p>
156 * Similarly when using the sorting and filtering functionality
157 * provided by <code>RowSorter</code> the underlying
158 * <code>TableModel</code> does not need to know how to do sorting,
159 * rather <code>RowSorter</code> will handle it. Coordinate
160 * conversions will be necessary when using the row based methods of
161 * <code>JTable</code> with the underlying <code>TableModel</code>.
162 * All of <code>JTable</code>s row based methods are in terms of the
163 * <code>RowSorter</code>, which is not necessarily the same as that
164 * of the underlying <code>TableModel</code>. For example, the
165 * selection is always in terms of <code>JTable</code> so that when
166 * using <code>RowSorter</code> you will need to convert using
167 * <code>convertRowIndexToView</code> or
168 * <code>convertRowIndexToModel</code>. The following shows how to
169 * convert coordinates from <code>JTable</code> to that of the
170 * underlying model:
171 * <pre>
172 * int[] selection = table.getSelectedRows();
173 * for (int i = 0; i < selection.length; i++) {
174 * selection[i] = table.convertRowIndexToModel(selection[i]);
175 * }
176 * // selection is now in terms of the underlying TableModel
177 * </pre>
178 * <p>
179 * By default if sorting is enabled <code>JTable</code> will persist the
180 * selection and variable row heights in terms of the model on
181 * sorting. For example if row 0, in terms of the underlying model,
182 * is currently selected, after the sort row 0, in terms of the
183 * underlying model will be selected. Visually the selection may
184 * change, but in terms of the underlying model it will remain the
185 * same. The one exception to that is if the model index is no longer
186 * visible or was removed. For example, if row 0 in terms of model
187 * was filtered out the selection will be empty after the sort.
188 * <p>
189 * J2SE 5 adds methods to <code>JTable</code> to provide convenient access to some
190 * common printing needs. Simple new {@link #print()} methods allow for quick
191 * and easy addition of printing support to your application. In addition, a new
192 * {@link #getPrintable} method is available for more advanced printing needs.
193 * <p>
194 * As for all <code>JComponent</code> classes, you can use
195 * {@link InputMap} and {@link ActionMap} to associate an
196 * {@link Action} object with a {@link KeyStroke} and execute the
197 * action under specified conditions.
198 * <p>
199 * <strong>Warning:</strong> Swing is not thread safe. For more
200 * information see <a
201 * href="package-summary.html#threading">Swing's Threading
202 * Policy</a>.
203 * <p>
204 * <strong>Warning:</strong>
205 * Serialized objects of this class will not be compatible with
206 * future Swing releases. The current serialization support is
207 * appropriate for short term storage or RMI between applications running
208 * the same version of Swing. As of 1.4, support for long term storage
209 * of all JavaBeans™
210 * has been added to the <code>java.beans</code> package.
211 * Please see {@link java.beans.XMLEncoder}.
212 *
213 * @author Philip Milne
214 * @author Shannon Hickey (printing support)
215 * @see javax.swing.table.DefaultTableModel
216 * @see javax.swing.table.TableRowSorter
217 * @since 1.2
218 */
219 /* The first versions of the JTable, contained in Swing-0.1 through
220 * Swing-0.4, were written by Alan Chung.
221 */
222 @JavaBean(defaultProperty = "UI", description = "A component which displays data in a two dimensional grid.")
223 @SwingContainer(false)
224 @SuppressWarnings("serial") // Same-version serialization only
225 public class JTable extends JComponent implements TableModelListener, Scrollable,
226 TableColumnModelListener, ListSelectionListener, CellEditorListener,
227 Accessible, RowSorterListener
228 {
229 //
230 // Static Constants
231 //
232
233 /**
234 * @see #getUIClassID
235 * @see #readObject
236 */
237 private static final String uiClassID = "TableUI";
238
239 /** Do not adjust column widths automatically; use a horizontal scrollbar instead. */
240 public static final int AUTO_RESIZE_OFF = 0;
241
242 /** When a column is adjusted in the UI, adjust the next column the opposite way. */
243 public static final int AUTO_RESIZE_NEXT_COLUMN = 1;
244
245 /** During UI adjustment, change subsequent columns to preserve the total width;
246 * this is the default behavior. */
247 public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;
248
249 /** During all resize operations, apply adjustments to the last column only. */
250 public static final int AUTO_RESIZE_LAST_COLUMN = 3;
251
252 /** During all resize operations, proportionately resize all columns. */
253 public static final int AUTO_RESIZE_ALL_COLUMNS = 4;
254
255
256 /**
257 * Printing modes, used in printing <code>JTable</code>s.
258 *
259 * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
260 * boolean, PrintRequestAttributeSet, boolean)
261 * @see #getPrintable
262 * @since 1.5
263 */
264 public enum PrintMode {
265
266 /**
267 * Printing mode that prints the table at its current size,
268 * spreading both columns and rows across multiple pages if necessary.
269 */
270 NORMAL,
271
272 /**
273 * Printing mode that scales the output smaller, if necessary,
274 * to fit the table's entire width (and thereby all columns) on each page;
275 * Rows are spread across multiple pages as necessary.
276 */
277 FIT_WIDTH
278 }
279
280
281 //
282 // Instance Variables
283 //
284
285 /** The <code>TableModel</code> of the table. */
286 protected TableModel dataModel;
287
288 /** The <code>TableColumnModel</code> of the table. */
289 protected TableColumnModel columnModel;
290
291 /** The <code>ListSelectionModel</code> of the table, used to keep track of row selections. */
292 protected ListSelectionModel selectionModel;
293
294 /** The <code>TableHeader</code> working with the table. */
295 protected JTableHeader tableHeader;
296
297 /** The height in pixels of each row in the table. */
298 protected int rowHeight;
299
300 /** The height in pixels of the margin between the cells in each row. */
301 protected int rowMargin;
302
303 /** The color of the grid. */
304 protected Color gridColor;
305
306 /** The table draws horizontal lines between cells if <code>showHorizontalLines</code> is true. */
307 protected boolean showHorizontalLines;
308
309 /** The table draws vertical lines between cells if <code>showVerticalLines</code> is true. */
310 protected boolean showVerticalLines;
311
312 /**
313 * Determines if the table automatically resizes the
314 * width of the table's columns to take up the entire width of the
315 * table, and how it does the resizing.
316 */
317 protected int autoResizeMode;
318
319 /**
320 * The table will query the <code>TableModel</code> to build the default
321 * set of columns if this is true.
322 */
323 protected boolean autoCreateColumnsFromModel;
324
325 /** Used by the <code>Scrollable</code> interface to determine the initial visible area. */
326 protected Dimension preferredViewportSize;
327
328 /** True if row selection is allowed in this table. */
329 protected boolean rowSelectionAllowed;
330
331 /**
332 * Obsolete as of Java 2 platform v1.3. Please use the
333 * <code>rowSelectionAllowed</code> property and the
334 * <code>columnSelectionAllowed</code> property of the
335 * <code>columnModel</code> instead. Or use the
336 * method <code>getCellSelectionEnabled</code>.
337 */
338 /*
339 * If true, both a row selection and a column selection
340 * can be non-empty at the same time, the selected cells are the
341 * the cells whose row and column are both selected.
342 */
343 protected boolean cellSelectionEnabled;
344
345 /** If editing, the <code>Component</code> that is handling the editing. */
346 protected transient Component editorComp;
347
348 /**
349 * The active cell editor object, that overwrites the screen real estate
350 * occupied by the current cell and allows the user to change its contents.
351 * {@code null} if the table isn't currently editing.
352 */
353 protected transient TableCellEditor cellEditor;
354
355 /** Identifies the column of the cell being edited. */
356 protected transient int editingColumn;
357
358 /** Identifies the row of the cell being edited. */
359 protected transient int editingRow;
360
361 /**
362 * A table of objects that display the contents of a cell,
363 * indexed by class as declared in <code>getColumnClass</code>
364 * in the <code>TableModel</code> interface.
365 */
366 protected transient Hashtable<Object, Object> defaultRenderersByColumnClass;
367 // Logicaly, the above is a Hashtable<Class<?>, TableCellRenderer>.
368 // It is declared otherwise to accomodate using UIDefaults.
369
370 /**
371 * A table of objects that display and edit the contents of a cell,
372 * indexed by class as declared in <code>getColumnClass</code>
373 * in the <code>TableModel</code> interface.
374 */
375 protected transient Hashtable<Object, Object> defaultEditorsByColumnClass;
376 // Logicaly, the above is a Hashtable<Class<?>, TableCellEditor>.
377 // It is declared otherwise to accomodate using UIDefaults.
378
379 /** The foreground color of selected cells. */
380 protected Color selectionForeground;
381
382 /** The background color of selected cells. */
383 protected Color selectionBackground;
384
385 //
386 // Private state
387 //
388
389 // WARNING: If you directly access this field you should also change the
390 // SortManager.modelRowSizes field as well.
391 private SizeSequence rowModel;
392 private boolean dragEnabled;
393 private boolean surrendersFocusOnKeystroke;
394 private PropertyChangeListener editorRemover = null;
395 /**
396 * The last value of getValueIsAdjusting from the column selection models
397 * columnSelectionChanged notification. Used to test if a repaint is
398 * needed.
399 */
400 private boolean columnSelectionAdjusting;
401 /**
402 * The last value of getValueIsAdjusting from the row selection models
403 * valueChanged notification. Used to test if a repaint is needed.
404 */
405 private boolean rowSelectionAdjusting;
406
407 /**
408 * To communicate errors between threads during printing.
409 */
410 private Throwable printError;
411
412 /**
413 * True when setRowHeight(int) has been invoked.
414 */
415 private boolean isRowHeightSet;
416
417 /**
418 * If true, on a sort the selection is reset.
419 */
420 private boolean updateSelectionOnSort;
421
422 /**
423 * Information used in sorting.
424 */
425 private transient SortManager sortManager;
426
427 /**
428 * If true, when sorterChanged is invoked it's value is ignored.
429 */
430 private boolean ignoreSortChange;
431
432 /**
433 * Whether or not sorterChanged has been invoked.
434 */
435 private boolean sorterChanged;
436
437 /**
438 * If true, any time the model changes a new RowSorter is set.
439 */
440 private boolean autoCreateRowSorter;
441
442 /**
443 * Whether or not the table always fills the viewport height.
444 * @see #setFillsViewportHeight
445 * @see #getScrollableTracksViewportHeight
446 */
447 private boolean fillsViewportHeight;
448
449 /**
450 * The drop mode for this component.
451 */
452 private DropMode dropMode = DropMode.USE_SELECTION;
453
454 /**
455 * The drop location.
456 */
457 private transient DropLocation dropLocation;
458
459 /**
460 * Flag to indicate UI update is in progress
461 */
462 private transient boolean updateInProgress;
463
464 /**
465 * A subclass of <code>TransferHandler.DropLocation</code> representing
466 * a drop location for a <code>JTable</code>.
467 *
468 * @see #getDropLocation
469 * @since 1.6
470 */
471 public static final class DropLocation extends TransferHandler.DropLocation {
472 private final int row;
473 private final int col;
474 private final boolean isInsertRow;
475 private final boolean isInsertCol;
476
477 private DropLocation(Point p, int row, int col,
478 boolean isInsertRow, boolean isInsertCol) {
479
480 super(p);
481 this.row = row;
482 this.col = col;
483 this.isInsertRow = isInsertRow;
484 this.isInsertCol = isInsertCol;
485 }
486
487 /**
488 * Returns the row index where a dropped item should be placed in the
489 * table. Interpretation of the value depends on the return of
490 * <code>isInsertRow()</code>. If that method returns
491 * <code>true</code> this value indicates the index where a new
492 * row should be inserted. Otherwise, it represents the value
493 * of an existing row on which the data was dropped. This index is
494 * in terms of the view.
495 * <p>
496 * <code>-1</code> indicates that the drop occurred over empty space,
497 * and no row could be calculated.
498 *
499 * @return the drop row
500 */
501 public int getRow() {
502 return row;
503 }
504
505 /**
506 * Returns the column index where a dropped item should be placed in the
507 * table. Interpretation of the value depends on the return of
508 * <code>isInsertColumn()</code>. If that method returns
509 * <code>true</code> this value indicates the index where a new
510 * column should be inserted. Otherwise, it represents the value
511 * of an existing column on which the data was dropped. This index is
512 * in terms of the view.
513 * <p>
514 * <code>-1</code> indicates that the drop occurred over empty space,
515 * and no column could be calculated.
516 *
517 * @return the drop row
518 */
519 public int getColumn() {
520 return col;
521 }
522
523 /**
524 * Returns whether or not this location represents an insert
525 * of a row.
526 *
527 * @return whether or not this is an insert row
528 */
529 public boolean isInsertRow() {
530 return isInsertRow;
531 }
532
533 /**
534 * Returns whether or not this location represents an insert
535 * of a column.
536 *
537 * @return whether or not this is an insert column
538 */
539 public boolean isInsertColumn() {
540 return isInsertCol;
541 }
542
543 /**
544 * Returns a string representation of this drop location.
545 * This method is intended to be used for debugging purposes,
546 * and the content and format of the returned string may vary
547 * between implementations.
548 *
549 * @return a string representation of this drop location
550 */
551 public String toString() {
552 return getClass().getName()
553 + "[dropPoint=" + getDropPoint() + ","
554 + "row=" + row + ","
555 + "column=" + col + ","
556 + "insertRow=" + isInsertRow + ","
557 + "insertColumn=" + isInsertCol + "]";
558 }
559 }
560
561 //
562 // Constructors
563 //
564
565 /**
566 * Constructs a default <code>JTable</code> that is initialized with a default
567 * data model, a default column model, and a default selection
568 * model.
569 *
570 * @see #createDefaultDataModel
571 * @see #createDefaultColumnModel
572 * @see #createDefaultSelectionModel
573 */
574 public JTable() {
575 this(null, null, null);
576 }
577
578 /**
579 * Constructs a <code>JTable</code> that is initialized with
580 * <code>dm</code> as the data model, a default column model,
581 * and a default selection model.
582 *
583 * @param dm the data model for the table
584 * @see #createDefaultColumnModel
585 * @see #createDefaultSelectionModel
586 */
587 public JTable(TableModel dm) {
588 this(dm, null, null);
589 }
590
591 /**
592 * Constructs a <code>JTable</code> that is initialized with
593 * <code>dm</code> as the data model, <code>cm</code>
594 * as the column model, and a default selection model.
595 *
596 * @param dm the data model for the table
597 * @param cm the column model for the table
598 * @see #createDefaultSelectionModel
599 */
600 public JTable(TableModel dm, TableColumnModel cm) {
601 this(dm, cm, null);
602 }
603
604 /**
605 * Constructs a <code>JTable</code> that is initialized with
606 * <code>dm</code> as the data model, <code>cm</code> as the
607 * column model, and <code>sm</code> as the selection model.
608 * If any of the parameters are <code>null</code> this method
609 * will initialize the table with the corresponding default model.
610 * The <code>autoCreateColumnsFromModel</code> flag is set to false
611 * if <code>cm</code> is non-null, otherwise it is set to true
612 * and the column model is populated with suitable
613 * <code>TableColumns</code> for the columns in <code>dm</code>.
614 *
615 * @param dm the data model for the table
616 * @param cm the column model for the table
617 * @param sm the row selection model for the table
618 * @see #createDefaultDataModel
619 * @see #createDefaultColumnModel
620 * @see #createDefaultSelectionModel
621 */
622 public JTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm) {
623 super();
624 setLayout(null);
625
626 setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
627 JComponent.getManagingFocusForwardTraversalKeys());
628 setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
629 JComponent.getManagingFocusBackwardTraversalKeys());
630 if (cm == null) {
631 cm = createDefaultColumnModel();
632 autoCreateColumnsFromModel = true;
633 }
634 setColumnModel(cm);
635
636 if (sm == null) {
637 sm = createDefaultSelectionModel();
638 }
639 setSelectionModel(sm);
640
641 // Set the model last, that way if the autoCreatColumnsFromModel has
642 // been set above, we will automatically populate an empty columnModel
643 // with suitable columns for the new model.
644 if (dm == null) {
645 dm = createDefaultDataModel();
646 }
647 setModel(dm);
648
649 initializeLocalVars();
650 updateUI();
651 }
652
653 /**
654 * Constructs a <code>JTable</code> with <code>numRows</code>
655 * and <code>numColumns</code> of empty cells using
656 * <code>DefaultTableModel</code>. The columns will have
657 * names of the form "A", "B", "C", etc.
658 *
659 * @param numRows the number of rows the table holds
660 * @param numColumns the number of columns the table holds
661 * @see javax.swing.table.DefaultTableModel
662 */
663 public JTable(int numRows, int numColumns) {
664 this(new DefaultTableModel(numRows, numColumns));
665 }
666
667 /**
668 * Constructs a <code>JTable</code> to display the values in the
669 * <code>Vector</code> of <code>Vectors</code>, <code>rowData</code>,
670 * with column names, <code>columnNames</code>. The
671 * <code>Vectors</code> contained in <code>rowData</code>
672 * should contain the values for that row. In other words,
673 * the value of the cell at row 1, column 5 can be obtained
674 * with the following code:
675 *
676 * <pre>((Vector)rowData.elementAt(1)).elementAt(5);</pre>
677 *
678 * @param rowData the data for the new table
679 * @param columnNames names of each column
680 */
681 @SuppressWarnings("rawtypes")
682 public JTable(Vector<? extends Vector> rowData, Vector<?> columnNames) {
683 this(new DefaultTableModel(rowData, columnNames));
684 }
685
686 /**
687 * Constructs a <code>JTable</code> to display the values in the two dimensional array,
688 * <code>rowData</code>, with column names, <code>columnNames</code>.
689 * <code>rowData</code> is an array of rows, so the value of the cell at row 1,
690 * column 5 can be obtained with the following code:
691 *
692 * <pre> rowData[1][5]; </pre>
693 * <p>
694 * All rows must be of the same length as <code>columnNames</code>.
695 *
696 * @param rowData the data for the new table
697 * @param columnNames names of each column
698 */
699 public JTable(final Object[][] rowData, final Object[] columnNames) {
700 this(new AbstractTableModel() {
701 public String getColumnName(int column) { return columnNames[column].toString(); }
702 public int getRowCount() { return rowData.length; }
703 public int getColumnCount() { return columnNames.length; }
704 public Object getValueAt(int row, int col) { return rowData[row][col]; }
705 public boolean isCellEditable(int row, int column) { return true; }
706 public void setValueAt(Object value, int row, int col) {
707 rowData[row][col] = value;
708 fireTableCellUpdated(row, col);
709 }
710 });
711 }
712
713 /**
714 * Calls the <code>configureEnclosingScrollPane</code> method.
715 *
716 * @see #configureEnclosingScrollPane
717 */
718 public void addNotify() {
719 super.addNotify();
720 configureEnclosingScrollPane();
721 }
722
723 /**
724 * If this <code>JTable</code> is the <code>viewportView</code> of an enclosing <code>JScrollPane</code>
725 * (the usual situation), configure this <code>ScrollPane</code> by, amongst other things,
726 * installing the table's <code>tableHeader</code> as the <code>columnHeaderView</code> of the scroll pane.
727 * When a <code>JTable</code> is added to a <code>JScrollPane</code> in the usual way,
728 * using <code>new JScrollPane(myTable)</code>, <code>addNotify</code> is
729 * called in the <code>JTable</code> (when the table is added to the viewport).
730 * <code>JTable</code>'s <code>addNotify</code> method in turn calls this method,
731 * which is protected so that this default installation procedure can
732 * be overridden by a subclass.
733 *
734 * @see #addNotify
735 */
736 protected void configureEnclosingScrollPane() {
737 Container parent = SwingUtilities.getUnwrappedParent(this);
738 if (parent instanceof JViewport) {
739 JViewport port = (JViewport) parent;
740 Container gp = port.getParent();
741 if (gp instanceof JScrollPane) {
742 JScrollPane scrollPane = (JScrollPane)gp;
743 // Make certain we are the viewPort's view and not, for
744 // example, the rowHeaderView of the scrollPane -
745 // an implementor of fixed columns might do this.
746 JViewport viewport = scrollPane.getViewport();
747 if (viewport == null ||
748 SwingUtilities.getUnwrappedView(viewport) != this) {
749 return;
750 }
751 scrollPane.setColumnHeaderView(getTableHeader());
752 // configure the scrollpane for any LAF dependent settings
753 configureEnclosingScrollPaneUI();
754 }
755 }
756 }
757
758 /**
759 * This is a sub-part of configureEnclosingScrollPane() that configures
760 * anything on the scrollpane that may change when the look and feel
761 * changes. It needed to be split out from configureEnclosingScrollPane() so
762 * that it can be called from updateUI() when the LAF changes without
763 * causing the regression found in bug 6687962. This was because updateUI()
764 * is called from the constructor which then caused
765 * configureEnclosingScrollPane() to be called by the constructor which
766 * changes its contract for any subclass that overrides it. So by splitting
767 * it out in this way configureEnclosingScrollPaneUI() can be called both
768 * from configureEnclosingScrollPane() and updateUI() in a safe manor.
769 */
770 private void configureEnclosingScrollPaneUI() {
771 Container parent = SwingUtilities.getUnwrappedParent(this);
772 if (parent instanceof JViewport) {
773 JViewport port = (JViewport) parent;
774 Container gp = port.getParent();
775 if (gp instanceof JScrollPane) {
776 JScrollPane scrollPane = (JScrollPane)gp;
777 // Make certain we are the viewPort's view and not, for
778 // example, the rowHeaderView of the scrollPane -
779 // an implementor of fixed columns might do this.
780 JViewport viewport = scrollPane.getViewport();
781 if (viewport == null ||
782 SwingUtilities.getUnwrappedView(viewport) != this) {
783 return;
784 }
785 // scrollPane.getViewport().setBackingStoreEnabled(true);
786 Border border = scrollPane.getBorder();
787 if (border == null || border instanceof UIResource) {
788 Border scrollPaneBorder =
789 UIManager.getBorder("Table.scrollPaneBorder");
790 if (scrollPaneBorder != null) {
791 scrollPane.setBorder(scrollPaneBorder);
792 }
793 }
794 // add JScrollBar corner component if available from LAF and not already set by the user
795 Component corner =
796 scrollPane.getCorner(JScrollPane.UPPER_TRAILING_CORNER);
797 if (corner == null || corner instanceof UIResource){
798 corner = null;
799 try {
800 corner = (Component) UIManager.get(
801 "Table.scrollPaneCornerComponent");
802 } catch (Exception e) {
803 // just ignore and don't set corner
804 }
805 scrollPane.setCorner(JScrollPane.UPPER_TRAILING_CORNER,
806 corner);
807 }
808 }
809 }
810 }
811
812 /**
813 * Calls the <code>unconfigureEnclosingScrollPane</code> method.
814 *
815 * @see #unconfigureEnclosingScrollPane
816 */
817 public void removeNotify() {
818 KeyboardFocusManager.getCurrentKeyboardFocusManager().
819 removePropertyChangeListener("permanentFocusOwner", editorRemover);
820 editorRemover = null;
821 unconfigureEnclosingScrollPane();
822 super.removeNotify();
823 }
824
825 /**
826 * Reverses the effect of <code>configureEnclosingScrollPane</code>
827 * by replacing the <code>columnHeaderView</code> of the enclosing
828 * scroll pane with <code>null</code>. <code>JTable</code>'s
829 * <code>removeNotify</code> method calls
830 * this method, which is protected so that this default uninstallation
831 * procedure can be overridden by a subclass.
832 *
833 * @see #removeNotify
834 * @see #configureEnclosingScrollPane
835 * @since 1.3
836 */
837 protected void unconfigureEnclosingScrollPane() {
838 Container parent = SwingUtilities.getUnwrappedParent(this);
839 if (parent instanceof JViewport) {
840 JViewport port = (JViewport) parent;
841 Container gp = port.getParent();
842 if (gp instanceof JScrollPane) {
843 JScrollPane scrollPane = (JScrollPane)gp;
844 // Make certain we are the viewPort's view and not, for
845 // example, the rowHeaderView of the scrollPane -
846 // an implementor of fixed columns might do this.
847 JViewport viewport = scrollPane.getViewport();
848 if (viewport == null ||
849 SwingUtilities.getUnwrappedView(viewport) != this) {
850 return;
851 }
852 scrollPane.setColumnHeaderView(null);
853 // remove ScrollPane corner if one was added by the LAF
854 Component corner =
855 scrollPane.getCorner(JScrollPane.UPPER_TRAILING_CORNER);
856 if (corner instanceof UIResource){
857 scrollPane.setCorner(JScrollPane.UPPER_TRAILING_CORNER,
858 null);
859 }
860 }
861 }
862 }
863
864 void setUIProperty(String propertyName, Object value) {
865 if (propertyName == "rowHeight") {
866 if (!isRowHeightSet) {
867 setRowHeight(((Number)value).intValue());
868 isRowHeightSet = false;
869 }
870 return;
871 }
872 super.setUIProperty(propertyName, value);
873 }
874
875 //
876 // Static Methods
877 //
878
879 /**
880 * Equivalent to <code>new JScrollPane(aTable)</code>.
881 *
882 * @param aTable a {@code JTable} to be used for the scroll pane
883 * @return a {@code JScrollPane} created using {@code aTable}
884 * @deprecated As of Swing version 1.0.2,
885 * replaced by <code>new JScrollPane(aTable)</code>.
886 */
887 @Deprecated
888 public static JScrollPane createScrollPaneForTable(JTable aTable) {
889 return new JScrollPane(aTable);
890 }
891
892 //
893 // Table Attributes
894 //
895
896 /**
897 * Sets the <code>tableHeader</code> working with this <code>JTable</code> to <code>newHeader</code>.
898 * It is legal to have a <code>null</code> <code>tableHeader</code>.
899 *
900 * @param tableHeader new tableHeader
901 * @see #getTableHeader
902 */
903 @BeanProperty(description
904 = "The JTableHeader instance which renders the column headers.")
905 public void setTableHeader(JTableHeader tableHeader) {
906 if (this.tableHeader != tableHeader) {
907 JTableHeader old = this.tableHeader;
908 // Release the old header
909 if (old != null) {
910 old.setTable(null);
911 }
912 this.tableHeader = tableHeader;
913 if (tableHeader != null) {
914 tableHeader.setTable(this);
915 }
916 firePropertyChange("tableHeader", old, tableHeader);
917 }
918 }
919
920 /**
921 * Returns the <code>tableHeader</code> used by this <code>JTable</code>.
922 *
923 * @return the <code>tableHeader</code> used by this table
924 * @see #setTableHeader
925 */
926 public JTableHeader getTableHeader() {
927 return tableHeader;
928 }
929
930 /**
931 * Sets the height, in pixels, of all cells to <code>rowHeight</code>,
932 * revalidates, and repaints.
933 * The height of the cells will be equal to the row height minus
934 * the row margin.
935 *
936 * @param rowHeight new row height
937 * @exception IllegalArgumentException if <code>rowHeight</code> is
938 * less than 1
939 * @see #getRowHeight
940 */
941 @BeanProperty(description
942 = "The height of the specified row.")
943 public void setRowHeight(int rowHeight) {
944 if (rowHeight <= 0) {
945 throw new IllegalArgumentException("New row height less than 1");
946 }
947 int old = this.rowHeight;
948 this.rowHeight = rowHeight;
949 rowModel = null;
950 if (sortManager != null) {
951 sortManager.modelRowSizes = null;
952 }
953 isRowHeightSet = true;
954 resizeAndRepaint();
955 firePropertyChange("rowHeight", old, rowHeight);
956 }
957
958 /**
959 * Returns the height of a table row, in pixels.
960 *
961 * @return the height in pixels of a table row
962 * @see #setRowHeight
963 */
964 public int getRowHeight() {
965 return rowHeight;
966 }
967
968 private SizeSequence getRowModel() {
969 if (rowModel == null) {
970 rowModel = new SizeSequence(getRowCount(), getRowHeight());
971 }
972 return rowModel;
973 }
974
975 /**
976 * Sets the height for <code>row</code> to <code>rowHeight</code>,
977 * revalidates, and repaints. The height of the cells in this row
978 * will be equal to the row height minus the row margin.
979 *
980 * @param row the row whose height is being
981 changed
982 * @param rowHeight new row height, in pixels
983 * @exception IllegalArgumentException if <code>rowHeight</code> is
984 * less than 1
985 * @since 1.3
986 */
987 @BeanProperty(description
988 = "The height in pixels of the cells in <code>row</code>")
989 public void setRowHeight(int row, int rowHeight) {
990 if (rowHeight <= 0) {
991 throw new IllegalArgumentException("New row height less than 1");
992 }
993 getRowModel().setSize(row, rowHeight);
994 if (sortManager != null) {
995 sortManager.setViewRowHeight(row, rowHeight);
996 }
997 resizeAndRepaint();
998 }
999
1000 /**
1001 * Returns the height, in pixels, of the cells in <code>row</code>.
1002 * @param row the row whose height is to be returned
1003 * @return the height, in pixels, of the cells in the row
1004 * @since 1.3
1005 */
1006 public int getRowHeight(int row) {
1007 return (rowModel == null) ? getRowHeight() : rowModel.getSize(row);
1008 }
1009
1010 /**
1011 * Sets the amount of empty space between cells in adjacent rows.
1012 *
1013 * @param rowMargin the number of pixels between cells in a row
1014 * @see #getRowMargin
1015 */
1016 @BeanProperty(description
1017 = "The amount of space between cells.")
1018 public void setRowMargin(int rowMargin) {
1019 int old = this.rowMargin;
1020 this.rowMargin = rowMargin;
1021 resizeAndRepaint();
1022 firePropertyChange("rowMargin", old, rowMargin);
1023 }
1024
1025 /**
1026 * Gets the amount of empty space, in pixels, between cells. Equivalent to:
1027 * <code>getIntercellSpacing().height</code>.
1028 * @return the number of pixels between cells in a row
1029 *
1030 * @see #setRowMargin
1031 */
1032 public int getRowMargin() {
1033 return rowMargin;
1034 }
1035
1036 /**
1037 * Sets the <code>rowMargin</code> and the <code>columnMargin</code> --
1038 * the height and width of the space between cells -- to
1039 * <code>intercellSpacing</code>.
1040 *
1041 * @param intercellSpacing a <code>Dimension</code>
1042 * specifying the new width
1043 * and height between cells
1044 * @see #getIntercellSpacing
1045 */
1046 @BeanProperty(bound = false, description
1047 = "The spacing between the cells, drawn in the background color of the JTable.")
1048 public void setIntercellSpacing(Dimension intercellSpacing) {
1049 // Set the rowMargin here and columnMargin in the TableColumnModel
1050 setRowMargin(intercellSpacing.height);
1051 getColumnModel().setColumnMargin(intercellSpacing.width);
1052
1053 resizeAndRepaint();
1054 }
1055
1056 /**
1057 * Returns the horizontal and vertical space between cells.
1058 * The default spacing is look and feel dependent.
1059 *
1060 * @return the horizontal and vertical spacing between cells
1061 * @see #setIntercellSpacing
1062 */
1063 public Dimension getIntercellSpacing() {
1064 return new Dimension(getColumnModel().getColumnMargin(), rowMargin);
1065 }
1066
1067 /**
1068 * Sets the color used to draw grid lines to <code>gridColor</code> and redisplays.
1069 * The default color is look and feel dependent.
1070 *
1071 * @param gridColor the new color of the grid lines
1072 * @exception IllegalArgumentException if <code>gridColor</code> is <code>null</code>
1073 * @see #getGridColor
1074 */
1075 @BeanProperty(description
1076 = "The grid color.")
1077 public void setGridColor(Color gridColor) {
1078 if (gridColor == null) {
1079 throw new IllegalArgumentException("New color is null");
1080 }
1081 Color old = this.gridColor;
1082 this.gridColor = gridColor;
1083 firePropertyChange("gridColor", old, gridColor);
1084 // Redraw
1085 repaint();
1086 }
1087
1088 /**
1089 * Returns the color used to draw grid lines.
1090 * The default color is look and feel dependent.
1091 *
1092 * @return the color used to draw grid lines
1093 * @see #setGridColor
1094 */
1095 public Color getGridColor() {
1096 return gridColor;
1097 }
1098
1099 /**
1100 * Sets whether the table draws grid lines around cells.
1101 * If <code>showGrid</code> is true it does; if it is false it doesn't.
1102 * There is no <code>getShowGrid</code> method as this state is held
1103 * in two variables -- <code>showHorizontalLines</code> and <code>showVerticalLines</code> --
1104 * each of which can be queried independently.
1105 *
1106 * @param showGrid true if table view should draw grid lines
1107 *
1108 * @see #setShowVerticalLines
1109 * @see #setShowHorizontalLines
1110 */
1111 @BeanProperty(description
1112 = "The color used to draw the grid lines.")
1113 public void setShowGrid(boolean showGrid) {
1114 setShowHorizontalLines(showGrid);
1115 setShowVerticalLines(showGrid);
1116
1117 // Redraw
1118 repaint();
1119 }
1120
1121 /**
1122 * Sets whether the table draws horizontal lines between cells.
1123 * If <code>showHorizontalLines</code> is true it does; if it is false it doesn't.
1124 *
1125 * @param showHorizontalLines true if table view should draw horizontal lines
1126 * @see #getShowHorizontalLines
1127 * @see #setShowGrid
1128 * @see #setShowVerticalLines
1129 */
1130 @BeanProperty(description
1131 = "Whether horizontal lines should be drawn in between the cells.")
1132 public void setShowHorizontalLines(boolean showHorizontalLines) {
1133 boolean old = this.showHorizontalLines;
1134 this.showHorizontalLines = showHorizontalLines;
1135 firePropertyChange("showHorizontalLines", old, showHorizontalLines);
1136
1137 // Redraw
1138 repaint();
1139 }
1140
1141 /**
1142 * Sets whether the table draws vertical lines between cells.
1143 * If <code>showVerticalLines</code> is true it does; if it is false it doesn't.
1144 *
1145 * @param showVerticalLines true if table view should draw vertical lines
1146 * @see #getShowVerticalLines
1147 * @see #setShowGrid
1148 * @see #setShowHorizontalLines
1149 */
1150 @BeanProperty(description
1151 = "Whether vertical lines should be drawn in between the cells.")
1152 public void setShowVerticalLines(boolean showVerticalLines) {
1153 boolean old = this.showVerticalLines;
1154 this.showVerticalLines = showVerticalLines;
1155 firePropertyChange("showVerticalLines", old, showVerticalLines);
1156 // Redraw
1157 repaint();
1158 }
1159
1160 /**
1161 * Returns true if the table draws horizontal lines between cells, false if it
1162 * doesn't. The default value is look and feel dependent.
1163 *
1164 * @return true if the table draws horizontal lines between cells, false if it
1165 * doesn't
1166 * @see #setShowHorizontalLines
1167 */
1168 public boolean getShowHorizontalLines() {
1169 return showHorizontalLines;
1170 }
1171
1172 /**
1173 * Returns true if the table draws vertical lines between cells, false if it
1174 * doesn't. The default value is look and feel dependent.
1175 *
1176 * @return true if the table draws vertical lines between cells, false if it
1177 * doesn't
1178 * @see #setShowVerticalLines
1179 */
1180 public boolean getShowVerticalLines() {
1181 return showVerticalLines;
1182 }
1183
1184 /**
1185 * Sets the table's auto resize mode when the table is resized. For further
1186 * information on how the different resize modes work, see
1187 * {@link #doLayout}.
1188 *
1189 * @param mode One of 5 legal values:
1190 * AUTO_RESIZE_OFF,
1191 * AUTO_RESIZE_NEXT_COLUMN,
1192 * AUTO_RESIZE_SUBSEQUENT_COLUMNS,
1193 * AUTO_RESIZE_LAST_COLUMN,
1194 * AUTO_RESIZE_ALL_COLUMNS
1195 *
1196 * @see #getAutoResizeMode
1197 * @see #doLayout
1198 */
1199 @BeanProperty(enumerationValues = {
1200 "JTable.AUTO_RESIZE_OFF",
1201 "JTable.AUTO_RESIZE_NEXT_COLUMN",
1202 "JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS",
1203 "JTable.AUTO_RESIZE_LAST_COLUMN",
1204 "JTable.AUTO_RESIZE_ALL_COLUMNS"}, description
1205 = "Whether the columns should adjust themselves automatically.")
1206 public void setAutoResizeMode(int mode) {
1207 if (isValidAutoResizeMode(mode)) {
1208 int old = autoResizeMode;
1209 autoResizeMode = mode;
1210 resizeAndRepaint();
1211 if (tableHeader != null) {
1212 tableHeader.resizeAndRepaint();
1213 }
1214 firePropertyChange("autoResizeMode", old, autoResizeMode);
1215 }
1216 }
1217
1218 private static boolean isValidAutoResizeMode(int mode) {
1219 return (mode == AUTO_RESIZE_OFF)
1220 || (mode == AUTO_RESIZE_NEXT_COLUMN)
1221 || (mode == AUTO_RESIZE_SUBSEQUENT_COLUMNS)
1222 || (mode == AUTO_RESIZE_LAST_COLUMN)
1223 || (mode == AUTO_RESIZE_ALL_COLUMNS);
1224 }
1225
1226 /**
1227 * Returns the auto resize mode of the table. The default mode
1228 * is AUTO_RESIZE_SUBSEQUENT_COLUMNS.
1229 *
1230 * @return the autoResizeMode of the table
1231 *
1232 * @see #setAutoResizeMode
1233 * @see #doLayout
1234 */
1235 public int getAutoResizeMode() {
1236 return autoResizeMode;
1237 }
1238
1239 /**
1240 * Sets this table's <code>autoCreateColumnsFromModel</code> flag.
1241 * This method calls <code>createDefaultColumnsFromModel</code> if
1242 * <code>autoCreateColumnsFromModel</code> changes from false to true.
1243 *
1244 * @param autoCreateColumnsFromModel true if <code>JTable</code> should automatically create columns
1245 * @see #getAutoCreateColumnsFromModel
1246 * @see #createDefaultColumnsFromModel
1247 */
1248 @BeanProperty(description
1249 = "Automatically populates the columnModel when a new TableModel is submitted.")
1250 public void setAutoCreateColumnsFromModel(boolean autoCreateColumnsFromModel) {
1251 if (this.autoCreateColumnsFromModel != autoCreateColumnsFromModel) {
1252 boolean old = this.autoCreateColumnsFromModel;
1253 this.autoCreateColumnsFromModel = autoCreateColumnsFromModel;
1254 if (autoCreateColumnsFromModel) {
1255 createDefaultColumnsFromModel();
1256 }
1257 firePropertyChange("autoCreateColumnsFromModel", old, autoCreateColumnsFromModel);
1258 }
1259 }
1260
1261 /**
1262 * Determines whether the table will create default columns from the model.
1263 * If true, <code>setModel</code> will clear any existing columns and
1264 * create new columns from the new model. Also, if the event in
1265 * the <code>tableChanged</code> notification specifies that the
1266 * entire table changed, then the columns will be rebuilt.
1267 * The default is true.
1268 *
1269 * @return the autoCreateColumnsFromModel of the table
1270 * @see #setAutoCreateColumnsFromModel
1271 * @see #createDefaultColumnsFromModel
1272 */
1273 public boolean getAutoCreateColumnsFromModel() {
1274 return autoCreateColumnsFromModel;
1275 }
1276
1277 /**
1278 * Creates default columns for the table from
1279 * the data model using the <code>getColumnCount</code> method
1280 * defined in the <code>TableModel</code> interface.
1281 * <p>
1282 * Clears any existing columns before creating the
1283 * new columns based on information from the model.
1284 *
1285 * @see #getAutoCreateColumnsFromModel
1286 */
1287 public void createDefaultColumnsFromModel() {
1288 TableModel m = getModel();
1289 if (m != null) {
1290 // Remove any current columns
1291 TableColumnModel cm = getColumnModel();
1292 while (cm.getColumnCount() > 0) {
1293 cm.removeColumn(cm.getColumn(0));
1294 }
1295
1296 // Create new columns from the data model info
1297 for (int i = 0; i < m.getColumnCount(); i++) {
1298 TableColumn newColumn = new TableColumn(i);
1299 addColumn(newColumn);
1300 }
1301 }
1302 }
1303
1304 /**
1305 * Sets a default cell renderer to be used if no renderer has been set in
1306 * a <code>TableColumn</code>. If renderer is <code>null</code>,
1307 * removes the default renderer for this column class.
1308 *
1309 * @param columnClass set the default cell renderer for this columnClass
1310 * @param renderer default cell renderer to be used for this
1311 * columnClass
1312 * @see #getDefaultRenderer
1313 * @see #setDefaultEditor
1314 */
1315 public void setDefaultRenderer(Class<?> columnClass, TableCellRenderer renderer) {
1316 if (renderer != null) {
1317 defaultRenderersByColumnClass.put(columnClass, renderer);
1318 }
1319 else {
1320 defaultRenderersByColumnClass.remove(columnClass);
1321 }
1322 }
1323
1324 /**
1325 * Returns the cell renderer to be used when no renderer has been set in
1326 * a <code>TableColumn</code>. During the rendering of cells the renderer is fetched from
1327 * a <code>Hashtable</code> of entries according to the class of the cells in the column. If
1328 * there is no entry for this <code>columnClass</code> the method returns
1329 * the entry for the most specific superclass. The <code>JTable</code> installs entries
1330 * for <code>Object</code>, <code>Number</code>, and <code>Boolean</code>, all of which can be modified
1331 * or replaced.
1332 *
1333 * @param columnClass return the default cell renderer
1334 * for this columnClass
1335 * @return the renderer for this columnClass
1336 * @see #setDefaultRenderer
1337 * @see #getColumnClass
1338 */
1339 public TableCellRenderer getDefaultRenderer(Class<?> columnClass) {
1340 if (columnClass == null) {
1341 return null;
1342 }
1343 else {
1344 Object renderer = defaultRenderersByColumnClass.get(columnClass);
1345 if (renderer != null) {
1346 return (TableCellRenderer)renderer;
1347 }
1348 else {
1349 Class<?> c = columnClass.getSuperclass();
1350 if (c == null && columnClass != Object.class) {
1351 c = Object.class;
1352 }
1353 return getDefaultRenderer(c);
1354 }
1355 }
1356 }
1357
1358 /**
1359 * Sets a default cell editor to be used if no editor has been set in
1360 * a <code>TableColumn</code>. If no editing is required in a table, or a
1361 * particular column in a table, uses the <code>isCellEditable</code>
1362 * method in the <code>TableModel</code> interface to ensure that this
1363 * <code>JTable</code> will not start an editor in these columns.
1364 * If editor is <code>null</code>, removes the default editor for this
1365 * column class.
1366 *
1367 * @param columnClass set the default cell editor for this columnClass
1368 * @param editor default cell editor to be used for this columnClass
1369 * @see TableModel#isCellEditable
1370 * @see #getDefaultEditor
1371 * @see #setDefaultRenderer
1372 */
1373 public void setDefaultEditor(Class<?> columnClass, TableCellEditor editor) {
1374 if (editor != null) {
1375 defaultEditorsByColumnClass.put(columnClass, editor);
1376 }
1377 else {
1378 defaultEditorsByColumnClass.remove(columnClass);
1379 }
1380 }
1381
1382 /**
1383 * Returns the editor to be used when no editor has been set in
1384 * a <code>TableColumn</code>. During the editing of cells the editor is fetched from
1385 * a <code>Hashtable</code> of entries according to the class of the cells in the column. If
1386 * there is no entry for this <code>columnClass</code> the method returns
1387 * the entry for the most specific superclass. The <code>JTable</code> installs entries
1388 * for <code>Object</code>, <code>Number</code>, and <code>Boolean</code>, all of which can be modified
1389 * or replaced.
1390 *
1391 * @param columnClass return the default cell editor for this columnClass
1392 * @return the default cell editor to be used for this columnClass
1393 * @see #setDefaultEditor
1394 * @see #getColumnClass
1395 */
1396 public TableCellEditor getDefaultEditor(Class<?> columnClass) {
1397 if (columnClass == null) {
1398 return null;
1399 }
1400 else {
1401 Object editor = defaultEditorsByColumnClass.get(columnClass);
1402 if (editor != null) {
1403 return (TableCellEditor)editor;
1404 }
1405 else {
1406 return getDefaultEditor(columnClass.getSuperclass());
1407 }
1408 }
1409 }
1410
1411 /**
1412 * Turns on or off automatic drag handling. In order to enable automatic
1413 * drag handling, this property should be set to {@code true}, and the
1414 * table's {@code TransferHandler} needs to be {@code non-null}.
1415 * The default value of the {@code dragEnabled} property is {@code false}.
1416 * <p>
1417 * The job of honoring this property, and recognizing a user drag gesture,
1418 * lies with the look and feel implementation, and in particular, the table's
1419 * {@code TableUI}. When automatic drag handling is enabled, most look and
1420 * feels (including those that subclass {@code BasicLookAndFeel}) begin a
1421 * drag and drop operation whenever the user presses the mouse button over
1422 * an item (in single selection mode) or a selection (in other selection
1423 * modes) and then moves the mouse a few pixels. Setting this property to
1424 * {@code true} can therefore have a subtle effect on how selections behave.
1425 * <p>
1426 * If a look and feel is used that ignores this property, you can still
1427 * begin a drag and drop operation by calling {@code exportAsDrag} on the
1428 * table's {@code TransferHandler}.
1429 *
1430 * @param b whether or not to enable automatic drag handling
1431 * @exception HeadlessException if
1432 * <code>b</code> is <code>true</code> and
1433 * <code>GraphicsEnvironment.isHeadless()</code>
1434 * returns <code>true</code>
1435 * @see java.awt.GraphicsEnvironment#isHeadless
1436 * @see #getDragEnabled
1437 * @see #setTransferHandler
1438 * @see TransferHandler
1439 * @since 1.4
1440 */
1441 @BeanProperty(bound = false, description
1442 = "determines whether automatic drag handling is enabled")
1443 public void setDragEnabled(boolean b) {
1444 checkDragEnabled(b);
1445 dragEnabled = b;
1446 }
1447
1448 private void checkDragEnabled(boolean b) {
1449 if (b && GraphicsEnvironment.isHeadless()) {
1450 throw new HeadlessException();
1451 }
1452 }
1453
1454 /**
1455 * Returns whether or not automatic drag handling is enabled.
1456 *
1457 * @return the value of the {@code dragEnabled} property
1458 * @see #setDragEnabled
1459 * @since 1.4
1460 */
1461 public boolean getDragEnabled() {
1462 return dragEnabled;
1463 }
1464
1465 /**
1466 * Sets the drop mode for this component. For backward compatibility,
1467 * the default for this property is <code>DropMode.USE_SELECTION</code>.
1468 * Usage of one of the other modes is recommended, however, for an
1469 * improved user experience. <code>DropMode.ON</code>, for instance,
1470 * offers similar behavior of showing items as selected, but does so without
1471 * affecting the actual selection in the table.
1472 * <p>
1473 * <code>JTable</code> supports the following drop modes:
1474 * <ul>
1475 * <li><code>DropMode.USE_SELECTION</code></li>
1476 * <li><code>DropMode.ON</code></li>
1477 * <li><code>DropMode.INSERT</code></li>
1478 * <li><code>DropMode.INSERT_ROWS</code></li>
1479 * <li><code>DropMode.INSERT_COLS</code></li>
1480 * <li><code>DropMode.ON_OR_INSERT</code></li>
1481 * <li><code>DropMode.ON_OR_INSERT_ROWS</code></li>
1482 * <li><code>DropMode.ON_OR_INSERT_COLS</code></li>
1483 * </ul>
1484 * <p>
1485 * The drop mode is only meaningful if this component has a
1486 * <code>TransferHandler</code> that accepts drops.
1487 *
1488 * @param dropMode the drop mode to use
1489 * @throws IllegalArgumentException if the drop mode is unsupported
1490 * or <code>null</code>
1491 * @see #getDropMode
1492 * @see #getDropLocation
1493 * @see #setTransferHandler
1494 * @see TransferHandler
1495 * @since 1.6
1496 */
1497 public final void setDropMode(DropMode dropMode) {
1498 checkDropMode(dropMode);
1499 this.dropMode = dropMode;
1500 }
1501
1502 private static void checkDropMode(DropMode dropMode) {
1503 if (dropMode != null) {
1504 switch (dropMode) {
1505 case USE_SELECTION:
1506 case ON:
1507 case INSERT:
1508 case INSERT_ROWS:
1509 case INSERT_COLS:
1510 case ON_OR_INSERT:
1511 case ON_OR_INSERT_ROWS:
1512 case ON_OR_INSERT_COLS:
1513 return;
1514 }
1515 }
1516 throw new IllegalArgumentException(dropMode
1517 + ": Unsupported drop mode for table");
1518 }
1519 /**
1520 * Returns the drop mode for this component.
1521 *
1522 * @return the drop mode for this component
1523 * @see #setDropMode
1524 * @since 1.6
1525 */
1526 public final DropMode getDropMode() {
1527 return dropMode;
1528 }
1529
1530 /**
1531 * Calculates a drop location in this component, representing where a
1532 * drop at the given point should insert data.
1533 *
1534 * @param p the point to calculate a drop location for
1535 * @return the drop location, or <code>null</code>
1536 */
1537 DropLocation dropLocationForPoint(Point p) {
1538 DropLocation location = null;
1539
1540 int row = rowAtPoint(p);
1541 int col = columnAtPoint(p);
1542 boolean outside = Boolean.TRUE == getClientProperty("Table.isFileList")
1543 && SwingUtilities2.pointOutsidePrefSize(this, row, col, p);
1544
1545 Rectangle rect = getCellRect(row, col, true);
1546 Section xSection, ySection;
1547 boolean between = false;
1548 boolean ltr = getComponentOrientation().isLeftToRight();
1549
1550 switch(dropMode) {
1551 case USE_SELECTION:
1552 case ON:
1553 if (row == -1 || col == -1 || outside) {
1554 location = new DropLocation(p, -1, -1, false, false);
1555 } else {
1556 location = new DropLocation(p, row, col, false, false);
1557 }
1558 break;
1559 case INSERT:
1560 if (row == -1 && col == -1) {
1561 location = new DropLocation(p, 0, 0, true, true);
1562 break;
1563 }
1564
1565 xSection = SwingUtilities2.liesInHorizontal(rect, p, ltr, true);
1566
1567 if (row == -1) {
1568 if (xSection == LEADING) {
1569 location = new DropLocation(p, getRowCount(), col, true, true);
1570 } else if (xSection == TRAILING) {
1571 location = new DropLocation(p, getRowCount(), col + 1, true, true);
1572 } else {
1573 location = new DropLocation(p, getRowCount(), col, true, false);
1574 }
1575 } else if (xSection == LEADING || xSection == TRAILING) {
1576 ySection = SwingUtilities2.liesInVertical(rect, p, true);
1577 if (ySection == LEADING) {
1578 between = true;
1579 } else if (ySection == TRAILING) {
1580 row++;
1581 between = true;
1582 }
1583
1584 location = new DropLocation(p, row,
1585 xSection == TRAILING ? col + 1 : col,
1586 between, true);
1587 } else {
1588 if (SwingUtilities2.liesInVertical(rect, p, false) == TRAILING) {
1589 row++;
1590 }
1591
1592 location = new DropLocation(p, row, col, true, false);
1593 }
1594
1595 break;
1596 case INSERT_ROWS:
1597 if (row == -1 && col == -1) {
1598 location = new DropLocation(p, -1, -1, false, false);
1599 break;
1600 }
1601
1602 if (row == -1) {
1603 location = new DropLocation(p, getRowCount(), col, true, false);
1604 break;
1605 }
1606
1607 if (SwingUtilities2.liesInVertical(rect, p, false) == TRAILING) {
1608 row++;
1609 }
1610
1611 location = new DropLocation(p, row, col, true, false);
1612 break;
1613 case ON_OR_INSERT_ROWS:
1614 if (row == -1 && col == -1) {
1615 location = new DropLocation(p, -1, -1, false, false);
1616 break;
1617 }
1618
1619 if (row == -1) {
1620 location = new DropLocation(p, getRowCount(), col, true, false);
1621 break;
1622 }
1623
1624 ySection = SwingUtilities2.liesInVertical(rect, p, true);
1625 if (ySection == LEADING) {
1626 between = true;
1627 } else if (ySection == TRAILING) {
1628 row++;
1629 between = true;
1630 }
1631
1632 location = new DropLocation(p, row, col, between, false);
1633 break;
1634 case INSERT_COLS:
1635 if (row == -1) {
1636 location = new DropLocation(p, -1, -1, false, false);
1637 break;
1638 }
1639
1640 if (col == -1) {
1641 location = new DropLocation(p, getColumnCount(), col, false, true);
1642 break;
1643 }
1644
1645 if (SwingUtilities2.liesInHorizontal(rect, p, ltr, false) == TRAILING) {
1646 col++;
1647 }
1648
1649 location = new DropLocation(p, row, col, false, true);
1650 break;
1651 case ON_OR_INSERT_COLS:
1652 if (row == -1) {
1653 location = new DropLocation(p, -1, -1, false, false);
1654 break;
1655 }
1656
1657 if (col == -1) {
1658 location = new DropLocation(p, row, getColumnCount(), false, true);
1659 break;
1660 }
1661
1662 xSection = SwingUtilities2.liesInHorizontal(rect, p, ltr, true);
1663 if (xSection == LEADING) {
1664 between = true;
1665 } else if (xSection == TRAILING) {
1666 col++;
1667 between = true;
1668 }
1669
1670 location = new DropLocation(p, row, col, false, between);
1671 break;
1672 case ON_OR_INSERT:
1673 if (row == -1 && col == -1) {
1674 location = new DropLocation(p, 0, 0, true, true);
1675 break;
1676 }
1677
1678 xSection = SwingUtilities2.liesInHorizontal(rect, p, ltr, true);
1679
1680 if (row == -1) {
1681 if (xSection == LEADING) {
1682 location = new DropLocation(p, getRowCount(), col, true, true);
1683 } else if (xSection == TRAILING) {
1684 location = new DropLocation(p, getRowCount(), col + 1, true, true);
1685 } else {
1686 location = new DropLocation(p, getRowCount(), col, true, false);
1687 }
1688
1689 break;
1690 }
1691
1692 ySection = SwingUtilities2.liesInVertical(rect, p, true);
1693 if (ySection == LEADING) {
1694 between = true;
1695 } else if (ySection == TRAILING) {
1696 row++;
1697 between = true;
1698 }
1699
1700 location = new DropLocation(p, row,
1701 xSection == TRAILING ? col + 1 : col,
1702 between,
1703 xSection != MIDDLE);
1704
1705 break;
1706 default:
1707 assert false : "Unexpected drop mode";
1708 }
1709
1710 return location;
1711 }
1712
1713 /**
1714 * Called to set or clear the drop location during a DnD operation.
1715 * In some cases, the component may need to use it's internal selection
1716 * temporarily to indicate the drop location. To help facilitate this,
1717 * this method returns and accepts as a parameter a state object.
1718 * This state object can be used to store, and later restore, the selection
1719 * state. Whatever this method returns will be passed back to it in
1720 * future calls, as the state parameter. If it wants the DnD system to
1721 * continue storing the same state, it must pass it back every time.
1722 * Here's how this is used:
1723 * <p>
1724 * Let's say that on the first call to this method the component decides
1725 * to save some state (because it is about to use the selection to show
1726 * a drop index). It can return a state object to the caller encapsulating
1727 * any saved selection state. On a second call, let's say the drop location
1728 * is being changed to something else. The component doesn't need to
1729 * restore anything yet, so it simply passes back the same state object
1730 * to have the DnD system continue storing it. Finally, let's say this
1731 * method is messaged with <code>null</code>. This means DnD
1732 * is finished with this component for now, meaning it should restore
1733 * state. At this point, it can use the state parameter to restore
1734 * said state, and of course return <code>null</code> since there's
1735 * no longer anything to store.
1736 *
1737 * @param location the drop location (as calculated by
1738 * <code>dropLocationForPoint</code>) or <code>null</code>
1739 * if there's no longer a valid drop location
1740 * @param state the state object saved earlier for this component,
1741 * or <code>null</code>
1742 * @param forDrop whether or not the method is being called because an
1743 * actual drop occurred
1744 * @return any saved state for this component, or <code>null</code> if none
1745 */
1746 Object setDropLocation(TransferHandler.DropLocation location,
1747 Object state,
1748 boolean forDrop) {
1749
1750 Object retVal = null;
1751 DropLocation tableLocation = (DropLocation)location;
1752
1753 if (dropMode == DropMode.USE_SELECTION) {
1754 if (tableLocation == null) {
1755 if (!forDrop && state != null) {
1756 clearSelection();
1757
1758 int[] rows = ((int[][])state)[0];
1759 int[] cols = ((int[][])state)[1];
1760 int[] anchleads = ((int[][])state)[2];
1761
1762 for (int row : rows) {
1763 addRowSelectionInterval(row, row);
1764 }
1765
1766 for (int col : cols) {
1767 addColumnSelectionInterval(col, col);
1768 }
1769
1770 SwingUtilities2.setLeadAnchorWithoutSelection(
1771 getSelectionModel(), anchleads[1], anchleads[0]);
1772
1773 SwingUtilities2.setLeadAnchorWithoutSelection(
1774 getColumnModel().getSelectionModel(),
1775 anchleads[3], anchleads[2]);
1776 }
1777 } else {
1778 if (dropLocation == null) {
1779 retVal = new int[][]{
1780 getSelectedRows(),
1781 getSelectedColumns(),
1782 {getAdjustedIndex(getSelectionModel()
1783 .getAnchorSelectionIndex(), true),
1784 getAdjustedIndex(getSelectionModel()
1785 .getLeadSelectionIndex(), true),
1786 getAdjustedIndex(getColumnModel().getSelectionModel()
1787 .getAnchorSelectionIndex(), false),
1788 getAdjustedIndex(getColumnModel().getSelectionModel()
1789 .getLeadSelectionIndex(), false)}};
1790 } else {
1791 retVal = state;
1792 }
1793
1794 if (tableLocation.getRow() == -1) {
1795 clearSelectionAndLeadAnchor();
1796 } else {
1797 setRowSelectionInterval(tableLocation.getRow(),
1798 tableLocation.getRow());
1799 setColumnSelectionInterval(tableLocation.getColumn(),
1800 tableLocation.getColumn());
1801 }
1802 }
1803 }
1804
1805 DropLocation old = dropLocation;
1806 dropLocation = tableLocation;
1807 firePropertyChange("dropLocation", old, dropLocation);
1808
1809 return retVal;
1810 }
1811
1812 /**
1813 * Returns the location that this component should visually indicate
1814 * as the drop location during a DnD operation over the component,
1815 * or {@code null} if no location is to currently be shown.
1816 * <p>
1817 * This method is not meant for querying the drop location
1818 * from a {@code TransferHandler}, as the drop location is only
1819 * set after the {@code TransferHandler}'s <code>canImport</code>
1820 * has returned and has allowed for the location to be shown.
1821 * <p>
1822 * When this property changes, a property change event with
1823 * name "dropLocation" is fired by the component.
1824 *
1825 * @return the drop location
1826 * @see #setDropMode
1827 * @see TransferHandler#canImport(TransferHandler.TransferSupport)
1828 * @since 1.6
1829 */
1830 @BeanProperty(bound = false)
1831 public final DropLocation getDropLocation() {
1832 return dropLocation;
1833 }
1834
1835 /**
1836 * Specifies whether a {@code RowSorter} should be created for the
1837 * table whenever its model changes.
1838 * <p>
1839 * When {@code setAutoCreateRowSorter(true)} is invoked, a {@code
1840 * TableRowSorter} is immediately created and installed on the
1841 * table. While the {@code autoCreateRowSorter} property remains
1842 * {@code true}, every time the model is changed, a new {@code
1843 * TableRowSorter} is created and set as the table's row sorter.
1844 * The default value for the {@code autoCreateRowSorter}
1845 * property is {@code false}.
1846 *
1847 * @param autoCreateRowSorter whether or not a {@code RowSorter}
1848 * should be automatically created
1849 * @see javax.swing.table.TableRowSorter
1850 * @since 1.6
1851 */
1852 @BeanProperty(preferred = true, description
1853 = "Whether or not to turn on sorting by default.")
1854 public void setAutoCreateRowSorter(boolean autoCreateRowSorter) {
1855 boolean oldValue = this.autoCreateRowSorter;
1856 this.autoCreateRowSorter = autoCreateRowSorter;
1857 if (autoCreateRowSorter) {
1858 setRowSorter(new TableRowSorter<TableModel>(getModel()));
1859 }
1860 firePropertyChange("autoCreateRowSorter", oldValue,
1861 autoCreateRowSorter);
1862 }
1863
1864 /**
1865 * Returns {@code true} if whenever the model changes, a new
1866 * {@code RowSorter} should be created and installed
1867 * as the table's sorter; otherwise, returns {@code false}.
1868 *
1869 * @return true if a {@code RowSorter} should be created when
1870 * the model changes
1871 * @since 1.6
1872 */
1873 public boolean getAutoCreateRowSorter() {
1874 return autoCreateRowSorter;
1875 }
1876
1877 /**
1878 * Specifies whether the selection should be updated after sorting.
1879 * If true, on sorting the selection is reset such that
1880 * the same rows, in terms of the model, remain selected. The default
1881 * is true.
1882 *
1883 * @param update whether or not to update the selection on sorting
1884 * @since 1.6
1885 */
1886 @BeanProperty(expert = true, description
1887 = "Whether or not to update the selection on sorting")
1888 public void setUpdateSelectionOnSort(boolean update) {
1889 if (updateSelectionOnSort != update) {
1890 updateSelectionOnSort = update;
1891 firePropertyChange("updateSelectionOnSort", !update, update);
1892 }
1893 }
1894
1895 /**
1896 * Returns true if the selection should be updated after sorting.
1897 *
1898 * @return whether to update the selection on a sort
1899 * @since 1.6
1900 */
1901 public boolean getUpdateSelectionOnSort() {
1902 return updateSelectionOnSort;
1903 }
1904
1905 /**
1906 * Sets the <code>RowSorter</code>. <code>RowSorter</code> is used
1907 * to provide sorting and filtering to a <code>JTable</code>.
1908 * <p>
1909 * This method clears the selection and resets any variable row heights.
1910 * <p>
1911 * This method fires a <code>PropertyChangeEvent</code> when appropriate,
1912 * with the property name <code>"rowSorter"</code>. For
1913 * backward-compatibility, this method fires an additional event with the
1914 * property name <code>"sorter"</code>.
1915 * <p>
1916 * If the underlying model of the <code>RowSorter</code> differs from
1917 * that of this <code>JTable</code> undefined behavior will result.
1918 *
1919 * @param sorter the <code>RowSorter</code>; <code>null</code> turns
1920 * sorting off
1921 * @see javax.swing.table.TableRowSorter
1922 * @since 1.6
1923 */
1924 @BeanProperty(description
1925 = "The table's RowSorter")
1926 public void setRowSorter(RowSorter<? extends TableModel> sorter) {
1927 RowSorter<? extends TableModel> oldRowSorter = null;
1928 if (sortManager != null) {
1929 oldRowSorter = sortManager.sorter;
1930 sortManager.dispose();
1931 sortManager = null;
1932 }
1933 rowModel = null;
1934 clearSelectionAndLeadAnchor();
1935 if (sorter != null) {
1936 sortManager = new SortManager(sorter);
1937 }
1938 resizeAndRepaint();
1939 firePropertyChange("rowSorter", oldRowSorter, sorter);
1940 firePropertyChange("sorter", oldRowSorter, sorter);
1941 }
1942
1943 /**
1944 * Returns the object responsible for sorting.
1945 *
1946 * @return the object responsible for sorting
1947 * @since 1.6
1948 */
1949 public RowSorter<? extends TableModel> getRowSorter() {
1950 return (sortManager != null) ? sortManager.sorter : null;
1951 }
1952
1953 //
1954 // Selection methods
1955 //
1956 /**
1957 * Sets the table's selection mode to allow only single selections, a single
1958 * contiguous interval, or multiple intervals.
1959 * <P>
1960 * <b>Note:</b>
1961 * <code>JTable</code> provides all the methods for handling
1962 * column and row selection. When setting states,
1963 * such as <code>setSelectionMode</code>, it not only
1964 * updates the mode for the row selection model but also sets similar
1965 * values in the selection model of the <code>columnModel</code>.
1966 * If you want to have the row and column selection models operating
1967 * in different modes, set them both directly.
1968 * <p>
1969 * Both the row and column selection models for <code>JTable</code>
1970 * default to using a <code>DefaultListSelectionModel</code>
1971 * so that <code>JTable</code> works the same way as the
1972 * <code>JList</code>. See the <code>setSelectionMode</code> method
1973 * in <code>JList</code> for details about the modes.
1974 *
1975 * @param selectionMode the mode used by the row and column selection models
1976 * @see JList#setSelectionMode
1977 */
1978 @BeanProperty(enumerationValues = {
1979 "ListSelectionModel.SINGLE_SELECTION",
1980 "ListSelectionModel.SINGLE_INTERVAL_SELECTION",
1981 "ListSelectionModel.MULTIPLE_INTERVAL_SELECTION"}, description
1982 = "The selection mode used by the row and column selection models.")
1983 public void setSelectionMode(int selectionMode) {
1984 clearSelection();
1985 getSelectionModel().setSelectionMode(selectionMode);
1986 getColumnModel().getSelectionModel().setSelectionMode(selectionMode);
1987 }
1988
1989 /**
1990 * Sets whether the rows in this model can be selected.
1991 *
1992 * @param rowSelectionAllowed true if this model will allow row selection
1993 * @see #getRowSelectionAllowed
1994 */
1995 @BeanProperty(visualUpdate = true, description
1996 = "If true, an entire row is selected for each selected cell.")
1997 public void setRowSelectionAllowed(boolean rowSelectionAllowed) {
1998 boolean old = this.rowSelectionAllowed;
1999 this.rowSelectionAllowed = rowSelectionAllowed;
2000 if (old != rowSelectionAllowed) {
2001 repaint();
2002 }
2003 firePropertyChange("rowSelectionAllowed", old, rowSelectionAllowed);
2004 }
2005
2006 /**
2007 * Returns true if rows can be selected.
2008 *
2009 * @return true if rows can be selected, otherwise false
2010 * @see #setRowSelectionAllowed
2011 */
2012 public boolean getRowSelectionAllowed() {
2013 return rowSelectionAllowed;
2014 }
2015
2016 /**
2017 * Sets whether the columns in this model can be selected.
2018 *
2019 * @param columnSelectionAllowed true if this model will allow column selection
2020 * @see #getColumnSelectionAllowed
2021 */
2022 @BeanProperty(visualUpdate = true, description
2023 = "If true, an entire column is selected for each selected cell.")
2024 public void setColumnSelectionAllowed(boolean columnSelectionAllowed) {
2025 boolean old = columnModel.getColumnSelectionAllowed();
2026 columnModel.setColumnSelectionAllowed(columnSelectionAllowed);
2027 if (old != columnSelectionAllowed) {
2028 repaint();
2029 }
2030 firePropertyChange("columnSelectionAllowed", old, columnSelectionAllowed);
2031 }
2032
2033 /**
2034 * Returns true if columns can be selected.
2035 *
2036 * @return true if columns can be selected, otherwise false
2037 * @see #setColumnSelectionAllowed
2038 */
2039 public boolean getColumnSelectionAllowed() {
2040 return columnModel.getColumnSelectionAllowed();
2041 }
2042
2043 /**
2044 * Sets whether this table allows both a column selection and a
2045 * row selection to exist simultaneously. When set,
2046 * the table treats the intersection of the row and column selection
2047 * models as the selected cells. Override <code>isCellSelected</code> to
2048 * change this default behavior. This method is equivalent to setting
2049 * both the <code>rowSelectionAllowed</code> property and
2050 * <code>columnSelectionAllowed</code> property of the
2051 * <code>columnModel</code> to the supplied value.
2052 *
2053 * @param cellSelectionEnabled true if simultaneous row and column
2054 * selection is allowed
2055 * @see #getCellSelectionEnabled
2056 * @see #isCellSelected
2057 */
2058 @BeanProperty(visualUpdate = true, description
2059 = "Select a rectangular region of cells rather than rows or columns.")
2060 public void setCellSelectionEnabled(boolean cellSelectionEnabled) {
2061 setRowSelectionAllowed(cellSelectionEnabled);
2062 setColumnSelectionAllowed(cellSelectionEnabled);
2063 boolean old = this.cellSelectionEnabled;
2064 this.cellSelectionEnabled = cellSelectionEnabled;
2065 firePropertyChange("cellSelectionEnabled", old, cellSelectionEnabled);
2066 }
2067
2068 /**
2069 * Returns true if both row and column selection models are enabled.
2070 * Equivalent to <code>getRowSelectionAllowed() &&
2071 * getColumnSelectionAllowed()</code>.
2072 *
2073 * @return true if both row and column selection models are enabled
2074 *
2075 * @see #setCellSelectionEnabled
2076 */
2077 public boolean getCellSelectionEnabled() {
2078 return getRowSelectionAllowed() && getColumnSelectionAllowed();
2079 }
2080
2081 /**
2082 * Selects all rows, columns, and cells in the table.
2083 */
2084 public void selectAll() {
2085 // If I'm currently editing, then I should stop editing
2086 if (isEditing()) {
2087 removeEditor();
2088 }
2089 if (getRowCount() > 0 && getColumnCount() > 0) {
2090 int oldLead;
2091 int oldAnchor;
2092 ListSelectionModel selModel;
2093
2094 selModel = selectionModel;
2095 selModel.setValueIsAdjusting(true);
2096 oldLead = getAdjustedIndex(selModel.getLeadSelectionIndex(), true);
2097 oldAnchor = getAdjustedIndex(selModel.getAnchorSelectionIndex(), true);
2098
2099 setRowSelectionInterval(0, getRowCount()-1);
2100
2101 // this is done to restore the anchor and lead
2102 SwingUtilities2.setLeadAnchorWithoutSelection(selModel, oldLead, oldAnchor);
2103
2104 selModel.setValueIsAdjusting(false);
2105
2106 selModel = columnModel.getSelectionModel();
2107 selModel.setValueIsAdjusting(true);
2108 oldLead = getAdjustedIndex(selModel.getLeadSelectionIndex(), false);
2109 oldAnchor = getAdjustedIndex(selModel.getAnchorSelectionIndex(), false);
2110
2111 setColumnSelectionInterval(0, getColumnCount()-1);
2112
2113 // this is done to restore the anchor and lead
2114 SwingUtilities2.setLeadAnchorWithoutSelection(selModel, oldLead, oldAnchor);
2115
2116 selModel.setValueIsAdjusting(false);
2117 }
2118 }
2119
2120 /**
2121 * Deselects all selected columns and rows.
2122 */
2123 public void clearSelection() {
2124 selectionModel.clearSelection();
2125 columnModel.getSelectionModel().clearSelection();
2126 }
2127
2128 private void clearSelectionAndLeadAnchor() {
2129 selectionModel.setValueIsAdjusting(true);
2130 columnModel.getSelectionModel().setValueIsAdjusting(true);
2131
2132 clearSelection();
2133
2134 selectionModel.setAnchorSelectionIndex(-1);
2135 selectionModel.setLeadSelectionIndex(-1);
2136 columnModel.getSelectionModel().setAnchorSelectionIndex(-1);
2137 columnModel.getSelectionModel().setLeadSelectionIndex(-1);
2138
2139 selectionModel.setValueIsAdjusting(false);
2140 columnModel.getSelectionModel().setValueIsAdjusting(false);
2141 }
2142
2143 private int getAdjustedIndex(int index, boolean row) {
2144 int compare = row ? getRowCount() : getColumnCount();
2145 return index < compare ? index : -1;
2146 }
2147
2148 private int boundRow(int row) throws IllegalArgumentException {
2149 if (row < 0 || row >= getRowCount()) {
2150 throw new IllegalArgumentException("Row index out of range");
2151 }
2152 return row;
2153 }
2154
2155 private int boundColumn(int col) {
2156 if (col< 0 || col >= getColumnCount()) {
2157 throw new IllegalArgumentException("Column index out of range");
2158 }
2159 return col;
2160 }
2161
2162 /**
2163 * Selects the rows from <code>index0</code> to <code>index1</code>,
2164 * inclusive.
2165 *
2166 * @exception IllegalArgumentException if <code>index0</code> or
2167 * <code>index1</code> lie outside
2168 * [0, <code>getRowCount()</code>-1]
2169 * @param index0 one end of the interval
2170 * @param index1 the other end of the interval
2171 */
2172 public void setRowSelectionInterval(int index0, int index1) {
2173 selectionModel.setSelectionInterval(boundRow(index0), boundRow(index1));
2174 }
2175
2176 /**
2177 * Selects the columns from <code>index0</code> to <code>index1</code>,
2178 * inclusive.
2179 *
2180 * @exception IllegalArgumentException if <code>index0</code> or
2181 * <code>index1</code> lie outside
2182 * [0, <code>getColumnCount()</code>-1]
2183 * @param index0 one end of the interval
2184 * @param index1 the other end of the interval
2185 */
2186 public void setColumnSelectionInterval(int index0, int index1) {
2187 columnModel.getSelectionModel().setSelectionInterval(boundColumn(index0), boundColumn(index1));
2188 }
2189
2190 /**
2191 * Adds the rows from <code>index0</code> to <code>index1</code>, inclusive, to
2192 * the current selection.
2193 *
2194 * @exception IllegalArgumentException if <code>index0</code> or <code>index1</code>
2195 * lie outside [0, <code>getRowCount()</code>-1]
2196 * @param index0 one end of the interval
2197 * @param index1 the other end of the interval
2198 */
2199 public void addRowSelectionInterval(int index0, int index1) {
2200 selectionModel.addSelectionInterval(boundRow(index0), boundRow(index1));
2201 }
2202
2203 /**
2204 * Adds the columns from <code>index0</code> to <code>index1</code>,
2205 * inclusive, to the current selection.
2206 *
2207 * @exception IllegalArgumentException if <code>index0</code> or
2208 * <code>index1</code> lie outside
2209 * [0, <code>getColumnCount()</code>-1]
2210 * @param index0 one end of the interval
2211 * @param index1 the other end of the interval
2212 */
2213 public void addColumnSelectionInterval(int index0, int index1) {
2214 columnModel.getSelectionModel().addSelectionInterval(boundColumn(index0), boundColumn(index1));
2215 }
2216
2217 /**
2218 * Deselects the rows from <code>index0</code> to <code>index1</code>, inclusive.
2219 *
2220 * @exception IllegalArgumentException if <code>index0</code> or
2221 * <code>index1</code> lie outside
2222 * [0, <code>getRowCount()</code>-1]
2223 * @param index0 one end of the interval
2224 * @param index1 the other end of the interval
2225 */
2226 public void removeRowSelectionInterval(int index0, int index1) {
2227 selectionModel.removeSelectionInterval(boundRow(index0), boundRow(index1));
2228 }
2229
2230 /**
2231 * Deselects the columns from <code>index0</code> to <code>index1</code>, inclusive.
2232 *
2233 * @exception IllegalArgumentException if <code>index0</code> or
2234 * <code>index1</code> lie outside
2235 * [0, <code>getColumnCount()</code>-1]
2236 * @param index0 one end of the interval
2237 * @param index1 the other end of the interval
2238 */
2239 public void removeColumnSelectionInterval(int index0, int index1) {
2240 columnModel.getSelectionModel().removeSelectionInterval(boundColumn(index0), boundColumn(index1));
2241 }
2242
2243 /**
2244 * Returns the index of the first selected row, -1 if no row is selected.
2245 * @return the index of the first selected row
2246 */
2247 @BeanProperty(bound = false)
2248 public int getSelectedRow() {
2249 return selectionModel.getMinSelectionIndex();
2250 }
2251
2252 /**
2253 * Returns the index of the first selected column,
2254 * -1 if no column is selected.
2255 * @return the index of the first selected column
2256 */
2257 @BeanProperty(bound = false)
2258 public int getSelectedColumn() {
2259 return columnModel.getSelectionModel().getMinSelectionIndex();
2260 }
2261
2262 /**
2263 * Returns the indices of all selected rows.
2264 *
2265 * @return an array of integers containing the indices of all selected rows,
2266 * or an empty array if no row is selected
2267 * @see #getSelectedRow
2268 */
2269 @BeanProperty(bound = false)
2270 public int[] getSelectedRows() {
2271 int iMin = selectionModel.getMinSelectionIndex();
2272 int iMax = selectionModel.getMaxSelectionIndex();
2273
2274 if ((iMin == -1) || (iMax == -1)) {
2275 return new int[0];
2276 }
2277
2278 int[] rvTmp = new int[1+ (iMax - iMin)];
2279 int n = 0;
2280 for(int i = iMin; i <= iMax; i++) {
2281 if (selectionModel.isSelectedIndex(i)) {
2282 rvTmp[n++] = i;
2283 }
2284 }
2285 int[] rv = new int[n];
2286 System.arraycopy(rvTmp, 0, rv, 0, n);
2287 return rv;
2288 }
2289
2290 /**
2291 * Returns the indices of all selected columns.
2292 *
2293 * @return an array of integers containing the indices of all selected columns,
2294 * or an empty array if no column is selected
2295 * @see #getSelectedColumn
2296 */
2297 @BeanProperty(bound = false)
2298 public int[] getSelectedColumns() {
2299 return columnModel.getSelectedColumns();
2300 }
2301
2302 /**
2303 * Returns the number of selected rows.
2304 *
2305 * @return the number of selected rows, 0 if no rows are selected
2306 */
2307 @BeanProperty(bound = false)
2308 public int getSelectedRowCount() {
2309 int iMin = selectionModel.getMinSelectionIndex();
2310 int iMax = selectionModel.getMaxSelectionIndex();
2311 int count = 0;
2312
2313 for(int i = iMin; i <= iMax; i++) {
2314 if (selectionModel.isSelectedIndex(i)) {
2315 count++;
2316 }
2317 }
2318 return count;
2319 }
2320
2321 /**
2322 * Returns the number of selected columns.
2323 *
2324 * @return the number of selected columns, 0 if no columns are selected
2325 */
2326 @BeanProperty(bound = false)
2327 public int getSelectedColumnCount() {
2328 return columnModel.getSelectedColumnCount();
2329 }
2330
2331 /**
2332 * Returns true if the specified index is in the valid range of rows,
2333 * and the row at that index is selected.
2334 *
2335 * @param row a row in the row model
2336 * @return true if <code>row</code> is a valid index and the row at
2337 * that index is selected (where 0 is the first row)
2338 */
2339 public boolean isRowSelected(int row) {
2340 return selectionModel.isSelectedIndex(row);
2341 }
2342
2343 /**
2344 * Returns true if the specified index is in the valid range of columns,
2345 * and the column at that index is selected.
2346 *
2347 * @param column the column in the column model
2348 * @return true if <code>column</code> is a valid index and the column at
2349 * that index is selected (where 0 is the first column)
2350 */
2351 public boolean isColumnSelected(int column) {
2352 return columnModel.getSelectionModel().isSelectedIndex(column);
2353 }
2354
2355 /**
2356 * Returns true if the specified indices are in the valid range of rows
2357 * and columns and the cell at the specified position is selected.
2358 * @param row the row being queried
2359 * @param column the column being queried
2360 *
2361 * @return true if <code>row</code> and <code>column</code> are valid indices
2362 * and the cell at index <code>(row, column)</code> is selected,
2363 * where the first row and first column are at index 0
2364 */
2365 public boolean isCellSelected(int row, int column) {
2366 if (!getRowSelectionAllowed() && !getColumnSelectionAllowed()) {
2367 return false;
2368 }
2369 return (!getRowSelectionAllowed() || isRowSelected(row)) &&
2370 (!getColumnSelectionAllowed() || isColumnSelected(column));
2371 }
2372
2373 private void changeSelectionModel(ListSelectionModel sm, int index,
2374 boolean toggle, boolean extend, boolean selected,
2375 int anchor, boolean anchorSelected) {
2376 if (extend) {
2377 if (toggle) {
2378 if (anchorSelected) {
2379 sm.addSelectionInterval(anchor, index);
2380 } else {
2381 sm.removeSelectionInterval(anchor, index);
2382 // this is a Windows-only behavior that we want for file lists
2383 if (Boolean.TRUE == getClientProperty("Table.isFileList")) {
2384 sm.addSelectionInterval(index, index);
2385 sm.setAnchorSelectionIndex(anchor);
2386 }
2387 }
2388 }
2389 else {
2390 sm.setSelectionInterval(anchor, index);
2391 }
2392 }
2393 else {
2394 if (toggle) {
2395 if (selected) {
2396 sm.removeSelectionInterval(index, index);
2397 }
2398 else {
2399 sm.addSelectionInterval(index, index);
2400 }
2401 }
2402 else {
2403 sm.setSelectionInterval(index, index);
2404 }
2405 }
2406 }
2407
2408 /**
2409 * Updates the selection models of the table, depending on the state of the
2410 * two flags: <code>toggle</code> and <code>extend</code>. Most changes
2411 * to the selection that are the result of keyboard or mouse events received
2412 * by the UI are channeled through this method so that the behavior may be
2413 * overridden by a subclass. Some UIs may need more functionality than
2414 * this method provides, such as when manipulating the lead for discontiguous
2415 * selection, and may not call into this method for some selection changes.
2416 * <p>
2417 * This implementation uses the following conventions:
2418 * <ul>
2419 * <li> <code>toggle</code>: <em>false</em>, <code>extend</code>: <em>false</em>.
2420 * Clear the previous selection and ensure the new cell is selected.
2421 * <li> <code>toggle</code>: <em>false</em>, <code>extend</code>: <em>true</em>.
2422 * Extend the previous selection from the anchor to the specified cell,
2423 * clearing all other selections.
2424 * <li> <code>toggle</code>: <em>true</em>, <code>extend</code>: <em>false</em>.
2425 * If the specified cell is selected, deselect it. If it is not selected, select it.
2426 * <li> <code>toggle</code>: <em>true</em>, <code>extend</code>: <em>true</em>.
2427 * Apply the selection state of the anchor to all cells between it and the
2428 * specified cell.
2429 * </ul>
2430 * @param rowIndex affects the selection at <code>row</code>
2431 * @param columnIndex affects the selection at <code>column</code>
2432 * @param toggle see description above
2433 * @param extend if true, extend the current selection
2434 *
2435 * @since 1.3
2436 */
2437 public void changeSelection(int rowIndex, int columnIndex, boolean toggle, boolean extend) {
2438 ListSelectionModel rsm = getSelectionModel();
2439 ListSelectionModel csm = getColumnModel().getSelectionModel();
2440
2441 int anchorRow = getAdjustedIndex(rsm.getAnchorSelectionIndex(), true);
2442 int anchorCol = getAdjustedIndex(csm.getAnchorSelectionIndex(), false);
2443
2444 boolean anchorSelected = true;
2445
2446 if (anchorRow == -1) {
2447 if (getRowCount() > 0) {
2448 anchorRow = 0;
2449 }
2450 anchorSelected = false;
2451 }
2452
2453 if (anchorCol == -1) {
2454 if (getColumnCount() > 0) {
2455 anchorCol = 0;
2456 }
2457 anchorSelected = false;
2458 }
2459
2460 // Check the selection here rather than in each selection model.
2461 // This is significant in cell selection mode if we are supposed
2462 // to be toggling the selection. In this case it is better to
2463 // ensure that the cell's selection state will indeed be changed.
2464 // If this were done in the code for the selection model it
2465 // might leave a cell in selection state if the row was
2466 // selected but the column was not - as it would toggle them both.
2467 boolean selected = isCellSelected(rowIndex, columnIndex);
2468 anchorSelected = anchorSelected && isCellSelected(anchorRow, anchorCol);
2469
2470 changeSelectionModel(csm, columnIndex, toggle, extend, selected,
2471 anchorCol, anchorSelected);
2472 changeSelectionModel(rsm, rowIndex, toggle, extend, selected,
2473 anchorRow, anchorSelected);
2474
2475 // Scroll after changing the selection as blit scrolling is immediate,
2476 // so that if we cause the repaint after the scroll we end up painting
2477 // everything!
2478 if (getAutoscrolls()) {
2479 Rectangle cellRect = getCellRect(rowIndex, columnIndex, false);
2480 if (cellRect != null) {
2481 scrollRectToVisible(cellRect);
2482 }
2483 }
2484 }
2485
2486 /**
2487 * Returns the foreground color for selected cells.
2488 *
2489 * @return the <code>Color</code> object for the foreground property
2490 * @see #setSelectionForeground
2491 * @see #setSelectionBackground
2492 */
2493 public Color getSelectionForeground() {
2494 return selectionForeground;
2495 }
2496
2497 /**
2498 * Sets the foreground color for selected cells. Cell renderers
2499 * can use this color to render text and graphics for selected
2500 * cells.
2501 * <p>
2502 * The default value of this property is defined by the look
2503 * and feel implementation.
2504 * <p>
2505 * This is a <a href="http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html">JavaBeans</a> bound property.
2506 *
2507 * @param selectionForeground the <code>Color</code> to use in the foreground
2508 * for selected list items
2509 * @see #getSelectionForeground
2510 * @see #setSelectionBackground
2511 * @see #setForeground
2512 * @see #setBackground
2513 * @see #setFont
2514 */
2515 @BeanProperty(description
2516 = "A default foreground color for selected cells.")
2517 public void setSelectionForeground(Color selectionForeground) {
2518 Color old = this.selectionForeground;
2519 this.selectionForeground = selectionForeground;
2520 firePropertyChange("selectionForeground", old, selectionForeground);
2521 repaint();
2522 }
2523
2524 /**
2525 * Returns the background color for selected cells.
2526 *
2527 * @return the <code>Color</code> used for the background of selected list items
2528 * @see #setSelectionBackground
2529 * @see #setSelectionForeground
2530 */
2531 public Color getSelectionBackground() {
2532 return selectionBackground;
2533 }
2534
2535 /**
2536 * Sets the background color for selected cells. Cell renderers
2537 * can use this color to the fill selected cells.
2538 * <p>
2539 * The default value of this property is defined by the look
2540 * and feel implementation.
2541 * <p>
2542 * This is a <a href="http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html">JavaBeans</a> bound property.
2543 *
2544 * @param selectionBackground the <code>Color</code> to use for the background
2545 * of selected cells
2546 * @see #getSelectionBackground
2547 * @see #setSelectionForeground
2548 * @see #setForeground
2549 * @see #setBackground
2550 * @see #setFont
2551 */
2552 @BeanProperty(description
2553 = "A default background color for selected cells.")
2554 public void setSelectionBackground(Color selectionBackground) {
2555 Color old = this.selectionBackground;
2556 this.selectionBackground = selectionBackground;
2557 firePropertyChange("selectionBackground", old, selectionBackground);
2558 repaint();
2559 }
2560
2561 /**
2562 * Returns the <code>TableColumn</code> object for the column in the table
2563 * whose identifier is equal to <code>identifier</code>, when compared using
2564 * <code>equals</code>.
2565 *
2566 * @return the <code>TableColumn</code> object that matches the identifier
2567 * @exception IllegalArgumentException if <code>identifier</code> is <code>null</code> or no <code>TableColumn</code> has this identifier
2568 *
2569 * @param identifier the identifier object
2570 */
2571 public TableColumn getColumn(Object identifier) {
2572 TableColumnModel cm = getColumnModel();
2573 int columnIndex = cm.getColumnIndex(identifier);
2574 return cm.getColumn(columnIndex);
2575 }
2576
2577 //
2578 // Informally implement the TableModel interface.
2579 //
2580
2581 /**
2582 * Maps the index of the column in the view at
2583 * <code>viewColumnIndex</code> to the index of the column
2584 * in the table model. Returns the index of the corresponding
2585 * column in the model. If <code>viewColumnIndex</code>
2586 * is less than zero, returns <code>viewColumnIndex</code>.
2587 *
2588 * @param viewColumnIndex the index of the column in the view
2589 * @return the index of the corresponding column in the model
2590 *
2591 * @see #convertColumnIndexToView
2592 */
2593 public int convertColumnIndexToModel(int viewColumnIndex) {
2594 return SwingUtilities2.convertColumnIndexToModel(
2595 getColumnModel(), viewColumnIndex);
2596 }
2597
2598 /**
2599 * Maps the index of the column in the table model at
2600 * <code>modelColumnIndex</code> to the index of the column
2601 * in the view. Returns the index of the
2602 * corresponding column in the view; returns -1 if this column is not
2603 * being displayed. If <code>modelColumnIndex</code> is less than zero,
2604 * returns <code>modelColumnIndex</code>.
2605 *
2606 * @param modelColumnIndex the index of the column in the model
2607 * @return the index of the corresponding column in the view
2608 *
2609 * @see #convertColumnIndexToModel
2610 */
2611 public int convertColumnIndexToView(int modelColumnIndex) {
2612 return SwingUtilities2.convertColumnIndexToView(
2613 getColumnModel(), modelColumnIndex);
2614 }
2615
2616 /**
2617 * Maps the index of the row in terms of the
2618 * <code>TableModel</code> to the view. If the contents of the
2619 * model are not sorted the model and view indices are the same.
2620 *
2621 * @param modelRowIndex the index of the row in terms of the model
2622 * @return the index of the corresponding row in the view, or -1 if
2623 * the row isn't visible
2624 * @throws IndexOutOfBoundsException if sorting is enabled and passed an
2625 * index outside the number of rows of the <code>TableModel</code>
2626 * @see javax.swing.table.TableRowSorter
2627 * @since 1.6
2628 */
2629 public int convertRowIndexToView(int modelRowIndex) {
2630 RowSorter<?> sorter = getRowSorter();
2631 if (sorter != null) {
2632 return sorter.convertRowIndexToView(modelRowIndex);
2633 }
2634 return modelRowIndex;
2635 }
2636
2637 /**
2638 * Maps the index of the row in terms of the view to the
2639 * underlying <code>TableModel</code>. If the contents of the
2640 * model are not sorted the model and view indices are the same.
2641 *
2642 * @param viewRowIndex the index of the row in the view
2643 * @return the index of the corresponding row in the model
2644 * @throws IndexOutOfBoundsException if sorting is enabled and passed an
2645 * index outside the range of the <code>JTable</code> as
2646 * determined by the method <code>getRowCount</code>
2647 * @see javax.swing.table.TableRowSorter
2648 * @see #getRowCount
2649 * @since 1.6
2650 */
2651 public int convertRowIndexToModel(int viewRowIndex) {
2652 RowSorter<?> sorter = getRowSorter();
2653 if (sorter != null) {
2654 return sorter.convertRowIndexToModel(viewRowIndex);
2655 }
2656 return viewRowIndex;
2657 }
2658
2659 /**
2660 * Returns the number of rows that can be shown in the
2661 * <code>JTable</code>, given unlimited space. If a
2662 * <code>RowSorter</code> with a filter has been specified, the
2663 * number of rows returned may differ from that of the underlying
2664 * <code>TableModel</code>.
2665 *
2666 * @return the number of rows shown in the <code>JTable</code>
2667 * @see #getColumnCount
2668 */
2669 @BeanProperty(bound = false)
2670 public int getRowCount() {
2671 RowSorter<?> sorter = getRowSorter();
2672 if (sorter != null) {
2673 return sorter.getViewRowCount();
2674 }
2675 return getModel().getRowCount();
2676 }
2677
2678 /**
2679 * Returns the number of columns in the column model. Note that this may
2680 * be different from the number of columns in the table model.
2681 *
2682 * @return the number of columns in the table
2683 * @see #getRowCount
2684 * @see #removeColumn
2685 */
2686 @BeanProperty(bound = false)
2687 public int getColumnCount() {
2688 return getColumnModel().getColumnCount();
2689 }
2690
2691 /**
2692 * Returns the name of the column appearing in the view at
2693 * column position <code>column</code>.
2694 *
2695 * @param column the column in the view being queried
2696 * @return the name of the column at position <code>column</code>
2697 in the view where the first column is column 0
2698 */
2699 public String getColumnName(int column) {
2700 return getModel().getColumnName(convertColumnIndexToModel(column));
2701 }
2702
2703 /**
2704 * Returns the type of the column appearing in the view at
2705 * column position <code>column</code>.
2706 *
2707 * @param column the column in the view being queried
2708 * @return the type of the column at position <code>column</code>
2709 * in the view where the first column is column 0
2710 */
2711 public Class<?> getColumnClass(int column) {
2712 return getModel().getColumnClass(convertColumnIndexToModel(column));
2713 }
2714
2715 /**
2716 * Returns the cell value at <code>row</code> and <code>column</code>.
2717 * <p>
2718 * <b>Note</b>: The column is specified in the table view's display
2719 * order, and not in the <code>TableModel</code>'s column
2720 * order. This is an important distinction because as the
2721 * user rearranges the columns in the table,
2722 * the column at a given index in the view will change.
2723 * Meanwhile the user's actions never affect the model's
2724 * column ordering.
2725 *
2726 * @param row the row whose value is to be queried
2727 * @param column the column whose value is to be queried
2728 * @return the Object at the specified cell
2729 */
2730 public Object getValueAt(int row, int column) {
2731 return getModel().getValueAt(convertRowIndexToModel(row),
2732 convertColumnIndexToModel(column));
2733 }
2734
2735 /**
2736 * Sets the value for the cell in the table model at <code>row</code>
2737 * and <code>column</code>.
2738 * <p>
2739 * <b>Note</b>: The column is specified in the table view's display
2740 * order, and not in the <code>TableModel</code>'s column
2741 * order. This is an important distinction because as the
2742 * user rearranges the columns in the table,
2743 * the column at a given index in the view will change.
2744 * Meanwhile the user's actions never affect the model's
2745 * column ordering.
2746 *
2747 * <code>aValue</code> is the new value.
2748 *
2749 * @param aValue the new value
2750 * @param row the row of the cell to be changed
2751 * @param column the column of the cell to be changed
2752 * @see #getValueAt
2753 */
2754 public void setValueAt(Object aValue, int row, int column) {
2755 getModel().setValueAt(aValue, convertRowIndexToModel(row),
2756 convertColumnIndexToModel(column));
2757 }
2758
2759 /**
2760 * Returns true if the cell at <code>row</code> and <code>column</code>
2761 * is editable. Otherwise, invoking <code>setValueAt</code> on the cell
2762 * will have no effect.
2763 * <p>
2764 * <b>Note</b>: The column is specified in the table view's display
2765 * order, and not in the <code>TableModel</code>'s column
2766 * order. This is an important distinction because as the
2767 * user rearranges the columns in the table,
2768 * the column at a given index in the view will change.
2769 * Meanwhile the user's actions never affect the model's
2770 * column ordering.
2771 *
2772 *
2773 * @param row the row whose value is to be queried
2774 * @param column the column whose value is to be queried
2775 * @return true if the cell is editable
2776 * @see #setValueAt
2777 */
2778 public boolean isCellEditable(int row, int column) {
2779 return getModel().isCellEditable(convertRowIndexToModel(row),
2780 convertColumnIndexToModel(column));
2781 }
2782 //
2783 // Adding and removing columns in the view
2784 //
2785
2786 /**
2787 * Appends <code>aColumn</code> to the end of the array of columns held by
2788 * this <code>JTable</code>'s column model.
2789 * If the column name of <code>aColumn</code> is <code>null</code>,
2790 * sets the column name of <code>aColumn</code> to the name
2791 * returned by <code>getModel().getColumnName()</code>.
2792 * <p>
2793 * To add a column to this <code>JTable</code> to display the
2794 * <code>modelColumn</code>'th column of data in the model with a
2795 * given <code>width</code>, <code>cellRenderer</code>,
2796 * and <code>cellEditor</code> you can use:
2797 * <pre>
2798 *
2799 * addColumn(new TableColumn(modelColumn, width, cellRenderer, cellEditor));
2800 *
2801 * </pre>
2802 * [Any of the <code>TableColumn</code> constructors can be used
2803 * instead of this one.]
2804 * The model column number is stored inside the <code>TableColumn</code>
2805 * and is used during rendering and editing to locate the appropriates
2806 * data values in the model. The model column number does not change
2807 * when columns are reordered in the view.
2808 *
2809 * @param aColumn the <code>TableColumn</code> to be added
2810 * @see #removeColumn
2811 */
2812 public void addColumn(TableColumn aColumn) {
2813 if (aColumn.getHeaderValue() == null) {
2814 int modelColumn = aColumn.getModelIndex();
2815 String columnName = getModel().getColumnName(modelColumn);
2816 aColumn.setHeaderValue(columnName);
2817 }
2818 getColumnModel().addColumn(aColumn);
2819 }
2820
2821 /**
2822 * Removes <code>aColumn</code> from this <code>JTable</code>'s
2823 * array of columns. Note: this method does not remove the column
2824 * of data from the model; it just removes the <code>TableColumn</code>
2825 * that was responsible for displaying it.
2826 *
2827 * @param aColumn the <code>TableColumn</code> to be removed
2828 * @see #addColumn
2829 */
2830 public void removeColumn(TableColumn aColumn) {
2831 getColumnModel().removeColumn(aColumn);
2832 }
2833
2834 /**
2835 * Moves the column <code>column</code> to the position currently
2836 * occupied by the column <code>targetColumn</code> in the view.
2837 * The old column at <code>targetColumn</code> is
2838 * shifted left or right to make room.
2839 *
2840 * @param column the index of column to be moved
2841 * @param targetColumn the new index of the column
2842 */
2843 public void moveColumn(int column, int targetColumn) {
2844 getColumnModel().moveColumn(column, targetColumn);
2845 }
2846
2847 //
2848 // Cover methods for various models and helper methods
2849 //
2850
2851 /**
2852 * Returns the index of the column that <code>point</code> lies in,
2853 * or -1 if the result is not in the range
2854 * [0, <code>getColumnCount()</code>-1].
2855 *
2856 * @param point the location of interest
2857 * @return the index of the column that <code>point</code> lies in,
2858 * or -1 if the result is not in the range
2859 * [0, <code>getColumnCount()</code>-1]
2860 * @see #rowAtPoint
2861 */
2862 public int columnAtPoint(Point point) {
2863 int x = point.x;
2864 if( !getComponentOrientation().isLeftToRight() ) {
2865 x = getWidth() - x - 1;
2866 }
2867 return getColumnModel().getColumnIndexAtX(x);
2868 }
2869
2870 /**
2871 * Returns the index of the row that <code>point</code> lies in,
2872 * or -1 if the result is not in the range
2873 * [0, <code>getRowCount()</code>-1].
2874 *
2875 * @param point the location of interest
2876 * @return the index of the row that <code>point</code> lies in,
2877 * or -1 if the result is not in the range
2878 * [0, <code>getRowCount()</code>-1]
2879 * @see #columnAtPoint
2880 */
2881 public int rowAtPoint(Point point) {
2882 int y = point.y;
2883 int result = (rowModel == null) ? y/getRowHeight() : rowModel.getIndex(y);
2884 if (result < 0) {
2885 return -1;
2886 }
2887 else if (result >= getRowCount()) {
2888 return -1;
2889 }
2890 else {
2891 return result;
2892 }
2893 }
2894
2895 /**
2896 * Returns a rectangle for the cell that lies at the intersection of
2897 * <code>row</code> and <code>column</code>.
2898 * If <code>includeSpacing</code> is true then the value returned
2899 * has the full height and width of the row and column
2900 * specified. If it is false, the returned rectangle is inset by the
2901 * intercell spacing to return the true bounds of the rendering or
2902 * editing component as it will be set during rendering.
2903 * <p>
2904 * If the column index is valid but the row index is less
2905 * than zero the method returns a rectangle with the
2906 * <code>y</code> and <code>height</code> values set appropriately
2907 * and the <code>x</code> and <code>width</code> values both set
2908 * to zero. In general, when either the row or column indices indicate a
2909 * cell outside the appropriate range, the method returns a rectangle
2910 * depicting the closest edge of the closest cell that is within
2911 * the table's range. When both row and column indices are out
2912 * of range the returned rectangle covers the closest
2913 * point of the closest cell.
2914 * <p>
2915 * In all cases, calculations that use this method to calculate
2916 * results along one axis will not fail because of anomalies in
2917 * calculations along the other axis. When the cell is not valid
2918 * the <code>includeSpacing</code> parameter is ignored.
2919 *
2920 * @param row the row index where the desired cell
2921 * is located
2922 * @param column the column index where the desired cell
2923 * is located in the display; this is not
2924 * necessarily the same as the column index
2925 * in the data model for the table; the
2926 * {@link #convertColumnIndexToView(int)}
2927 * method may be used to convert a data
2928 * model column index to a display
2929 * column index
2930 * @param includeSpacing if false, return the true cell bounds -
2931 * computed by subtracting the intercell
2932 * spacing from the height and widths of
2933 * the column and row models
2934 *
2935 * @return the rectangle containing the cell at location
2936 * <code>row</code>,<code>column</code>
2937 * @see #getIntercellSpacing
2938 */
2939 public Rectangle getCellRect(int row, int column, boolean includeSpacing) {
2940 Rectangle r = new Rectangle();
2941 boolean valid = true;
2942 if (row < 0) {
2943 // y = height = 0;
2944 valid = false;
2945 }
2946 else if (row >= getRowCount()) {
2947 r.y = getHeight();
2948 valid = false;
2949 }
2950 else {
2951 r.height = getRowHeight(row);
2952 r.y = (rowModel == null) ? row * r.height : rowModel.getPosition(row);
2953 }
2954
2955 if (column < 0) {
2956 if( !getComponentOrientation().isLeftToRight() ) {
2957 r.x = getWidth();
2958 }
2959 // otherwise, x = width = 0;
2960 valid = false;
2961 }
2962 else if (column >= getColumnCount()) {
2963 if( getComponentOrientation().isLeftToRight() ) {
2964 r.x = getWidth();
2965 }
2966 // otherwise, x = width = 0;
2967 valid = false;
2968 }
2969 else {
2970 TableColumnModel cm = getColumnModel();
2971 if( getComponentOrientation().isLeftToRight() ) {
2972 for(int i = 0; i < column; i++) {
2973 r.x += cm.getColumn(i).getWidth();
2974 }
2975 } else {
2976 for(int i = cm.getColumnCount()-1; i > column; i--) {
2977 r.x += cm.getColumn(i).getWidth();
2978 }
2979 }
2980 r.width = cm.getColumn(column).getWidth();
2981 }
2982
2983 if (valid && !includeSpacing) {
2984 // Bound the margins by their associated dimensions to prevent
2985 // returning bounds with negative dimensions.
2986 int rm = Math.min(getRowMargin(), r.height);
2987 int cm = Math.min(getColumnModel().getColumnMargin(), r.width);
2988 // This is not the same as grow(), it rounds differently.
2989 r.setBounds(r.x + cm/2, r.y + rm/2, r.width - cm, r.height - rm);
2990 }
2991 return r;
2992 }
2993
2994 private int viewIndexForColumn(TableColumn aColumn) {
2995 TableColumnModel cm = getColumnModel();
2996 for (int column = 0; column < cm.getColumnCount(); column++) {
2997 if (cm.getColumn(column) == aColumn) {
2998 return column;
2999 }
3000 }
3001 return -1;
3002 }
3003
3004 /**
3005 * Causes this table to lay out its rows and columns. Overridden so
3006 * that columns can be resized to accommodate a change in the size of
3007 * a containing parent.
3008 * Resizes one or more of the columns in the table
3009 * so that the total width of all of this <code>JTable</code>'s
3010 * columns is equal to the width of the table.
3011 * <p>
3012 * Before the layout begins the method gets the
3013 * <code>resizingColumn</code> of the <code>tableHeader</code>.
3014 * When the method is called as a result of the resizing of an enclosing window,
3015 * the <code>resizingColumn</code> is <code>null</code>. This means that resizing
3016 * has taken place "outside" the <code>JTable</code> and the change -
3017 * or "delta" - should be distributed to all of the columns regardless
3018 * of this <code>JTable</code>'s automatic resize mode.
3019 * <p>
3020 * If the <code>resizingColumn</code> is not <code>null</code>, it is one of
3021 * the columns in the table that has changed size rather than
3022 * the table itself. In this case the auto-resize modes govern
3023 * the way the extra (or deficit) space is distributed
3024 * amongst the available columns.
3025 * <p>
3026 * The modes are:
3027 * <ul>
3028 * <li> AUTO_RESIZE_OFF: Don't automatically adjust the column's
3029 * widths at all. Use a horizontal scrollbar to accommodate the
3030 * columns when their sum exceeds the width of the
3031 * <code>Viewport</code>. If the <code>JTable</code> is not
3032 * enclosed in a <code>JScrollPane</code> this may
3033 * leave parts of the table invisible.
3034 * <li> AUTO_RESIZE_NEXT_COLUMN: Use just the column after the
3035 * resizing column. This results in the "boundary" or divider
3036 * between adjacent cells being independently adjustable.
3037 * <li> AUTO_RESIZE_SUBSEQUENT_COLUMNS: Use all columns after the
3038 * one being adjusted to absorb the changes. This is the
3039 * default behavior.
3040 * <li> AUTO_RESIZE_LAST_COLUMN: Automatically adjust the
3041 * size of the last column only. If the bounds of the last column
3042 * prevent the desired size from being allocated, set the
3043 * width of the last column to the appropriate limit and make
3044 * no further adjustments.
3045 * <li> AUTO_RESIZE_ALL_COLUMNS: Spread the delta amongst all the columns
3046 * in the <code>JTable</code>, including the one that is being
3047 * adjusted.
3048 * </ul>
3049 * <p>
3050 * <b>Note:</b> When a <code>JTable</code> makes adjustments
3051 * to the widths of the columns it respects their minimum and
3052 * maximum values absolutely. It is therefore possible that,
3053 * even after this method is called, the total width of the columns
3054 * is still not equal to the width of the table. When this happens
3055 * the <code>JTable</code> does not put itself
3056 * in AUTO_RESIZE_OFF mode to bring up a scroll bar, or break other
3057 * commitments of its current auto-resize mode -- instead it
3058 * allows its bounds to be set larger (or smaller) than the total of the
3059 * column minimum or maximum, meaning, either that there
3060 * will not be enough room to display all of the columns, or that the
3061 * columns will not fill the <code>JTable</code>'s bounds.
3062 * These respectively, result in the clipping of some columns
3063 * or an area being painted in the <code>JTable</code>'s
3064 * background color during painting.
3065 * <p>
3066 * The mechanism for distributing the delta amongst the available
3067 * columns is provided in a private method in the <code>JTable</code>
3068 * class:
3069 * <pre>
3070 * adjustSizes(long targetSize, final Resizable3 r, boolean inverse)
3071 * </pre>
3072 * an explanation of which is provided in the following section.
3073 * <code>Resizable3</code> is a private
3074 * interface that allows any data structure containing a collection
3075 * of elements with a size, preferred size, maximum size and minimum size
3076 * to have its elements manipulated by the algorithm.
3077 *
3078 * <H3> Distributing the delta </H3>
3079 *
3080 * <H4> Overview </H4>
3081 * <P>
3082 * Call "DELTA" the difference between the target size and the
3083 * sum of the preferred sizes of the elements in r. The individual
3084 * sizes are calculated by taking the original preferred
3085 * sizes and adding a share of the DELTA - that share being based on
3086 * how far each preferred size is from its limiting bound (minimum or
3087 * maximum).
3088 *
3089 * <H4>Definition</H4>
3090 * <P>
3091 * Call the individual constraints min[i], max[i], and pref[i].
3092 * <p>
3093 * Call their respective sums: MIN, MAX, and PREF.
3094 * <p>
3095 * Each new size will be calculated using:
3096 *
3097 * <pre>
3098 * size[i] = pref[i] + delta[i]
3099 * </pre>
3100 * where each individual delta[i] is calculated according to:
3101 * <p>
3102 * If (DELTA < 0) we are in shrink mode where:
3103 *
3104 * <PRE>
3105 * DELTA
3106 * delta[i] = ------------ * (pref[i] - min[i])
3107 * (PREF - MIN)
3108 * </PRE>
3109 * If (DELTA > 0) we are in expand mode where:
3110 *
3111 * <PRE>
3112 * DELTA
3113 * delta[i] = ------------ * (max[i] - pref[i])
3114 * (MAX - PREF)
3115 * </PRE>
3116 * <P>
3117 * The overall effect is that the total size moves that same percentage,
3118 * k, towards the total minimum or maximum and that percentage guarantees
3119 * accommodation of the required space, DELTA.
3120 *
3121 * <H4>Details</H4>
3122 * <P>
3123 * Naive evaluation of the formulae presented here would be subject to
3124 * the aggregated rounding errors caused by doing this operation in finite
3125 * precision (using ints). To deal with this, the multiplying factor above,
3126 * is constantly recalculated and this takes account of the rounding
3127 * errors in the previous iterations. The result is an algorithm that
3128 * produces a set of integers whose values exactly sum to the supplied
3129 * <code>targetSize</code>, and does so by spreading the rounding
3130 * errors evenly over the given elements.
3131 *
3132 * <H4>When the MAX and MIN bounds are hit</H4>
3133 * <P>
3134 * When <code>targetSize</code> is outside the [MIN, MAX] range,
3135 * the algorithm sets all sizes to their appropriate limiting value
3136 * (maximum or minimum).
3137 *
3138 */
3139 public void doLayout() {
3140 TableColumn resizingColumn = getResizingColumn();
3141 if (resizingColumn == null) {
3142 setWidthsFromPreferredWidths(false);
3143 }
3144 else {
3145 // JTable behaves like a layout manger - but one in which the
3146 // user can come along and dictate how big one of the children
3147 // (columns) is supposed to be.
3148
3149 // A column has been resized and JTable may need to distribute
3150 // any overall delta to other columns, according to the resize mode.
3151 int columnIndex = viewIndexForColumn(resizingColumn);
3152 int delta = getWidth() - getColumnModel().getTotalColumnWidth();
3153 accommodateDelta(columnIndex, delta);
3154 delta = getWidth() - getColumnModel().getTotalColumnWidth();
3155
3156 // If the delta cannot be completely accomodated, then the
3157 // resizing column will have to take any remainder. This means
3158 // that the column is not being allowed to take the requested
3159 // width. This happens under many circumstances: For example,
3160 // AUTO_RESIZE_NEXT_COLUMN specifies that any delta be distributed
3161 // to the column after the resizing column. If one were to attempt
3162 // to resize the last column of the table, there would be no
3163 // columns after it, and hence nowhere to distribute the delta.
3164 // It would then be given entirely back to the resizing column,
3165 // preventing it from changing size.
3166 if (delta != 0) {
3167 resizingColumn.setWidth(resizingColumn.getWidth() + delta);
3168 }
3169
3170 // At this point the JTable has to work out what preferred sizes
3171 // would have resulted in the layout the user has chosen.
3172 // Thereafter, during window resizing etc. it has to work off
3173 // the preferred sizes as usual - the idea being that, whatever
3174 // the user does, everything stays in synch and things don't jump
3175 // around.
3176 setWidthsFromPreferredWidths(true);
3177 }
3178
3179 super.doLayout();
3180 }
3181
3182 private TableColumn getResizingColumn() {
3183 return (tableHeader == null) ? null
3184 : tableHeader.getResizingColumn();
3185 }
3186
3187 /**
3188 * Sizes the table columns to fit the available space.
3189 *
3190 * @param lastColumnOnly determines whether to resize last column only
3191 * @deprecated As of Swing version 1.0.3,
3192 * replaced by <code>doLayout()</code>.
3193 * @see #doLayout
3194 */
3195 @Deprecated
3196 public void sizeColumnsToFit(boolean lastColumnOnly) {
3197 int oldAutoResizeMode = autoResizeMode;
3198 setAutoResizeMode(lastColumnOnly ? AUTO_RESIZE_LAST_COLUMN
3199 : AUTO_RESIZE_ALL_COLUMNS);
3200 sizeColumnsToFit(-1);
3201 setAutoResizeMode(oldAutoResizeMode);
3202 }
3203
3204 /**
3205 * Obsolete as of Java 2 platform v1.4. Please use the
3206 * <code>doLayout()</code> method instead.
3207 * @param resizingColumn the column whose resizing made this adjustment
3208 * necessary or -1 if there is no such column
3209 * @see #doLayout
3210 */
3211 public void sizeColumnsToFit(int resizingColumn) {
3212 if (resizingColumn == -1) {
3213 setWidthsFromPreferredWidths(false);
3214 }
3215 else {
3216 if (autoResizeMode == AUTO_RESIZE_OFF) {
3217 TableColumn aColumn = getColumnModel().getColumn(resizingColumn);
3218 aColumn.setPreferredWidth(aColumn.getWidth());
3219 }
3220 else {
3221 int delta = getWidth() - getColumnModel().getTotalColumnWidth();
3222 accommodateDelta(resizingColumn, delta);
3223 setWidthsFromPreferredWidths(true);
3224 }
3225 }
3226 }
3227
3228 private void setWidthsFromPreferredWidths(final boolean inverse) {
3229 int totalWidth = getWidth();
3230 int totalPreferred = getPreferredSize().width;
3231 int target = !inverse ? totalWidth : totalPreferred;
3232
3233 final TableColumnModel cm = columnModel;
3234 Resizable3 r = new Resizable3() {
3235 public int getElementCount() { return cm.getColumnCount(); }
3236 public int getLowerBoundAt(int i) { return cm.getColumn(i).getMinWidth(); }
3237 public int getUpperBoundAt(int i) { return cm.getColumn(i).getMaxWidth(); }
3238 public int getMidPointAt(int i) {
3239 if (!inverse) {
3240 return cm.getColumn(i).getPreferredWidth();
3241 }
3242 else {
3243 return cm.getColumn(i).getWidth();
3244 }
3245 }
3246 public void setSizeAt(int s, int i) {
3247 if (!inverse) {
3248 cm.getColumn(i).setWidth(s);
3249 }
3250 else {
3251 cm.getColumn(i).setPreferredWidth(s);
3252 }
3253 }
3254 };
3255
3256 adjustSizes(target, r, inverse);
3257 }
3258
3259
3260 // Distribute delta over columns, as indicated by the autoresize mode.
3261 private void accommodateDelta(int resizingColumnIndex, int delta) {
3262 int columnCount = getColumnCount();
3263 int from = resizingColumnIndex;
3264 int to;
3265
3266 // Use the mode to determine how to absorb the changes.
3267 switch(autoResizeMode) {
3268 case AUTO_RESIZE_NEXT_COLUMN:
3269 from = from + 1;
3270 to = Math.min(from + 1, columnCount); break;
3271 case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
3272 from = from + 1;
3273 to = columnCount; break;
3274 case AUTO_RESIZE_LAST_COLUMN:
3275 from = columnCount - 1;
3276 to = from + 1; break;
3277 case AUTO_RESIZE_ALL_COLUMNS:
3278 from = 0;
3279 to = columnCount; break;
3280 default:
3281 return;
3282 }
3283
3284 final int start = from;
3285 final int end = to;
3286 final TableColumnModel cm = columnModel;
3287 Resizable3 r = new Resizable3() {
3288 public int getElementCount() { return end-start; }
3289 public int getLowerBoundAt(int i) { return cm.getColumn(i+start).getMinWidth(); }
3290 public int getUpperBoundAt(int i) { return cm.getColumn(i+start).getMaxWidth(); }
3291 public int getMidPointAt(int i) { return cm.getColumn(i+start).getWidth(); }
3292 public void setSizeAt(int s, int i) { cm.getColumn(i+start).setWidth(s); }
3293 };
3294
3295 int totalWidth = 0;
3296 for(int i = from; i < to; i++) {
3297 TableColumn aColumn = columnModel.getColumn(i);
3298 int input = aColumn.getWidth();
3299 totalWidth = totalWidth + input;
3300 }
3301
3302 adjustSizes(totalWidth + delta, r, false);
3303 }
3304
3305 private interface Resizable2 {
3306 public int getElementCount();
3307 public int getLowerBoundAt(int i);
3308 public int getUpperBoundAt(int i);
3309 public void setSizeAt(int newSize, int i);
3310 }
3311
3312 private interface Resizable3 extends Resizable2 {
3313 public int getMidPointAt(int i);
3314 }
3315
3316
3317 private void adjustSizes(long target, final Resizable3 r, boolean inverse) {
3318 int N = r.getElementCount();
3319 long totalPreferred = 0;
3320 for(int i = 0; i < N; i++) {
3321 totalPreferred += r.getMidPointAt(i);
3322 }
3323 Resizable2 s;
3324 if ((target < totalPreferred) == !inverse) {
3325 s = new Resizable2() {
3326 public int getElementCount() { return r.getElementCount(); }
3327 public int getLowerBoundAt(int i) { return r.getLowerBoundAt(i); }
3328 public int getUpperBoundAt(int i) { return r.getMidPointAt(i); }
3329 public void setSizeAt(int newSize, int i) { r.setSizeAt(newSize, i); }
3330
3331 };
3332 }
3333 else {
3334 s = new Resizable2() {
3335 public int getElementCount() { return r.getElementCount(); }
3336 public int getLowerBoundAt(int i) { return r.getMidPointAt(i); }
3337 public int getUpperBoundAt(int i) { return r.getUpperBoundAt(i); }
3338 public void setSizeAt(int newSize, int i) { r.setSizeAt(newSize, i); }
3339
3340 };
3341 }
3342 adjustSizes(target, s, !inverse);
3343 }
3344
3345 private void adjustSizes(long target, Resizable2 r, boolean limitToRange) {
3346 long totalLowerBound = 0;
3347 long totalUpperBound = 0;
3348 for(int i = 0; i < r.getElementCount(); i++) {
3349 totalLowerBound += r.getLowerBoundAt(i);
3350 totalUpperBound += r.getUpperBoundAt(i);
3351 }
3352
3353 if (limitToRange) {
3354 target = Math.min(Math.max(totalLowerBound, target), totalUpperBound);
3355 }
3356
3357 for(int i = 0; i < r.getElementCount(); i++) {
3358 int lowerBound = r.getLowerBoundAt(i);
3359 int upperBound = r.getUpperBoundAt(i);
3360 // Check for zero. This happens when the distribution of the delta
3361 // finishes early due to a series of "fixed" entries at the end.
3362 // In this case, lowerBound == upperBound, for all subsequent terms.
3363 int newSize;
3364 if (totalLowerBound == totalUpperBound) {
3365 newSize = lowerBound;
3366 }
3367 else {
3368 double f = (double)(target - totalLowerBound)/(totalUpperBound - totalLowerBound);
3369 newSize = (int)Math.round(lowerBound+f*(upperBound - lowerBound));
3370 // We'd need to round manually in an all integer version.
3371 // size[i] = (int)(((totalUpperBound - target) * lowerBound +
3372 // (target - totalLowerBound) * upperBound)/(totalUpperBound-totalLowerBound));
3373 }
3374 r.setSizeAt(newSize, i);
3375 target -= newSize;
3376 totalLowerBound -= lowerBound;
3377 totalUpperBound -= upperBound;
3378 }
3379 }
3380
3381 /**
3382 * Overrides <code>JComponent</code>'s <code>getToolTipText</code>
3383 * method in order to allow the renderer's tips to be used
3384 * if it has text set.
3385 * <p>
3386 * <b>Note:</b> For <code>JTable</code> to properly display
3387 * tooltips of its renderers
3388 * <code>JTable</code> must be a registered component with the
3389 * <code>ToolTipManager</code>.
3390 * This is done automatically in <code>initializeLocalVars</code>,
3391 * but if at a later point <code>JTable</code> is told
3392 * <code>setToolTipText(null)</code> it will unregister the table
3393 * component, and no tips from renderers will display anymore.
3394 *
3395 * @see JComponent#getToolTipText
3396 */
3397 public String getToolTipText(MouseEvent event) {
3398 String tip = null;
3399 Point p = event.getPoint();
3400
3401 // Locate the renderer under the event location
3402 int hitColumnIndex = columnAtPoint(p);
3403 int hitRowIndex = rowAtPoint(p);
3404
3405 if ((hitColumnIndex != -1) && (hitRowIndex != -1)) {
3406 TableCellRenderer renderer = getCellRenderer(hitRowIndex, hitColumnIndex);
3407 Component component = prepareRenderer(renderer, hitRowIndex, hitColumnIndex);
3408
3409 // Now have to see if the component is a JComponent before
3410 // getting the tip
3411 if (component instanceof JComponent) {
3412 // Convert the event to the renderer's coordinate system
3413 Rectangle cellRect = getCellRect(hitRowIndex, hitColumnIndex, false);
3414 p.translate(-cellRect.x, -cellRect.y);
3415 @SuppressWarnings("deprecation")
3416 final int modifiers = event.getModifiers();
3417 MouseEvent newEvent = new MouseEvent(component, event.getID(),
3418 event.getWhen(), modifiers,
3419 p.x, p.y,
3420 event.getXOnScreen(),
3421 event.getYOnScreen(),
3422 event.getClickCount(),
3423 event.isPopupTrigger(),
3424 MouseEvent.NOBUTTON);
3425 MouseEventAccessor meAccessor = AWTAccessor.getMouseEventAccessor();
3426 meAccessor.setCausedByTouchEvent(newEvent,
3427 meAccessor.isCausedByTouchEvent(event));
3428
3429 tip = ((JComponent)component).getToolTipText(newEvent);
3430 }
3431 }
3432
3433 // No tip from the renderer get our own tip
3434 if (tip == null)
3435 tip = getToolTipText();
3436
3437 return tip;
3438 }
3439
3440 //
3441 // Editing Support
3442 //
3443
3444 /**
3445 * Sets whether editors in this JTable get the keyboard focus
3446 * when an editor is activated as a result of the JTable
3447 * forwarding keyboard events for a cell.
3448 * By default, this property is false, and the JTable
3449 * retains the focus unless the cell is clicked.
3450 *
3451 * @param surrendersFocusOnKeystroke true if the editor should get the focus
3452 * when keystrokes cause the editor to be
3453 * activated
3454 *
3455 *
3456 * @see #getSurrendersFocusOnKeystroke
3457 * @since 1.4
3458 */
3459 public void setSurrendersFocusOnKeystroke(boolean surrendersFocusOnKeystroke) {
3460 this.surrendersFocusOnKeystroke = surrendersFocusOnKeystroke;
3461 }
3462
3463 /**
3464 * Returns true if the editor should get the focus
3465 * when keystrokes cause the editor to be activated
3466 *
3467 * @return true if the editor should get the focus
3468 * when keystrokes cause the editor to be
3469 * activated
3470 *
3471 * @see #setSurrendersFocusOnKeystroke
3472 * @since 1.4
3473 */
3474 public boolean getSurrendersFocusOnKeystroke() {
3475 return surrendersFocusOnKeystroke;
3476 }
3477
3478 /**
3479 * Programmatically starts editing the cell at <code>row</code> and
3480 * <code>column</code>, if those indices are in the valid range, and
3481 * the cell at those indices is editable.
3482 * Note that this is a convenience method for
3483 * <code>editCellAt(int, int, null)</code>.
3484 *
3485 * @param row the row to be edited
3486 * @param column the column to be edited
3487 * @return false if for any reason the cell cannot be edited,
3488 * or if the indices are invalid
3489 */
3490 public boolean editCellAt(int row, int column) {
3491 return editCellAt(row, column, null);
3492 }
3493
3494 /**
3495 * Programmatically starts editing the cell at <code>row</code> and
3496 * <code>column</code>, if those indices are in the valid range, and
3497 * the cell at those indices is editable.
3498 * To prevent the <code>JTable</code> from
3499 * editing a particular table, column or cell value, return false from
3500 * the <code>isCellEditable</code> method in the <code>TableModel</code>
3501 * interface.
3502 *
3503 * @param row the row to be edited
3504 * @param column the column to be edited
3505 * @param e event to pass into <code>shouldSelectCell</code>;
3506 * note that as of Java 2 platform v1.2, the call to
3507 * <code>shouldSelectCell</code> is no longer made
3508 * @return false if for any reason the cell cannot be edited,
3509 * or if the indices are invalid
3510 */
3511 public boolean editCellAt(int row, int column, EventObject e){
3512 if (cellEditor != null && !cellEditor.stopCellEditing()) {
3513 return false;
3514 }
3515
3516 if (row < 0 || row >= getRowCount() ||
3517 column < 0 || column >= getColumnCount()) {
3518 return false;
3519 }
3520
3521 if (!isCellEditable(row, column))
3522 return false;
3523
3524 if (editorRemover == null) {
3525 KeyboardFocusManager fm =
3526 KeyboardFocusManager.getCurrentKeyboardFocusManager();
3527 editorRemover = new CellEditorRemover(fm);
3528 fm.addPropertyChangeListener("permanentFocusOwner", editorRemover);
3529 }
3530
3531 TableCellEditor editor = getCellEditor(row, column);
3532 if (editor != null && editor.isCellEditable(e)) {
3533 editorComp = prepareEditor(editor, row, column);
3534 if (editorComp == null) {
3535 removeEditor();
3536 return false;
3537 }
3538 editorComp.setBounds(getCellRect(row, column, false));
3539 add(editorComp);
3540 editorComp.validate();
3541 editorComp.repaint();
3542
3543 setCellEditor(editor);
3544 setEditingRow(row);
3545 setEditingColumn(column);
3546 editor.addCellEditorListener(this);
3547
3548 return true;
3549 }
3550 return false;
3551 }
3552
3553 /**
3554 * Returns true if a cell is being edited.
3555 *
3556 * @return true if the table is editing a cell
3557 * @see #editingColumn
3558 * @see #editingRow
3559 */
3560 @BeanProperty(bound = false)
3561 public boolean isEditing() {
3562 return cellEditor != null;
3563 }
3564
3565 /**
3566 * Returns the component that is handling the editing session.
3567 * If nothing is being edited, returns null.
3568 *
3569 * @return Component handling editing session
3570 */
3571 @BeanProperty(bound = false)
3572 public Component getEditorComponent() {
3573 return editorComp;
3574 }
3575
3576 /**
3577 * Returns the index of the column that contains the cell currently
3578 * being edited. If nothing is being edited, returns -1.
3579 *
3580 * @return the index of the column that contains the cell currently
3581 * being edited; returns -1 if nothing being edited
3582 * @see #editingRow
3583 */
3584 public int getEditingColumn() {
3585 return editingColumn;
3586 }
3587
3588 /**
3589 * Returns the index of the row that contains the cell currently
3590 * being edited. If nothing is being edited, returns -1.
3591 *
3592 * @return the index of the row that contains the cell currently
3593 * being edited; returns -1 if nothing being edited
3594 * @see #editingColumn
3595 */
3596 public int getEditingRow() {
3597 return editingRow;
3598 }
3599
3600 //
3601 // Managing TableUI
3602 //
3603
3604 /**
3605 * Returns the L&F object that renders this component.
3606 *
3607 * @return the <code>TableUI</code> object that renders this component
3608 */
3609 public TableUI getUI() {
3610 return (TableUI)ui;
3611 }
3612
3613 /**
3614 * Sets the L&F object that renders this component and repaints.
3615 *
3616 * @param ui the TableUI L&F object
3617 * @see UIDefaults#getUI
3618 */
3619 @BeanProperty(hidden = true, visualUpdate = true, description
3620 = "The UI object that implements the Component's LookAndFeel.")
3621 public void setUI(TableUI ui) {
3622 if (this.ui != ui) {
3623 super.setUI(ui);
3624 repaint();
3625 }
3626 }
3627
3628 /**
3629 * Notification from the <code>UIManager</code> that the L&F has changed.
3630 * Replaces the current UI object with the latest version from the
3631 * <code>UIManager</code>.
3632 *
3633 * @see JComponent#updateUI
3634 */
3635 public void updateUI() {
3636 if (updateInProgress) {
3637 return;
3638 }
3639
3640 updateInProgress = true;
3641
3642 try {
3643 // Update the UIs of the cell renderers, cell editors and header renderers.
3644 TableColumnModel cm = getColumnModel();
3645 for(int column = 0; column < cm.getColumnCount(); column++) {
3646 TableColumn aColumn = cm.getColumn(column);
3647 SwingUtilities.updateRendererOrEditorUI(aColumn.getCellRenderer());
3648 SwingUtilities.updateRendererOrEditorUI(aColumn.getCellEditor());
3649 SwingUtilities.updateRendererOrEditorUI(aColumn.getHeaderRenderer());
3650 }
3651
3652 // Update the UIs of all the default renderers.
3653 Enumeration<?> defaultRenderers = defaultRenderersByColumnClass.elements();
3654 while (defaultRenderers.hasMoreElements()) {
3655 SwingUtilities.updateRendererOrEditorUI(defaultRenderers.nextElement());
3656 }
3657
3658 // Update the UIs of all the default editors.
3659 Enumeration<?> defaultEditors = defaultEditorsByColumnClass.elements();
3660 while (defaultEditors.hasMoreElements()) {
3661 SwingUtilities.updateRendererOrEditorUI(defaultEditors.nextElement());
3662 }
3663
3664 // Update the UI of the table header
3665 if (tableHeader != null && tableHeader.getParent() == null) {
3666 tableHeader.updateUI();
3667 }
3668
3669 // Update UI applied to parent ScrollPane
3670 configureEnclosingScrollPaneUI();
3671
3672 setUI((TableUI)UIManager.getUI(this));
3673 } finally {
3674 updateInProgress = false;
3675 }
3676 }
3677
3678 /**
3679 * Returns the suffix used to construct the name of the L&F class used to
3680 * render this component.
3681 *
3682 * @return the string "TableUI"
3683 * @see JComponent#getUIClassID
3684 * @see UIDefaults#getUI
3685 */
3686 @BeanProperty(bound = false)
3687 public String getUIClassID() {
3688 return uiClassID;
3689 }
3690
3691
3692 //
3693 // Managing models
3694 //
3695
3696 /**
3697 * Sets the data model for this table to {@code dataModel} and registers
3698 * with it for listener notifications from the new data model.
3699 *
3700 * @param dataModel the new data source for this table
3701 * @throws IllegalArgumentException if {@code dataModel} is {@code null}
3702 * @see #getModel
3703 */
3704 @BeanProperty(description
3705 = "The model that is the source of the data for this view.")
3706 public void setModel(final TableModel dataModel) {
3707 if (dataModel == null) {
3708 throw new IllegalArgumentException("Cannot set a null TableModel");
3709 }
3710 if (this.dataModel != dataModel) {
3711 TableModel old = this.dataModel;
3712 if (old != null) {
3713 old.removeTableModelListener(this);
3714 }
3715 this.dataModel = dataModel;
3716 dataModel.addTableModelListener(this);
3717
3718 tableChanged(new TableModelEvent(dataModel, TableModelEvent.HEADER_ROW));
3719
3720 firePropertyChange("model", old, dataModel);
3721
3722 if (getAutoCreateRowSorter()) {
3723 setRowSorter(new TableRowSorter<TableModel>(dataModel));
3724 }
3725 }
3726 }
3727
3728 /**
3729 * Returns the {@code TableModel} that provides the data displayed by this
3730 * {@code JTable}.
3731 *
3732 * @return the {@code TableModel} that provides the data displayed by this
3733 * {@code JTable}
3734 * @see #setModel
3735 */
3736 public TableModel getModel() {
3737 return dataModel;
3738 }
3739
3740 /**
3741 * Sets the column model for this table to {@code columnModel} and registers
3742 * for listener notifications from the new column model. Also sets the
3743 * column model of the {@code JTableHeader} to {@code columnModel}.
3744 *
3745 * @param columnModel the new data source for this table
3746 * @throws IllegalArgumentException if {@code columnModel} is {@code null}
3747 * @see #getColumnModel
3748 */
3749 @BeanProperty(description
3750 = "The object governing the way columns appear in the view.")
3751 public void setColumnModel(final TableColumnModel columnModel) {
3752 if (columnModel == null) {
3753 throw new IllegalArgumentException("Cannot set a null ColumnModel");
3754 }
3755 TableColumnModel old = this.columnModel;
3756 if (columnModel != old) {
3757 if (old != null) {
3758 old.removeColumnModelListener(this);
3759 }
3760 this.columnModel = columnModel;
3761 columnModel.addColumnModelListener(this);
3762
3763 // Set the column model of the header as well.
3764 if (tableHeader != null) {
3765 tableHeader.setColumnModel(columnModel);
3766 }
3767
3768 firePropertyChange("columnModel", old, columnModel);
3769 resizeAndRepaint();
3770 }
3771 }
3772
3773 /**
3774 * Returns the {@code TableColumnModel} that contains all column information
3775 * of this table.
3776 *
3777 * @return the object that provides the column state of the table
3778 * @see #setColumnModel
3779 */
3780 public TableColumnModel getColumnModel() {
3781 return columnModel;
3782 }
3783
3784 /**
3785 * Sets the row selection model for this table to {@code selectionModel}
3786 * and registers for listener notifications from the new selection model.
3787 *
3788 * @param selectionModel the new selection model
3789 * @throws IllegalArgumentException if {@code selectionModel} is
3790 * {@code null}
3791 * @see #getSelectionModel
3792 */
3793 @BeanProperty(description
3794 = "The selection model for rows.")
3795 public void setSelectionModel(final ListSelectionModel selectionModel) {
3796 if (selectionModel == null) {
3797 throw new IllegalArgumentException("Cannot set a null SelectionModel");
3798 }
3799
3800 ListSelectionModel oldModel = this.selectionModel;
3801
3802 if (selectionModel != oldModel) {
3803 if (oldModel != null) {
3804 oldModel.removeListSelectionListener(this);
3805 }
3806
3807 this.selectionModel = selectionModel;
3808 selectionModel.addListSelectionListener(this);
3809
3810 firePropertyChange("selectionModel", oldModel, selectionModel);
3811 repaint();
3812 }
3813 }
3814
3815 /**
3816 * Returns the {@code ListSelectionModel} that is used to maintain row
3817 * selection state.
3818 *
3819 * @return the object that provides row selection state, {@code null} if row
3820 * selection is not allowed
3821 * @see #setSelectionModel
3822 */
3823 public ListSelectionModel getSelectionModel() {
3824 return selectionModel;
3825 }
3826
3827 //
3828 // RowSorterListener
3829 //
3830
3831 /**
3832 * <code>RowSorterListener</code> notification that the
3833 * <code>RowSorter</code> has changed in some way.
3834 *
3835 * @param e the <code>RowSorterEvent</code> describing the change
3836 * @throws NullPointerException if <code>e</code> is <code>null</code>
3837 * @since 1.6
3838 */
3839 public void sorterChanged(RowSorterEvent e) {
3840 if (e.getType() == RowSorterEvent.Type.SORT_ORDER_CHANGED) {
3841 JTableHeader header = getTableHeader();
3842 if (header != null) {
3843 header.repaint();
3844 }
3845 }
3846 else if (e.getType() == RowSorterEvent.Type.SORTED) {
3847 sorterChanged = true;
3848 if (!ignoreSortChange) {
3849 sortedTableChanged(e, null);
3850 }
3851 }
3852 }
3853
3854
3855 /**
3856 * SortManager provides support for managing the selection and variable
3857 * row heights when sorting is enabled. This information is encapsulated
3858 * into a class to avoid bulking up JTable.
3859 */
3860 private final class SortManager {
3861 RowSorter<? extends TableModel> sorter;
3862
3863 // Selection, in terms of the model. This is lazily created
3864 // as needed.
3865 private ListSelectionModel modelSelection;
3866 private int modelLeadIndex;
3867 // Set to true while in the process of changing the selection.
3868 // If this is true the selection change is ignored.
3869 private boolean syncingSelection;
3870 // Temporary cache of selection, in terms of model. This is only used
3871 // if we don't need the full weight of modelSelection.
3872 private int[] lastModelSelection;
3873
3874 // Heights of the rows in terms of the model.
3875 private SizeSequence modelRowSizes;
3876
3877
3878 SortManager(RowSorter<? extends TableModel> sorter) {
3879 this.sorter = sorter;
3880 sorter.addRowSorterListener(JTable.this);
3881 }
3882
3883 /**
3884 * Disposes any resources used by this SortManager.
3885 */
3886 public void dispose() {
3887 if (sorter != null) {
3888 sorter.removeRowSorterListener(JTable.this);
3889 }
3890 }
3891
3892 /**
3893 * Sets the height for a row at a specified index.
3894 */
3895 public void setViewRowHeight(int viewIndex, int rowHeight) {
3896 if (modelRowSizes == null) {
3897 modelRowSizes = new SizeSequence(getModel().getRowCount(),
3898 getRowHeight());
3899 }
3900 modelRowSizes.setSize(convertRowIndexToModel(viewIndex),rowHeight);
3901 }
3902
3903 /**
3904 * Invoked when the underlying model has completely changed.
3905 */
3906 public void allChanged() {
3907 modelLeadIndex = -1;
3908 modelSelection = null;
3909 modelRowSizes = null;
3910 }
3911
3912 /**
3913 * Invoked when the selection, on the view, has changed.
3914 */
3915 public void viewSelectionChanged(ListSelectionEvent e) {
3916 if (!syncingSelection && modelSelection != null) {
3917 modelSelection = null;
3918 }
3919 }
3920
3921 /**
3922 * Invoked when either the table model has changed, or the RowSorter
3923 * has changed. This is invoked prior to notifying the sorter of the
3924 * change.
3925 */
3926 public void prepareForChange(RowSorterEvent sortEvent,
3927 ModelChange change) {
3928 if (getUpdateSelectionOnSort()) {
3929 cacheSelection(sortEvent, change);
3930 }
3931 }
3932
3933 /**
3934 * Updates the internal cache of the selection based on the change.
3935 */
3936 private void cacheSelection(RowSorterEvent sortEvent,
3937 ModelChange change) {
3938 if (sortEvent != null) {
3939 // sort order changed. If modelSelection is null and filtering
3940 // is enabled we need to cache the selection in terms of the
3941 // underlying model, this will allow us to correctly restore
3942 // the selection even if rows are filtered out.
3943 if (modelSelection == null &&
3944 sorter.getViewRowCount() != getModel().getRowCount()) {
3945 modelSelection = new DefaultListSelectionModel();
3946 ListSelectionModel viewSelection = getSelectionModel();
3947 int min = viewSelection.getMinSelectionIndex();
3948 int max = viewSelection.getMaxSelectionIndex();
3949 int modelIndex;
3950 for (int viewIndex = min; viewIndex <= max; viewIndex++) {
3951 if (viewSelection.isSelectedIndex(viewIndex)) {
3952 modelIndex = convertRowIndexToModel(
3953 sortEvent, viewIndex);
3954 if (modelIndex != -1) {
3955 modelSelection.addSelectionInterval(
3956 modelIndex, modelIndex);
3957 }
3958 }
3959 }
3960 modelIndex = convertRowIndexToModel(sortEvent,
3961 viewSelection.getLeadSelectionIndex());
3962 SwingUtilities2.setLeadAnchorWithoutSelection(
3963 modelSelection, modelIndex, modelIndex);
3964 } else if (modelSelection == null) {
3965 // Sorting changed, haven't cached selection in terms
3966 // of model and no filtering. Temporarily cache selection.
3967 cacheModelSelection(sortEvent);
3968 }
3969 } else if (change.allRowsChanged) {
3970 // All the rows have changed, chuck any cached selection.
3971 modelSelection = null;
3972 } else if (modelSelection != null) {
3973 // Table changed, reflect changes in cached selection model.
3974 switch(change.type) {
3975 case TableModelEvent.DELETE:
3976 modelSelection.removeIndexInterval(change.startModelIndex,
3977 change.endModelIndex);
3978 break;
3979 case TableModelEvent.INSERT:
3980 modelSelection.insertIndexInterval(change.startModelIndex,
3981 change.length,
3982 true);
3983 break;
3984 default:
3985 break;
3986 }
3987 } else {
3988 // table changed, but haven't cached rows, temporarily
3989 // cache them.
3990 cacheModelSelection(null);
3991 }
3992 }
3993
3994 private void cacheModelSelection(RowSorterEvent sortEvent) {
3995 lastModelSelection = convertSelectionToModel(sortEvent);
3996 modelLeadIndex = convertRowIndexToModel(sortEvent,
3997 selectionModel.getLeadSelectionIndex());
3998 }
3999
4000 /**
4001 * Inovked when either the table has changed or the sorter has changed
4002 * and after the sorter has been notified. If necessary this will
4003 * reapply the selection and variable row heights.
4004 */
4005 public void processChange(RowSorterEvent sortEvent,
4006 ModelChange change,
4007 boolean sorterChanged) {
4008 if (change != null) {
4009 if (change.allRowsChanged) {
4010 modelRowSizes = null;
4011 rowModel = null;
4012 } else if (modelRowSizes != null) {
4013 if (change.type == TableModelEvent.INSERT) {
4014 modelRowSizes.insertEntries(change.startModelIndex,
4015 change.endModelIndex -
4016 change.startModelIndex + 1,
4017 getRowHeight());
4018 } else if (change.type == TableModelEvent.DELETE) {
4019 modelRowSizes.removeEntries(change.startModelIndex,
4020 change.endModelIndex -
4021 change.startModelIndex +1 );
4022 }
4023 }
4024 }
4025 if (sorterChanged) {
4026 setViewRowHeightsFromModel();
4027 restoreSelection(change);
4028 }
4029 }
4030
4031 /**
4032 * Resets the variable row heights in terms of the view from
4033 * that of the variable row heights in terms of the model.
4034 */
4035 private void setViewRowHeightsFromModel() {
4036 if (modelRowSizes != null) {
4037 rowModel.setSizes(getRowCount(), getRowHeight());
4038 for (int viewIndex = getRowCount() - 1; viewIndex >= 0;
4039 viewIndex--) {
4040 int modelIndex = convertRowIndexToModel(viewIndex);
4041 rowModel.setSize(viewIndex,
4042 modelRowSizes.getSize(modelIndex));
4043 }
4044 }
4045 }
4046
4047 /**
4048 * Restores the selection from that in terms of the model.
4049 */
4050 private void restoreSelection(ModelChange change) {
4051 syncingSelection = true;
4052 if (lastModelSelection != null) {
4053 restoreSortingSelection(lastModelSelection,
4054 modelLeadIndex, change);
4055 lastModelSelection = null;
4056 } else if (modelSelection != null) {
4057 ListSelectionModel viewSelection = getSelectionModel();
4058 viewSelection.setValueIsAdjusting(true);
4059 viewSelection.clearSelection();
4060 int min = modelSelection.getMinSelectionIndex();
4061 int max = modelSelection.getMaxSelectionIndex();
4062 int viewIndex;
4063 for (int modelIndex = min; modelIndex <= max; modelIndex++) {
4064 if (modelSelection.isSelectedIndex(modelIndex)) {
4065 viewIndex = convertRowIndexToView(modelIndex);
4066 if (viewIndex != -1) {
4067 viewSelection.addSelectionInterval(viewIndex,
4068 viewIndex);
4069 }
4070 }
4071 }
4072 // Restore the lead
4073 int viewLeadIndex = modelSelection.getLeadSelectionIndex();
4074 if (viewLeadIndex != -1 && !modelSelection.isSelectionEmpty()) {
4075 viewLeadIndex = convertRowIndexToView(viewLeadIndex);
4076 }
4077 SwingUtilities2.setLeadAnchorWithoutSelection(
4078 viewSelection, viewLeadIndex, viewLeadIndex);
4079 viewSelection.setValueIsAdjusting(false);
4080 }
4081 syncingSelection = false;
4082 }
4083 }
4084
4085
4086 /**
4087 * ModelChange is used when sorting to restore state, it corresponds
4088 * to data from a TableModelEvent. The values are precalculated as
4089 * they are used extensively.
4090 */
4091 private final class ModelChange {
4092 // Starting index of the change, in terms of the model
4093 int startModelIndex;
4094
4095 // Ending index of the change, in terms of the model
4096 int endModelIndex;
4097
4098 // Type of change
4099 int type;
4100
4101 // Number of rows in the model
4102 int modelRowCount;
4103
4104 // The event that triggered this.
4105 TableModelEvent event;
4106
4107 // Length of the change (end - start + 1)
4108 int length;
4109
4110 // True if the event indicates all the contents have changed
4111 boolean allRowsChanged;
4112
4113 ModelChange(TableModelEvent e) {
4114 startModelIndex = Math.max(0, e.getFirstRow());
4115 endModelIndex = e.getLastRow();
4116 modelRowCount = getModel().getRowCount();
4117 if (endModelIndex < 0) {
4118 endModelIndex = Math.max(0, modelRowCount - 1);
4119 }
4120 length = endModelIndex - startModelIndex + 1;
4121 type = e.getType();
4122 event = e;
4123 allRowsChanged = (e.getLastRow() == Integer.MAX_VALUE);
4124 }
4125 }
4126
4127 /**
4128 * Invoked when <code>sorterChanged</code> is invoked, or
4129 * when <code>tableChanged</code> is invoked and sorting is enabled.
4130 */
4131 private void sortedTableChanged(RowSorterEvent sortedEvent,
4132 TableModelEvent e) {
4133 int editingModelIndex = -1;
4134 ModelChange change = (e != null) ? new ModelChange(e) : null;
4135
4136 if ((change == null || !change.allRowsChanged) &&
4137 this.editingRow != -1) {
4138 editingModelIndex = convertRowIndexToModel(sortedEvent,
4139 this.editingRow);
4140 }
4141
4142 sortManager.prepareForChange(sortedEvent, change);
4143
4144 if (e != null) {
4145 if (change.type == TableModelEvent.UPDATE) {
4146 repaintSortedRows(change);
4147 }
4148 notifySorter(change);
4149 if (change.type != TableModelEvent.UPDATE) {
4150 // If the Sorter is unsorted we will not have received
4151 // notification, force treating insert/delete as a change.
4152 sorterChanged = true;
4153 }
4154 }
4155 else {
4156 sorterChanged = true;
4157 }
4158
4159 sortManager.processChange(sortedEvent, change, sorterChanged);
4160
4161 if (sorterChanged) {
4162 // Update the editing row
4163 if (this.editingRow != -1) {
4164 int newIndex = (editingModelIndex == -1) ? -1 :
4165 convertRowIndexToView(editingModelIndex,change);
4166 restoreSortingEditingRow(newIndex);
4167 }
4168
4169 // And handle the appropriate repainting.
4170 if (e == null || change.type != TableModelEvent.UPDATE) {
4171 resizeAndRepaint();
4172 }
4173 }
4174
4175 // Check if lead/anchor need to be reset.
4176 if (change != null && change.allRowsChanged) {
4177 clearSelectionAndLeadAnchor();
4178 resizeAndRepaint();
4179 }
4180 }
4181
4182 /**
4183 * Repaints the sort of sorted rows in response to a TableModelEvent.
4184 */
4185 private void repaintSortedRows(ModelChange change) {
4186 if (change.startModelIndex > change.endModelIndex ||
4187 change.startModelIndex + 10 < change.endModelIndex) {
4188 // Too much has changed, punt
4189 repaint();
4190 return;
4191 }
4192 int eventColumn = change.event.getColumn();
4193 int columnViewIndex = eventColumn;
4194 if (columnViewIndex == TableModelEvent.ALL_COLUMNS) {
4195 columnViewIndex = 0;
4196 }
4197 else {
4198 columnViewIndex = convertColumnIndexToView(columnViewIndex);
4199 if (columnViewIndex == -1) {
4200 return;
4201 }
4202 }
4203 int modelIndex = change.startModelIndex;
4204 while (modelIndex <= change.endModelIndex) {
4205 int viewIndex = convertRowIndexToView(modelIndex++);
4206 if (viewIndex != -1) {
4207 Rectangle dirty = getCellRect(viewIndex, columnViewIndex,
4208 false);
4209 int x = dirty.x;
4210 int w = dirty.width;
4211 if (eventColumn == TableModelEvent.ALL_COLUMNS) {
4212 x = 0;
4213 w = getWidth();
4214 }
4215 repaint(x, dirty.y, w, dirty.height);
4216 }
4217 }
4218 }
4219
4220 /**
4221 * Restores the selection after a model event/sort order changes.
4222 * All coordinates are in terms of the model.
4223 */
4224 private void restoreSortingSelection(int[] selection, int lead,
4225 ModelChange change) {
4226 // Convert the selection from model to view
4227 for (int i = selection.length - 1; i >= 0; i--) {
4228 selection[i] = convertRowIndexToView(selection[i], change);
4229 }
4230 lead = convertRowIndexToView(lead, change);
4231
4232 // Check for the common case of no change in selection for 1 row
4233 if (selection.length == 0 ||
4234 (selection.length == 1 && selection[0] == getSelectedRow())) {
4235 return;
4236 }
4237
4238 // And apply the new selection
4239 selectionModel.setValueIsAdjusting(true);
4240 selectionModel.clearSelection();
4241 for (int i = selection.length - 1; i >= 0; i--) {
4242 if (selection[i] != -1) {
4243 selectionModel.addSelectionInterval(selection[i],
4244 selection[i]);
4245 }
4246 }
4247 SwingUtilities2.setLeadAnchorWithoutSelection(
4248 selectionModel, lead, lead);
4249 selectionModel.setValueIsAdjusting(false);
4250 }
4251
4252 /**
4253 * Restores the editing row after a model event/sort order change.
4254 *
4255 * @param editingRow new index of the editingRow, in terms of the view
4256 */
4257 private void restoreSortingEditingRow(int editingRow) {
4258 if (editingRow == -1) {
4259 // Editing row no longer being shown, cancel editing
4260 TableCellEditor editor = getCellEditor();
4261 if (editor != null) {
4262 // First try and cancel
4263 editor.cancelCellEditing();
4264 if (getCellEditor() != null) {
4265 // CellEditor didn't cede control, forcefully
4266 // remove it
4267 removeEditor();
4268 }
4269 }
4270 }
4271 else {
4272 // Repositioning handled in BasicTableUI
4273 this.editingRow = editingRow;
4274 repaint();
4275 }
4276 }
4277
4278 /**
4279 * Notifies the sorter of a change in the underlying model.
4280 */
4281 private void notifySorter(ModelChange change) {
4282 try {
4283 ignoreSortChange = true;
4284 sorterChanged = false;
4285 switch(change.type) {
4286 case TableModelEvent.UPDATE:
4287 if (change.event.getLastRow() == Integer.MAX_VALUE) {
4288 sortManager.sorter.allRowsChanged();
4289 } else if (change.event.getColumn() ==
4290 TableModelEvent.ALL_COLUMNS) {
4291 sortManager.sorter.rowsUpdated(change.startModelIndex,
4292 change.endModelIndex);
4293 } else {
4294 sortManager.sorter.rowsUpdated(change.startModelIndex,
4295 change.endModelIndex,
4296 change.event.getColumn());
4297 }
4298 break;
4299 case TableModelEvent.INSERT:
4300 sortManager.sorter.rowsInserted(change.startModelIndex,
4301 change.endModelIndex);
4302 break;
4303 case TableModelEvent.DELETE:
4304 sortManager.sorter.rowsDeleted(change.startModelIndex,
4305 change.endModelIndex);
4306 break;
4307 }
4308 } finally {
4309 ignoreSortChange = false;
4310 }
4311 }
4312
4313 /**
4314 * Converts a model index to view index. This is called when the
4315 * sorter or model changes and sorting is enabled.
4316 *
4317 * @param change describes the TableModelEvent that initiated the change;
4318 * will be null if called as the result of a sort
4319 */
4320 private int convertRowIndexToView(int modelIndex, ModelChange change) {
4321 if (modelIndex < 0) {
4322 return -1;
4323 }
4324 if (change != null && modelIndex >= change.startModelIndex) {
4325 if (change.type == TableModelEvent.INSERT) {
4326 if (modelIndex + change.length >= change.modelRowCount) {
4327 return -1;
4328 }
4329 return sortManager.sorter.convertRowIndexToView(
4330 modelIndex + change.length);
4331 }
4332 else if (change.type == TableModelEvent.DELETE) {
4333 if (modelIndex <= change.endModelIndex) {
4334 // deleted
4335 return -1;
4336 }
4337 else {
4338 if (modelIndex - change.length >= change.modelRowCount) {
4339 return -1;
4340 }
4341 return sortManager.sorter.convertRowIndexToView(
4342 modelIndex - change.length);
4343 }
4344 }
4345 // else, updated
4346 }
4347 if (modelIndex >= getModel().getRowCount()) {
4348 return -1;
4349 }
4350 return sortManager.sorter.convertRowIndexToView(modelIndex);
4351 }
4352
4353 /**
4354 * Converts the selection to model coordinates. This is used when
4355 * the model changes or the sorter changes.
4356 */
4357 private int[] convertSelectionToModel(RowSorterEvent e) {
4358 int[] selection = getSelectedRows();
4359 for (int i = selection.length - 1; i >= 0; i--) {
4360 selection[i] = convertRowIndexToModel(e, selection[i]);
4361 }
4362 return selection;
4363 }
4364
4365 private int convertRowIndexToModel(RowSorterEvent e, int viewIndex) {
4366 if (e != null) {
4367 if (e.getPreviousRowCount() == 0) {
4368 return viewIndex;
4369 }
4370 // range checking handled by RowSorterEvent
4371 return e.convertPreviousRowIndexToModel(viewIndex);
4372 }
4373 // Make sure the viewIndex is valid
4374 if (viewIndex < 0 || viewIndex >= getRowCount()) {
4375 return -1;
4376 }
4377 return convertRowIndexToModel(viewIndex);
4378 }
4379
4380 //
4381 // Implementing TableModelListener interface
4382 //
4383
4384 /**
4385 * Invoked when this table's <code>TableModel</code> generates
4386 * a <code>TableModelEvent</code>.
4387 * The <code>TableModelEvent</code> should be constructed in the
4388 * coordinate system of the model; the appropriate mapping to the
4389 * view coordinate system is performed by this <code>JTable</code>
4390 * when it receives the event.
4391 * <p>
4392 * Application code will not use these methods explicitly, they
4393 * are used internally by <code>JTable</code>.
4394 * <p>
4395 * Note that as of 1.3, this method clears the selection, if any.
4396 */
4397 public void tableChanged(TableModelEvent e) {
4398 if (e == null || e.getFirstRow() == TableModelEvent.HEADER_ROW) {
4399 // The whole thing changed
4400 clearSelectionAndLeadAnchor();
4401
4402 rowModel = null;
4403
4404 if (sortManager != null) {
4405 try {
4406 ignoreSortChange = true;
4407 sortManager.sorter.modelStructureChanged();
4408 } finally {
4409 ignoreSortChange = false;
4410 }
4411 sortManager.allChanged();
4412 }
4413
4414 if (getAutoCreateColumnsFromModel()) {
4415 // This will effect invalidation of the JTable and JTableHeader.
4416 createDefaultColumnsFromModel();
4417 return;
4418 }
4419
4420 resizeAndRepaint();
4421 return;
4422 }
4423
4424 if (sortManager != null) {
4425 sortedTableChanged(null, e);
4426 return;
4427 }
4428
4429 // The totalRowHeight calculated below will be incorrect if
4430 // there are variable height rows. Repaint the visible region,
4431 // but don't return as a revalidate may be necessary as well.
4432 if (rowModel != null) {
4433 repaint();
4434 }
4435
4436 if (e.getType() == TableModelEvent.INSERT) {
4437 tableRowsInserted(e);
4438 return;
4439 }
4440
4441 if (e.getType() == TableModelEvent.DELETE) {
4442 tableRowsDeleted(e);
4443 return;
4444 }
4445
4446 int modelColumn = e.getColumn();
4447 int start = e.getFirstRow();
4448 int end = e.getLastRow();
4449
4450 Rectangle dirtyRegion;
4451 if (modelColumn == TableModelEvent.ALL_COLUMNS) {
4452 // 1 or more rows changed
4453 dirtyRegion = new Rectangle(0, start * getRowHeight(),
4454 getColumnModel().getTotalColumnWidth(), 0);
4455 }
4456 else {
4457 // A cell or column of cells has changed.
4458 // Unlike the rest of the methods in the JTable, the TableModelEvent
4459 // uses the coordinate system of the model instead of the view.
4460 // This is the only place in the JTable where this "reverse mapping"
4461 // is used.
4462 int column = convertColumnIndexToView(modelColumn);
4463 dirtyRegion = getCellRect(start, column, false);
4464 }
4465
4466 // Now adjust the height of the dirty region according to the value of "end".
4467 // Check for Integer.MAX_VALUE as this will cause an overflow.
4468 if (end != Integer.MAX_VALUE) {
4469 dirtyRegion.height = (end-start+1)*getRowHeight();
4470 repaint(dirtyRegion.x, dirtyRegion.y, dirtyRegion.width, dirtyRegion.height);
4471 }
4472 // In fact, if the end is Integer.MAX_VALUE we need to revalidate anyway
4473 // because the scrollbar may need repainting.
4474 else {
4475 clearSelectionAndLeadAnchor();
4476 resizeAndRepaint();
4477 rowModel = null;
4478 }
4479 }
4480
4481 /*
4482 * Invoked when rows have been inserted into the table.
4483 * <p>
4484 * Application code will not use these methods explicitly, they
4485 * are used internally by JTable.
4486 *
4487 * @param e the TableModelEvent encapsulating the insertion
4488 */
4489 private void tableRowsInserted(TableModelEvent e) {
4490 int start = e.getFirstRow();
4491 int end = e.getLastRow();
4492 if (start < 0) {
4493 start = 0;
4494 }
4495 if (end < 0) {
4496 end = getRowCount()-1;
4497 }
4498
4499 // Adjust the selection to account for the new rows.
4500 int length = end - start + 1;
4501 selectionModel.insertIndexInterval(start, length, true);
4502
4503 // If we have variable height rows, adjust the row model.
4504 if (rowModel != null) {
4505 rowModel.insertEntries(start, length, getRowHeight());
4506 }
4507 int rh = getRowHeight() ;
4508 Rectangle drawRect = new Rectangle(0, start * rh,
4509 getColumnModel().getTotalColumnWidth(),
4510 (getRowCount()-start) * rh);
4511
4512 revalidate();
4513 // PENDING(milne) revalidate calls repaint() if parent is a ScrollPane
4514 // repaint still required in the unusual case where there is no ScrollPane
4515 repaint(drawRect);
4516 }
4517
4518 /*
4519 * Invoked when rows have been removed from the table.
4520 * <p>
4521 * Application code will not use these methods explicitly, they
4522 * are used internally by JTable.
4523 *
4524 * @param e the TableModelEvent encapsulating the deletion
4525 */
4526 private void tableRowsDeleted(TableModelEvent e) {
4527 int start = e.getFirstRow();
4528 int end = e.getLastRow();
4529 if (start < 0) {
4530 start = 0;
4531 }
4532 if (end < 0) {
4533 end = getRowCount()-1;
4534 }
4535
4536 int deletedCount = end - start + 1;
4537 int previousRowCount = getRowCount() + deletedCount;
4538 // Adjust the selection to account for the new rows
4539 selectionModel.removeIndexInterval(start, end);
4540
4541 // If we have variable height rows, adjust the row model.
4542 if (rowModel != null) {
4543 rowModel.removeEntries(start, deletedCount);
4544 }
4545
4546 int rh = getRowHeight();
4547 Rectangle drawRect = new Rectangle(0, start * rh,
4548 getColumnModel().getTotalColumnWidth(),
4549 (previousRowCount - start) * rh);
4550
4551 revalidate();
4552 // PENDING(milne) revalidate calls repaint() if parent is a ScrollPane
4553 // repaint still required in the unusual case where there is no ScrollPane
4554 repaint(drawRect);
4555 }
4556
4557 //
4558 // Implementing TableColumnModelListener interface
4559 //
4560
4561 /**
4562 * Invoked when a column is added to the table column model.
4563 * <p>
4564 * Application code will not use these methods explicitly, they
4565 * are used internally by JTable.
4566 *
4567 * @see TableColumnModelListener
4568 */
4569 public void columnAdded(TableColumnModelEvent e) {
4570 // If I'm currently editing, then I should stop editing
4571 if (isEditing()) {
4572 removeEditor();
4573 }
4574 resizeAndRepaint();
4575 }
4576
4577 /**
4578 * Invoked when a column is removed from the table column model.
4579 * <p>
4580 * Application code will not use these methods explicitly, they
4581 * are used internally by JTable.
4582 *
4583 * @see TableColumnModelListener
4584 */
4585 public void columnRemoved(TableColumnModelEvent e) {
4586 // If I'm currently editing, then I should stop editing
4587 if (isEditing()) {
4588 removeEditor();
4589 }
4590 resizeAndRepaint();
4591 }
4592
4593 /**
4594 * Invoked when a column is repositioned. If a cell is being
4595 * edited, then editing is stopped and the cell is redrawn.
4596 * <p>
4597 * Application code will not use these methods explicitly, they
4598 * are used internally by JTable.
4599 *
4600 * @param e the event received
4601 * @see TableColumnModelListener
4602 */
4603 public void columnMoved(TableColumnModelEvent e) {
4604 if (isEditing() && !getCellEditor().stopCellEditing()) {
4605 getCellEditor().cancelCellEditing();
4606 }
4607 repaint();
4608 }
4609
4610 /**
4611 * Invoked when a column is moved due to a margin change.
4612 * If a cell is being edited, then editing is stopped and the cell
4613 * is redrawn.
4614 * <p>
4615 * Application code will not use these methods explicitly, they
4616 * are used internally by JTable.
4617 *
4618 * @param e the event received
4619 * @see TableColumnModelListener
4620 */
4621 public void columnMarginChanged(ChangeEvent e) {
4622 if (isEditing() && !getCellEditor().stopCellEditing()) {
4623 getCellEditor().cancelCellEditing();
4624 }
4625 TableColumn resizingColumn = getResizingColumn();
4626 // Need to do this here, before the parent's
4627 // layout manager calls getPreferredSize().
4628 if (resizingColumn != null && autoResizeMode == AUTO_RESIZE_OFF) {
4629 resizingColumn.setPreferredWidth(resizingColumn.getWidth());
4630 }
4631 resizeAndRepaint();
4632 }
4633
4634 private int limit(int i, int a, int b) {
4635 return Math.min(b, Math.max(i, a));
4636 }
4637
4638 /**
4639 * Invoked when the selection model of the <code>TableColumnModel</code>
4640 * is changed.
4641 * <p>
4642 * Application code will not use these methods explicitly, they
4643 * are used internally by JTable.
4644 *
4645 * @param e the event received
4646 * @see TableColumnModelListener
4647 */
4648 public void columnSelectionChanged(ListSelectionEvent e) {
4649 boolean isAdjusting = e.getValueIsAdjusting();
4650 if (columnSelectionAdjusting && !isAdjusting) {
4651 // The assumption is that when the model is no longer adjusting
4652 // we will have already gotten all the changes, and therefore
4653 // don't need to do an additional paint.
4654 columnSelectionAdjusting = false;
4655 return;
4656 }
4657 columnSelectionAdjusting = isAdjusting;
4658 // The getCellRect() call will fail unless there is at least one row.
4659 if (getRowCount() <= 0 || getColumnCount() <= 0) {
4660 return;
4661 }
4662 int firstIndex = limit(e.getFirstIndex(), 0, getColumnCount()-1);
4663 int lastIndex = limit(e.getLastIndex(), 0, getColumnCount()-1);
4664 int minRow = 0;
4665 int maxRow = getRowCount() - 1;
4666 if (getRowSelectionAllowed()) {
4667 minRow = selectionModel.getMinSelectionIndex();
4668 maxRow = selectionModel.getMaxSelectionIndex();
4669 int leadRow = getAdjustedIndex(selectionModel.getLeadSelectionIndex(), true);
4670
4671 if (minRow == -1 || maxRow == -1) {
4672 if (leadRow == -1) {
4673 // nothing to repaint, return
4674 return;
4675 }
4676
4677 // only thing to repaint is the lead
4678 minRow = maxRow = leadRow;
4679 } else {
4680 // We need to consider more than just the range between
4681 // the min and max selected index. The lead row, which could
4682 // be outside this range, should be considered also.
4683 if (leadRow != -1) {
4684 minRow = Math.min(minRow, leadRow);
4685 maxRow = Math.max(maxRow, leadRow);
4686 }
4687 }
4688 }
4689 Rectangle firstColumnRect = getCellRect(minRow, firstIndex, false);
4690 Rectangle lastColumnRect = getCellRect(maxRow, lastIndex, false);
4691 Rectangle dirtyRegion = firstColumnRect.union(lastColumnRect);
4692 repaint(dirtyRegion);
4693 }
4694
4695 //
4696 // Implementing ListSelectionListener interface
4697 //
4698
4699 /**
4700 * Invoked when the row selection changes -- repaints to show the new
4701 * selection.
4702 * <p>
4703 * Application code will not use these methods explicitly, they
4704 * are used internally by JTable.
4705 *
4706 * @param e the event received
4707 * @see ListSelectionListener
4708 */
4709 public void valueChanged(ListSelectionEvent e) {
4710 if (sortManager != null) {
4711 sortManager.viewSelectionChanged(e);
4712 }
4713 boolean isAdjusting = e.getValueIsAdjusting();
4714 if (rowSelectionAdjusting && !isAdjusting) {
4715 // The assumption is that when the model is no longer adjusting
4716 // we will have already gotten all the changes, and therefore
4717 // don't need to do an additional paint.
4718 rowSelectionAdjusting = false;
4719 return;
4720 }
4721 rowSelectionAdjusting = isAdjusting;
4722 // The getCellRect() calls will fail unless there is at least one column.
4723 if (getRowCount() <= 0 || getColumnCount() <= 0) {
4724 return;
4725 }
4726 int firstIndex = limit(e.getFirstIndex(), 0, getRowCount()-1);
4727 int lastIndex = limit(e.getLastIndex(), 0, getRowCount()-1);
4728 Rectangle firstRowRect = getCellRect(firstIndex, 0, false);
4729 Rectangle lastRowRect = getCellRect(lastIndex, getColumnCount()-1, false);
4730 Rectangle dirtyRegion = firstRowRect.union(lastRowRect);
4731 repaint(dirtyRegion);
4732 }
4733
4734 //
4735 // Implementing the CellEditorListener interface
4736 //
4737
4738 /**
4739 * Invoked when editing is finished. The changes are saved and the
4740 * editor is discarded.
4741 * <p>
4742 * Application code will not use these methods explicitly, they
4743 * are used internally by JTable.
4744 *
4745 * @param e the event received
4746 * @see CellEditorListener
4747 */
4748 public void editingStopped(ChangeEvent e) {
4749 // Take in the new value
4750 TableCellEditor editor = getCellEditor();
4751 if (editor != null) {
4752 Object value = editor.getCellEditorValue();
4753 setValueAt(value, editingRow, editingColumn);
4754 removeEditor();
4755 }
4756 }
4757
4758 /**
4759 * Invoked when editing is canceled. The editor object is discarded
4760 * and the cell is rendered once again.
4761 * <p>
4762 * Application code will not use these methods explicitly, they
4763 * are used internally by JTable.
4764 *
4765 * @param e the event received
4766 * @see CellEditorListener
4767 */
4768 public void editingCanceled(ChangeEvent e) {
4769 removeEditor();
4770 }
4771
4772 //
4773 // Implementing the Scrollable interface
4774 //
4775
4776 /**
4777 * Sets the preferred size of the viewport for this table.
4778 *
4779 * @param size a <code>Dimension</code> object specifying the <code>preferredSize</code> of a
4780 * <code>JViewport</code> whose view is this table
4781 * @see Scrollable#getPreferredScrollableViewportSize
4782 */
4783 @BeanProperty(bound = false, description
4784 = "The preferred size of the viewport.")
4785 public void setPreferredScrollableViewportSize(Dimension size) {
4786 preferredViewportSize = size;
4787 }
4788
4789 /**
4790 * Returns the preferred size of the viewport for this table.
4791 *
4792 * @return a <code>Dimension</code> object containing the <code>preferredSize</code> of the <code>JViewport</code>
4793 * which displays this table
4794 * @see Scrollable#getPreferredScrollableViewportSize
4795 */
4796 public Dimension getPreferredScrollableViewportSize() {
4797 return preferredViewportSize;
4798 }
4799
4800 /**
4801 * Returns the scroll increment (in pixels) that completely exposes one new
4802 * row or column (depending on the orientation).
4803 * <p>
4804 * This method is called each time the user requests a unit scroll.
4805 *
4806 * @param visibleRect the view area visible within the viewport
4807 * @param orientation either <code>SwingConstants.VERTICAL</code>
4808 * or <code>SwingConstants.HORIZONTAL</code>
4809 * @param direction less than zero to scroll up/left,
4810 * greater than zero for down/right
4811 * @return the "unit" increment for scrolling in the specified direction
4812 * @see Scrollable#getScrollableUnitIncrement
4813 */
4814 public int getScrollableUnitIncrement(Rectangle visibleRect,
4815 int orientation,
4816 int direction) {
4817 int leadingRow;
4818 int leadingCol;
4819 Rectangle leadingCellRect;
4820
4821 int leadingVisibleEdge;
4822 int leadingCellEdge;
4823 int leadingCellSize;
4824
4825 leadingRow = getLeadingRow(visibleRect);
4826 leadingCol = getLeadingCol(visibleRect);
4827 if (orientation == SwingConstants.VERTICAL && leadingRow < 0) {
4828 // Couldn't find leading row - return some default value
4829 return getRowHeight();
4830 }
4831 else if (orientation == SwingConstants.HORIZONTAL && leadingCol < 0) {
4832 // Couldn't find leading col - return some default value
4833 return 100;
4834 }
4835
4836 // Note that it's possible for one of leadingCol or leadingRow to be
4837 // -1, depending on the orientation. This is okay, as getCellRect()
4838 // still provides enough information to calculate the unit increment.
4839 leadingCellRect = getCellRect(leadingRow, leadingCol, true);
4840 leadingVisibleEdge = leadingEdge(visibleRect, orientation);
4841 leadingCellEdge = leadingEdge(leadingCellRect, orientation);
4842
4843 if (orientation == SwingConstants.VERTICAL) {
4844 leadingCellSize = leadingCellRect.height;
4845
4846 }
4847 else {
4848 leadingCellSize = leadingCellRect.width;
4849 }
4850
4851 // 4 cases:
4852 // #1: Leading cell fully visible, reveal next cell
4853 // #2: Leading cell fully visible, hide leading cell
4854 // #3: Leading cell partially visible, hide rest of leading cell
4855 // #4: Leading cell partially visible, reveal rest of leading cell
4856
4857 if (leadingVisibleEdge == leadingCellEdge) { // Leading cell is fully
4858 // visible
4859 // Case #1: Reveal previous cell
4860 if (direction < 0) {
4861 int retVal = 0;
4862
4863 if (orientation == SwingConstants.VERTICAL) {
4864 // Loop past any zero-height rows
4865 while (--leadingRow >= 0) {
4866 retVal = getRowHeight(leadingRow);
4867 if (retVal != 0) {
4868 break;
4869 }
4870 }
4871 }
4872 else { // HORIZONTAL
4873 // Loop past any zero-width cols
4874 while (--leadingCol >= 0) {
4875 retVal = getCellRect(leadingRow, leadingCol, true).width;
4876 if (retVal != 0) {
4877 break;
4878 }
4879 }
4880 }
4881 return retVal;
4882 }
4883 else { // Case #2: hide leading cell
4884 return leadingCellSize;
4885 }
4886 }
4887 else { // Leading cell is partially hidden
4888 // Compute visible, hidden portions
4889 int hiddenAmt = Math.abs(leadingVisibleEdge - leadingCellEdge);
4890 int visibleAmt = leadingCellSize - hiddenAmt;
4891
4892 if (direction > 0) {
4893 // Case #3: hide showing portion of leading cell
4894 return visibleAmt;
4895 }
4896 else { // Case #4: reveal hidden portion of leading cell
4897 return hiddenAmt;
4898 }
4899 }
4900 }
4901
4902 /**
4903 * Returns <code>visibleRect.height</code> or
4904 * <code>visibleRect.width</code>,
4905 * depending on this table's orientation. Note that as of Swing 1.1.1
4906 * (Java 2 v 1.2.2) the value
4907 * returned will ensure that the viewport is cleanly aligned on
4908 * a row boundary.
4909 *
4910 * @return <code>visibleRect.height</code> or
4911 * <code>visibleRect.width</code>
4912 * per the orientation
4913 * @see Scrollable#getScrollableBlockIncrement
4914 */
4915 public int getScrollableBlockIncrement(Rectangle visibleRect,
4916 int orientation, int direction) {
4917
4918 if (getRowCount() == 0) {
4919 // Short-circuit empty table model
4920 if (SwingConstants.VERTICAL == orientation) {
4921 int rh = getRowHeight();
4922 return (rh > 0) ? Math.max(rh, (visibleRect.height / rh) * rh) :
4923 visibleRect.height;
4924 }
4925 else {
4926 return visibleRect.width;
4927 }
4928 }
4929 // Shortcut for vertical scrolling of a table w/ uniform row height
4930 if (null == rowModel && SwingConstants.VERTICAL == orientation) {
4931 int row = rowAtPoint(visibleRect.getLocation());
4932 assert row != -1;
4933 int col = columnAtPoint(visibleRect.getLocation());
4934 Rectangle cellRect = getCellRect(row, col, true);
4935
4936 if (cellRect.y == visibleRect.y) {
4937 int rh = getRowHeight();
4938 assert rh > 0;
4939 return Math.max(rh, (visibleRect.height / rh) * rh);
4940 }
4941 }
4942 if (direction < 0) {
4943 return getPreviousBlockIncrement(visibleRect, orientation);
4944 }
4945 else {
4946 return getNextBlockIncrement(visibleRect, orientation);
4947 }
4948 }
4949
4950 /**
4951 * Called to get the block increment for upward scrolling in cases of
4952 * horizontal scrolling, or for vertical scrolling of a table with
4953 * variable row heights.
4954 */
4955 private int getPreviousBlockIncrement(Rectangle visibleRect,
4956 int orientation) {
4957 // Measure back from visible leading edge
4958 // If we hit the cell on its leading edge, it becomes the leading cell.
4959 // Else, use following cell
4960
4961 int row;
4962 int col;
4963
4964 int newEdge;
4965 Point newCellLoc;
4966
4967 int visibleLeadingEdge = leadingEdge(visibleRect, orientation);
4968 boolean leftToRight = getComponentOrientation().isLeftToRight();
4969 int newLeadingEdge;
4970
4971 // Roughly determine the new leading edge by measuring back from the
4972 // leading visible edge by the size of the visible rect, and find the
4973 // cell there.
4974 if (orientation == SwingConstants.VERTICAL) {
4975 newEdge = visibleLeadingEdge - visibleRect.height;
4976 int x = visibleRect.x + (leftToRight ? 0 : visibleRect.width);
4977 newCellLoc = new Point(x, newEdge);
4978 }
4979 else if (leftToRight) {
4980 newEdge = visibleLeadingEdge - visibleRect.width;
4981 newCellLoc = new Point(newEdge, visibleRect.y);
4982 }
4983 else { // Horizontal, right-to-left
4984 newEdge = visibleLeadingEdge + visibleRect.width;
4985 newCellLoc = new Point(newEdge - 1, visibleRect.y);
4986 }
4987 row = rowAtPoint(newCellLoc);
4988 col = columnAtPoint(newCellLoc);
4989
4990 // If we're measuring past the beginning of the table, we get an invalid
4991 // cell. Just go to the beginning of the table in this case.
4992 if (orientation == SwingConstants.VERTICAL & row < 0) {
4993 newLeadingEdge = 0;
4994 }
4995 else if (orientation == SwingConstants.HORIZONTAL & col < 0) {
4996 if (leftToRight) {
4997 newLeadingEdge = 0;
4998 }
4999 else {
5000 newLeadingEdge = getWidth();
5001 }
5002 }
5003 else {
5004 // Refine our measurement
5005 Rectangle newCellRect = getCellRect(row, col, true);
5006 int newCellLeadingEdge = leadingEdge(newCellRect, orientation);
5007 int newCellTrailingEdge = trailingEdge(newCellRect, orientation);
5008
5009 // Usually, we hit in the middle of newCell, and want to scroll to
5010 // the beginning of the cell after newCell. But there are a
5011 // couple corner cases where we want to scroll to the beginning of
5012 // newCell itself. These cases are:
5013 // 1) newCell is so large that it ends at or extends into the
5014 // visibleRect (newCell is the leading cell, or is adjacent to
5015 // the leading cell)
5016 // 2) newEdge happens to fall right on the beginning of a cell
5017
5018 // Case 1
5019 if ((orientation == SwingConstants.VERTICAL || leftToRight) &&
5020 (newCellTrailingEdge >= visibleLeadingEdge)) {
5021 newLeadingEdge = newCellLeadingEdge;
5022 }
5023 else if (orientation == SwingConstants.HORIZONTAL &&
5024 !leftToRight &&
5025 newCellTrailingEdge <= visibleLeadingEdge) {
5026 newLeadingEdge = newCellLeadingEdge;
5027 }
5028 // Case 2:
5029 else if (newEdge == newCellLeadingEdge) {
5030 newLeadingEdge = newCellLeadingEdge;
5031 }
5032 // Common case: scroll to cell after newCell
5033 else {
5034 newLeadingEdge = newCellTrailingEdge;
5035 }
5036 }
5037 return Math.abs(visibleLeadingEdge - newLeadingEdge);
5038 }
5039
5040 /**
5041 * Called to get the block increment for downward scrolling in cases of
5042 * horizontal scrolling, or for vertical scrolling of a table with
5043 * variable row heights.
5044 */
5045 private int getNextBlockIncrement(Rectangle visibleRect,
5046 int orientation) {
5047 // Find the cell at the trailing edge. Return the distance to put
5048 // that cell at the leading edge.
5049 int trailingRow = getTrailingRow(visibleRect);
5050 int trailingCol = getTrailingCol(visibleRect);
5051
5052 Rectangle cellRect;
5053 boolean cellFillsVis;
5054
5055 int cellLeadingEdge;
5056 int cellTrailingEdge;
5057 int newLeadingEdge;
5058 int visibleLeadingEdge = leadingEdge(visibleRect, orientation);
5059
5060 // If we couldn't find trailing cell, just return the size of the
5061 // visibleRect. Note that, for instance, we don't need the
5062 // trailingCol to proceed if we're scrolling vertically, because
5063 // cellRect will still fill in the required dimensions. This would
5064 // happen if we're scrolling vertically, and the table is not wide
5065 // enough to fill the visibleRect.
5066 if (orientation == SwingConstants.VERTICAL && trailingRow < 0) {
5067 return visibleRect.height;
5068 }
5069 else if (orientation == SwingConstants.HORIZONTAL && trailingCol < 0) {
5070 return visibleRect.width;
5071 }
5072 cellRect = getCellRect(trailingRow, trailingCol, true);
5073 cellLeadingEdge = leadingEdge(cellRect, orientation);
5074 cellTrailingEdge = trailingEdge(cellRect, orientation);
5075
5076 if (orientation == SwingConstants.VERTICAL ||
5077 getComponentOrientation().isLeftToRight()) {
5078 cellFillsVis = cellLeadingEdge <= visibleLeadingEdge;
5079 }
5080 else { // Horizontal, right-to-left
5081 cellFillsVis = cellLeadingEdge >= visibleLeadingEdge;
5082 }
5083
5084 if (cellFillsVis) {
5085 // The visibleRect contains a single large cell. Scroll to the end
5086 // of this cell, so the following cell is the first cell.
5087 newLeadingEdge = cellTrailingEdge;
5088 }
5089 else if (cellTrailingEdge == trailingEdge(visibleRect, orientation)) {
5090 // The trailing cell happens to end right at the end of the
5091 // visibleRect. Again, scroll to the beginning of the next cell.
5092 newLeadingEdge = cellTrailingEdge;
5093 }
5094 else {
5095 // Common case: the trailing cell is partially visible, and isn't
5096 // big enough to take up the entire visibleRect. Scroll so it
5097 // becomes the leading cell.
5098 newLeadingEdge = cellLeadingEdge;
5099 }
5100 return Math.abs(newLeadingEdge - visibleLeadingEdge);
5101 }
5102
5103 /*
5104 * Return the row at the top of the visibleRect
5105 *
5106 * May return -1
5107 */
5108 private int getLeadingRow(Rectangle visibleRect) {
5109 Point leadingPoint;
5110
5111 if (getComponentOrientation().isLeftToRight()) {
5112 leadingPoint = new Point(visibleRect.x, visibleRect.y);
5113 }
5114 else {
5115 leadingPoint = new Point(visibleRect.x + visibleRect.width - 1,
5116 visibleRect.y);
5117 }
5118 return rowAtPoint(leadingPoint);
5119 }
5120
5121 /*
5122 * Return the column at the leading edge of the visibleRect.
5123 *
5124 * May return -1
5125 */
5126 private int getLeadingCol(Rectangle visibleRect) {
5127 Point leadingPoint;
5128
5129 if (getComponentOrientation().isLeftToRight()) {
5130 leadingPoint = new Point(visibleRect.x, visibleRect.y);
5131 }
5132 else {
5133 leadingPoint = new Point(visibleRect.x + visibleRect.width - 1,
5134 visibleRect.y);
5135 }
5136 return columnAtPoint(leadingPoint);
5137 }
5138
5139 /*
5140 * Return the row at the bottom of the visibleRect.
5141 *
5142 * May return -1
5143 */
5144 private int getTrailingRow(Rectangle visibleRect) {
5145 Point trailingPoint;
5146
5147 if (getComponentOrientation().isLeftToRight()) {
5148 trailingPoint = new Point(visibleRect.x,
5149 visibleRect.y + visibleRect.height - 1);
5150 }
5151 else {
5152 trailingPoint = new Point(visibleRect.x + visibleRect.width - 1,
5153 visibleRect.y + visibleRect.height - 1);
5154 }
5155 return rowAtPoint(trailingPoint);
5156 }
5157
5158 /*
5159 * Return the column at the trailing edge of the visibleRect.
5160 *
5161 * May return -1
5162 */
5163 private int getTrailingCol(Rectangle visibleRect) {
5164 Point trailingPoint;
5165
5166 if (getComponentOrientation().isLeftToRight()) {
5167 trailingPoint = new Point(visibleRect.x + visibleRect.width - 1,
5168 visibleRect.y);
5169 }
5170 else {
5171 trailingPoint = new Point(visibleRect.x, visibleRect.y);
5172 }
5173 return columnAtPoint(trailingPoint);
5174 }
5175
5176 /*
5177 * Returns the leading edge ("beginning") of the given Rectangle.
5178 * For VERTICAL, this is the top, for left-to-right, the left side, and for
5179 * right-to-left, the right side.
5180 */
5181 private int leadingEdge(Rectangle rect, int orientation) {
5182 if (orientation == SwingConstants.VERTICAL) {
5183 return rect.y;
5184 }
5185 else if (getComponentOrientation().isLeftToRight()) {
5186 return rect.x;
5187 }
5188 else { // Horizontal, right-to-left
5189 return rect.x + rect.width;
5190 }
5191 }
5192
5193 /*
5194 * Returns the trailing edge ("end") of the given Rectangle.
5195 * For VERTICAL, this is the bottom, for left-to-right, the right side, and
5196 * for right-to-left, the left side.
5197 */
5198 private int trailingEdge(Rectangle rect, int orientation) {
5199 if (orientation == SwingConstants.VERTICAL) {
5200 return rect.y + rect.height;
5201 }
5202 else if (getComponentOrientation().isLeftToRight()) {
5203 return rect.x + rect.width;
5204 }
5205 else { // Horizontal, right-to-left
5206 return rect.x;
5207 }
5208 }
5209
5210 /**
5211 * Returns false if <code>autoResizeMode</code> is set to
5212 * <code>AUTO_RESIZE_OFF</code>, which indicates that the
5213 * width of the viewport does not determine the width
5214 * of the table. Otherwise returns true.
5215 *
5216 * @return false if <code>autoResizeMode</code> is set
5217 * to <code>AUTO_RESIZE_OFF</code>, otherwise returns true
5218 * @see Scrollable#getScrollableTracksViewportWidth
5219 */
5220 @BeanProperty(bound = false)
5221 public boolean getScrollableTracksViewportWidth() {
5222 return !(autoResizeMode == AUTO_RESIZE_OFF);
5223 }
5224
5225 /**
5226 * Returns {@code false} to indicate that the height of the viewport does
5227 * not determine the height of the table, unless
5228 * {@code getFillsViewportHeight} is {@code true} and the preferred height
5229 * of the table is smaller than the viewport's height.
5230 *
5231 * @return {@code false} unless {@code getFillsViewportHeight} is
5232 * {@code true} and the table needs to be stretched to fill
5233 * the viewport
5234 * @see Scrollable#getScrollableTracksViewportHeight
5235 * @see #setFillsViewportHeight
5236 * @see #getFillsViewportHeight
5237 */
5238 @BeanProperty(bound = false)
5239 public boolean getScrollableTracksViewportHeight() {
5240 Container parent = SwingUtilities.getUnwrappedParent(this);
5241 return getFillsViewportHeight()
5242 && parent instanceof JViewport
5243 && parent.getHeight() > getPreferredSize().height;
5244 }
5245
5246 /**
5247 * Sets whether or not this table is always made large enough
5248 * to fill the height of an enclosing viewport. If the preferred
5249 * height of the table is smaller than the viewport, then the table
5250 * will be stretched to fill the viewport. In other words, this
5251 * ensures the table is never smaller than the viewport.
5252 * The default for this property is {@code false}.
5253 *
5254 * @param fillsViewportHeight whether or not this table is always
5255 * made large enough to fill the height of an enclosing
5256 * viewport
5257 * @see #getFillsViewportHeight
5258 * @see #getScrollableTracksViewportHeight
5259 * @since 1.6
5260 */
5261 @BeanProperty(description
5262 = "Whether or not this table is always made large enough to fill the height of an enclosing viewport")
5263 public void setFillsViewportHeight(boolean fillsViewportHeight) {
5264 boolean old = this.fillsViewportHeight;
5265 this.fillsViewportHeight = fillsViewportHeight;
5266 resizeAndRepaint();
5267 firePropertyChange("fillsViewportHeight", old, fillsViewportHeight);
5268 }
5269
5270 /**
5271 * Returns whether or not this table is always made large enough
5272 * to fill the height of an enclosing viewport.
5273 *
5274 * @return whether or not this table is always made large enough
5275 * to fill the height of an enclosing viewport
5276 * @see #setFillsViewportHeight
5277 * @since 1.6
5278 */
5279 public boolean getFillsViewportHeight() {
5280 return fillsViewportHeight;
5281 }
5282
5283 //
5284 // Protected Methods
5285 //
5286
5287 protected boolean processKeyBinding(KeyStroke ks, KeyEvent e,
5288 int condition, boolean pressed) {
5289 boolean retValue = super.processKeyBinding(ks, e, condition, pressed);
5290
5291 // Start editing when a key is typed. UI classes can disable this behavior
5292 // by setting the client property JTable.autoStartsEdit to Boolean.FALSE.
5293 if (!retValue && condition == WHEN_ANCESTOR_OF_FOCUSED_COMPONENT &&
5294 isFocusOwner() &&
5295 !Boolean.FALSE.equals(getClientProperty("JTable.autoStartsEdit"))) {
5296 // We do not have a binding for the event.
5297 Component editorComponent = getEditorComponent();
5298 if (editorComponent == null) {
5299 // Only attempt to install the editor on a KEY_PRESSED,
5300 if (e == null || e.getID() != KeyEvent.KEY_PRESSED) {
5301 return false;
5302 }
5303 // Don't start when just a modifier is pressed
5304 int code = e.getKeyCode();
5305 if (code == KeyEvent.VK_SHIFT || code == KeyEvent.VK_CONTROL ||
5306 code == KeyEvent.VK_ALT) {
5307 return false;
5308 }
5309 // Try to install the editor
5310 int leadRow = getSelectionModel().getLeadSelectionIndex();
5311 int leadColumn = getColumnModel().getSelectionModel().
5312 getLeadSelectionIndex();
5313 if (leadRow != -1 && leadColumn != -1 && !isEditing()) {
5314 if (!editCellAt(leadRow, leadColumn, e)) {
5315 return false;
5316 }
5317 }
5318 editorComponent = getEditorComponent();
5319 if (editorComponent == null) {
5320 return false;
5321 }
5322 }
5323 // If the editorComponent is a JComponent, pass the event to it.
5324 if (editorComponent instanceof JComponent) {
5325 retValue = ((JComponent)editorComponent).processKeyBinding
5326 (ks, e, WHEN_FOCUSED, pressed);
5327 // If we have started an editor as a result of the user
5328 // pressing a key and the surrendersFocusOnKeystroke property
5329 // is true, give the focus to the new editor.
5330 if (getSurrendersFocusOnKeystroke()) {
5331 editorComponent.requestFocus();
5332 }
5333 }
5334 }
5335 return retValue;
5336 }
5337
5338 /**
5339 * Creates default cell renderers for objects, numbers, doubles, dates,
5340 * booleans, and icons.
5341 * @see javax.swing.table.DefaultTableCellRenderer
5342 *
5343 */
5344 protected void createDefaultRenderers() {
5345 defaultRenderersByColumnClass = new UIDefaults(8, 0.75f);
5346
5347 // Objects
5348 defaultRenderersByColumnClass.put(Object.class, (UIDefaults.LazyValue)
5349 t -> new DefaultTableCellRenderer.UIResource());
5350
5351 // Numbers
5352 defaultRenderersByColumnClass.put(Number.class, (UIDefaults.LazyValue)
5353 t -> new NumberRenderer());
5354
5355 // Doubles and Floats
5356 defaultRenderersByColumnClass.put(Float.class, (UIDefaults.LazyValue)
5357 t -> new DoubleRenderer());
5358 defaultRenderersByColumnClass.put(Double.class, (UIDefaults.LazyValue)
5359 t -> new DoubleRenderer());
5360
5361 // Dates
5362 defaultRenderersByColumnClass.put(Date.class, (UIDefaults.LazyValue)
5363 t -> new DateRenderer());
5364
5365 // Icons and ImageIcons
5366 defaultRenderersByColumnClass.put(Icon.class, (UIDefaults.LazyValue)
5367 t -> new IconRenderer());
5368 defaultRenderersByColumnClass.put(ImageIcon.class, (UIDefaults.LazyValue)
5369 t -> new IconRenderer());
5370
5371 // Booleans
5372 defaultRenderersByColumnClass.put(Boolean.class, (UIDefaults.LazyValue)
5373 t -> new BooleanRenderer());
5374 }
5375
5376 /**
5377 * Default Renderers
5378 **/
5379 static class NumberRenderer extends DefaultTableCellRenderer.UIResource {
5380 public NumberRenderer() {
5381 super();
5382 setHorizontalAlignment(JLabel.RIGHT);
5383 }
5384 }
5385
5386 static class DoubleRenderer extends NumberRenderer {
5387 NumberFormat formatter;
5388 public DoubleRenderer() { super(); }
5389
5390 public void setValue(Object value) {
5391 if (formatter == null) {
5392 formatter = NumberFormat.getInstance();
5393 }
5394 setText((value == null) ? "" : formatter.format(value));
5395 }
5396 }
5397
5398 static class DateRenderer extends DefaultTableCellRenderer.UIResource {
5399 DateFormat formatter;
5400 public DateRenderer() { super(); }
5401
5402 public void setValue(Object value) {
5403 if (formatter==null) {
5404 formatter = DateFormat.getDateInstance();
5405 }
5406 setText((value == null) ? "" : formatter.format(value));
5407 }
5408 }
5409
5410 static class IconRenderer extends DefaultTableCellRenderer.UIResource {
5411 public IconRenderer() {
5412 super();
5413 setHorizontalAlignment(JLabel.CENTER);
5414 }
5415 public void setValue(Object value) { setIcon((value instanceof Icon) ? (Icon)value : null); }
5416 }
5417
5418
5419 static class BooleanRenderer extends JCheckBox implements TableCellRenderer, UIResource
5420 {
5421 private static final Border noFocusBorder = new EmptyBorder(1, 1, 1, 1);
5422
5423 public BooleanRenderer() {
5424 super();
5425 setHorizontalAlignment(JLabel.CENTER);
5426 setBorderPainted(true);
5427 }
5428
5429 public Component getTableCellRendererComponent(JTable table, Object value,
5430 boolean isSelected, boolean hasFocus, int row, int column) {
5431 if (isSelected) {
5432 setForeground(table.getSelectionForeground());
5433 super.setBackground(table.getSelectionBackground());
5434 }
5435 else {
5436 setForeground(table.getForeground());
5437 setBackground(table.getBackground());
5438 }
5439 setSelected((value != null && ((Boolean)value).booleanValue()));
5440
5441 if (hasFocus) {
5442 setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
5443 } else {
5444 setBorder(noFocusBorder);
5445 }
5446
5447 return this;
5448 }
5449 }
5450
5451 /**
5452 * Creates default cell editors for objects, numbers, and boolean values.
5453 * @see DefaultCellEditor
5454 */
5455 protected void createDefaultEditors() {
5456 defaultEditorsByColumnClass = new UIDefaults(3, 0.75f);
5457
5458 // Objects
5459 defaultEditorsByColumnClass.put(Object.class, (UIDefaults.LazyValue)
5460 t -> new GenericEditor());
5461
5462 // Numbers
5463 defaultEditorsByColumnClass.put(Number.class, (UIDefaults.LazyValue)
5464 t -> new NumberEditor());
5465
5466 // Booleans
5467 defaultEditorsByColumnClass.put(Boolean.class, (UIDefaults.LazyValue)
5468 t -> new BooleanEditor());
5469 }
5470
5471 /**
5472 * Default Editors
5473 */
5474 static class GenericEditor extends DefaultCellEditor {
5475
5476 Class<?>[] argTypes = new Class<?>[]{String.class};
5477 java.lang.reflect.Constructor<?> constructor;
5478 Object value;
5479
5480 public GenericEditor() {
5481 super(new JTextField());
5482 getComponent().setName("Table.editor");
5483 }
5484
5485 public boolean stopCellEditing() {
5486 String s = (String)super.getCellEditorValue();
5487 // Here we are dealing with the case where a user
5488 // has deleted the string value in a cell, possibly
5489 // after a failed validation. Return null, so that
5490 // they have the option to replace the value with
5491 // null or use escape to restore the original.
5492 // For Strings, return "" for backward compatibility.
5493 try {
5494 if ("".equals(s)) {
5495 if (constructor.getDeclaringClass() == String.class) {
5496 value = s;
5497 }
5498 return super.stopCellEditing();
5499 }
5500
5501 SwingUtilities2.checkAccess(constructor.getModifiers());
5502 value = constructor.newInstance(new Object[]{s});
5503 }
5504 catch (Exception e) {
5505 ((JComponent)getComponent()).setBorder(new LineBorder(Color.red));
5506 return false;
5507 }
5508 return super.stopCellEditing();
5509 }
5510
5511 public Component getTableCellEditorComponent(JTable table, Object value,
5512 boolean isSelected,
5513 int row, int column) {
5514 this.value = null;
5515 ((JComponent)getComponent()).setBorder(new LineBorder(Color.black));
5516 try {
5517 Class<?> type = table.getColumnClass(column);
5518 // Since our obligation is to produce a value which is
5519 // assignable for the required type it is OK to use the
5520 // String constructor for columns which are declared
5521 // to contain Objects. A String is an Object.
5522 if (type == Object.class) {
5523 type = String.class;
5524 }
5525 ReflectUtil.checkPackageAccess(type);
5526 SwingUtilities2.checkAccess(type.getModifiers());
5527 constructor = type.getConstructor(argTypes);
5528 }
5529 catch (Exception e) {
5530 return null;
5531 }
5532 return super.getTableCellEditorComponent(table, value, isSelected, row, column);
5533 }
5534
5535 public Object getCellEditorValue() {
5536 return value;
5537 }
5538 }
5539
5540 static class NumberEditor extends GenericEditor {
5541
5542 public NumberEditor() {
5543 ((JTextField)getComponent()).setHorizontalAlignment(JTextField.RIGHT);
5544 }
5545 }
5546
5547 static class BooleanEditor extends DefaultCellEditor {
5548 public BooleanEditor() {
5549 super(new JCheckBox());
5550 JCheckBox checkBox = (JCheckBox)getComponent();
5551 checkBox.setHorizontalAlignment(JCheckBox.CENTER);
5552 }
5553 }
5554
5555 /**
5556 * Initializes table properties to their default values.
5557 */
5558 protected void initializeLocalVars() {
5559 updateSelectionOnSort = true;
5560 setOpaque(true);
5561 createDefaultRenderers();
5562 createDefaultEditors();
5563
5564 setTableHeader(createDefaultTableHeader());
5565
5566 setShowGrid(true);
5567 setAutoResizeMode(AUTO_RESIZE_SUBSEQUENT_COLUMNS);
5568 setRowHeight(16);
5569 isRowHeightSet = false;
5570 setRowMargin(1);
5571 setRowSelectionAllowed(true);
5572 setCellEditor(null);
5573 setEditingColumn(-1);
5574 setEditingRow(-1);
5575 setSurrendersFocusOnKeystroke(false);
5576 setPreferredScrollableViewportSize(new Dimension(450, 400));
5577
5578 // I'm registered to do tool tips so we can draw tips for the renderers
5579 ToolTipManager toolTipManager = ToolTipManager.sharedInstance();
5580 toolTipManager.registerComponent(this);
5581
5582 setAutoscrolls(true);
5583 }
5584
5585 /**
5586 * Returns the default table model object, which is
5587 * a <code>DefaultTableModel</code>. A subclass can override this
5588 * method to return a different table model object.
5589 *
5590 * @return the default table model object
5591 * @see javax.swing.table.DefaultTableModel
5592 */
5593 protected TableModel createDefaultDataModel() {
5594 return new DefaultTableModel();
5595 }
5596
5597 /**
5598 * Returns the default column model object, which is
5599 * a <code>DefaultTableColumnModel</code>. A subclass can override this
5600 * method to return a different column model object.
5601 *
5602 * @return the default column model object
5603 * @see javax.swing.table.DefaultTableColumnModel
5604 */
5605 protected TableColumnModel createDefaultColumnModel() {
5606 return new DefaultTableColumnModel();
5607 }
5608
5609 /**
5610 * Returns the default selection model object, which is
5611 * a <code>DefaultListSelectionModel</code>. A subclass can override this
5612 * method to return a different selection model object.
5613 *
5614 * @return the default selection model object
5615 * @see javax.swing.DefaultListSelectionModel
5616 */
5617 protected ListSelectionModel createDefaultSelectionModel() {
5618 return new DefaultListSelectionModel();
5619 }
5620
5621 /**
5622 * Returns the default table header object, which is
5623 * a <code>JTableHeader</code>. A subclass can override this
5624 * method to return a different table header object.
5625 *
5626 * @return the default table header object
5627 * @see javax.swing.table.JTableHeader
5628 */
5629 protected JTableHeader createDefaultTableHeader() {
5630 return new JTableHeader(columnModel);
5631 }
5632
5633 /**
5634 * Equivalent to <code>revalidate</code> followed by <code>repaint</code>.
5635 */
5636 protected void resizeAndRepaint() {
5637 revalidate();
5638 repaint();
5639 }
5640
5641 /**
5642 * Returns the active cell editor, which is {@code null} if the table
5643 * is not currently editing.
5644 *
5645 * @return the {@code TableCellEditor} that does the editing,
5646 * or {@code null} if the table is not currently editing.
5647 * @see #cellEditor
5648 * @see #getCellEditor(int, int)
5649 */
5650 public TableCellEditor getCellEditor() {
5651 return cellEditor;
5652 }
5653
5654 /**
5655 * Sets the active cell editor.
5656 *
5657 * @param anEditor the active cell editor
5658 * @see #cellEditor
5659 */
5660 @BeanProperty(description
5661 = "The table's active cell editor.")
5662 public void setCellEditor(TableCellEditor anEditor) {
5663 TableCellEditor oldEditor = cellEditor;
5664 cellEditor = anEditor;
5665 firePropertyChange("tableCellEditor", oldEditor, anEditor);
5666 }
5667
5668 /**
5669 * Sets the <code>editingColumn</code> variable.
5670 * @param aColumn the column of the cell to be edited
5671 *
5672 * @see #editingColumn
5673 */
5674 public void setEditingColumn(int aColumn) {
5675 editingColumn = aColumn;
5676 }
5677
5678 /**
5679 * Sets the <code>editingRow</code> variable.
5680 * @param aRow the row of the cell to be edited
5681 *
5682 * @see #editingRow
5683 */
5684 public void setEditingRow(int aRow) {
5685 editingRow = aRow;
5686 }
5687
5688 /**
5689 * Returns an appropriate renderer for the cell specified by this row and
5690 * column. If the <code>TableColumn</code> for this column has a non-null
5691 * renderer, returns that. If not, finds the class of the data in
5692 * this column (using <code>getColumnClass</code>)
5693 * and returns the default renderer for this type of data.
5694 * <p>
5695 * <b>Note:</b>
5696 * Throughout the table package, the internal implementations always
5697 * use this method to provide renderers so that this default behavior
5698 * can be safely overridden by a subclass.
5699 *
5700 * @param row the row of the cell to render, where 0 is the first row
5701 * @param column the column of the cell to render,
5702 * where 0 is the first column
5703 * @return the assigned renderer; if <code>null</code>
5704 * returns the default renderer
5705 * for this type of object
5706 * @see javax.swing.table.DefaultTableCellRenderer
5707 * @see javax.swing.table.TableColumn#setCellRenderer
5708 * @see #setDefaultRenderer
5709 */
5710 public TableCellRenderer getCellRenderer(int row, int column) {
5711 TableColumn tableColumn = getColumnModel().getColumn(column);
5712 TableCellRenderer renderer = tableColumn.getCellRenderer();
5713 if (renderer == null) {
5714 renderer = getDefaultRenderer(getColumnClass(column));
5715 }
5716 return renderer;
5717 }
5718
5719 /**
5720 * Prepares the renderer by querying the data model for the
5721 * value and selection state
5722 * of the cell at <code>row</code>, <code>column</code>.
5723 * Returns the component (may be a <code>Component</code>
5724 * or a <code>JComponent</code>) under the event location.
5725 * <p>
5726 * During a printing operation, this method will configure the
5727 * renderer without indicating selection or focus, to prevent
5728 * them from appearing in the printed output. To do other
5729 * customizations based on whether or not the table is being
5730 * printed, you can check the value of
5731 * {@link javax.swing.JComponent#isPaintingForPrint()}, either here
5732 * or within custom renderers.
5733 * <p>
5734 * <b>Note:</b>
5735 * Throughout the table package, the internal implementations always
5736 * use this method to prepare renderers so that this default behavior
5737 * can be safely overridden by a subclass.
5738 *
5739 * @param renderer the <code>TableCellRenderer</code> to prepare
5740 * @param row the row of the cell to render, where 0 is the first row
5741 * @param column the column of the cell to render,
5742 * where 0 is the first column
5743 * @return the <code>Component</code> under the event location
5744 */
5745 public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
5746 Object value = getValueAt(row, column);
5747
5748 boolean isSelected = false;
5749 boolean hasFocus = false;
5750
5751 // Only indicate the selection and focused cell if not printing
5752 if (!isPaintingForPrint()) {
5753 isSelected = isCellSelected(row, column);
5754
5755 boolean rowIsLead =
5756 (selectionModel.getLeadSelectionIndex() == row);
5757 boolean colIsLead =
5758 (columnModel.getSelectionModel().getLeadSelectionIndex() == column);
5759
5760 hasFocus = (rowIsLead && colIsLead) && isFocusOwner();
5761 }
5762
5763 return renderer.getTableCellRendererComponent(this, value,
5764 isSelected, hasFocus,
5765 row, column);
5766 }
5767
5768 /**
5769 * Returns an appropriate editor for the cell specified by
5770 * <code>row</code> and <code>column</code>. If the
5771 * <code>TableColumn</code> for this column has a non-null editor,
5772 * returns that. If not, finds the class of the data in this
5773 * column (using <code>getColumnClass</code>)
5774 * and returns the default editor for this type of data.
5775 * <p>
5776 * <b>Note:</b>
5777 * Throughout the table package, the internal implementations always
5778 * use this method to provide editors so that this default behavior
5779 * can be safely overridden by a subclass.
5780 *
5781 * @param row the row of the cell to edit, where 0 is the first row
5782 * @param column the column of the cell to edit,
5783 * where 0 is the first column
5784 * @return the editor for this cell;
5785 * if <code>null</code> return the default editor for
5786 * this type of cell
5787 * @see DefaultCellEditor
5788 */
5789 public TableCellEditor getCellEditor(int row, int column) {
5790 TableColumn tableColumn = getColumnModel().getColumn(column);
5791 TableCellEditor editor = tableColumn.getCellEditor();
5792 if (editor == null) {
5793 editor = getDefaultEditor(getColumnClass(column));
5794 }
5795 return editor;
5796 }
5797
5798
5799 /**
5800 * Prepares the editor by querying the data model for the value and
5801 * selection state of the cell at <code>row</code>, <code>column</code>.
5802 * <p>
5803 * <b>Note:</b>
5804 * Throughout the table package, the internal implementations always
5805 * use this method to prepare editors so that this default behavior
5806 * can be safely overridden by a subclass.
5807 *
5808 * @param editor the <code>TableCellEditor</code> to set up
5809 * @param row the row of the cell to edit,
5810 * where 0 is the first row
5811 * @param column the column of the cell to edit,
5812 * where 0 is the first column
5813 * @return the <code>Component</code> being edited
5814 */
5815 @SuppressWarnings("deprecation")
5816 public Component prepareEditor(TableCellEditor editor, int row, int column) {
5817 Object value = getValueAt(row, column);
5818 boolean isSelected = isCellSelected(row, column);
5819 Component comp = editor.getTableCellEditorComponent(this, value, isSelected,
5820 row, column);
5821 if (comp instanceof JComponent) {
5822 JComponent jComp = (JComponent)comp;
5823 if (jComp.getNextFocusableComponent() == null) {
5824 jComp.setNextFocusableComponent(this);
5825 }
5826 }
5827 return comp;
5828 }
5829
5830 /**
5831 * Discards the editor object and frees the real estate it used for
5832 * cell rendering.
5833 */
5834 public void removeEditor() {
5835 KeyboardFocusManager.getCurrentKeyboardFocusManager().
5836 removePropertyChangeListener("permanentFocusOwner", editorRemover);
5837 editorRemover = null;
5838
5839 TableCellEditor editor = getCellEditor();
5840 if(editor != null) {
5841 editor.removeCellEditorListener(this);
5842 if (editorComp != null) {
5843 Component focusOwner =
5844 KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
5845 boolean isFocusOwnerInTheTable = focusOwner != null?
5846 SwingUtilities.isDescendingFrom(focusOwner, this):false;
5847 remove(editorComp);
5848 if(isFocusOwnerInTheTable) {
5849 requestFocusInWindow();
5850 }
5851 }
5852
5853 Rectangle cellRect = getCellRect(editingRow, editingColumn, false);
5854
5855 setCellEditor(null);
5856 setEditingColumn(-1);
5857 setEditingRow(-1);
5858 editorComp = null;
5859
5860 repaint(cellRect);
5861 }
5862 }
5863
5864 //
5865 // Serialization
5866 //
5867
5868 /**
5869 * See readObject() and writeObject() in JComponent for more
5870 * information about serialization in Swing.
5871 */
5872 private void writeObject(ObjectOutputStream s) throws IOException {
5873 s.defaultWriteObject();
5874 if (getUIClassID().equals(uiClassID)) {
5875 byte count = JComponent.getWriteObjCounter(this);
5876 JComponent.setWriteObjCounter(this, --count);
5877 if (count == 0 && ui != null) {
5878 ui.installUI(this);
5879 }
5880 }
5881 }
5882
5883 private void readObject(ObjectInputStream s)
5884 throws IOException, ClassNotFoundException
5885 {
5886 ObjectInputStream.GetField f = s.readFields();
5887
5888 TableModel newDataModel = (TableModel) f.get("dataModel", null);
5889 if (newDataModel == null) {
5890 throw new InvalidObjectException("Null dataModel");
5891 }
5892 dataModel = newDataModel;
5893
5894 TableColumnModel newColumnModel = (TableColumnModel) f.get("columnModel", null);
5895 if (newColumnModel == null) {
5896 throw new InvalidObjectException("Null columnModel");
5897 }
5898 columnModel = newColumnModel;
5899
5900 ListSelectionModel newSelectionModel = (ListSelectionModel) f.get("selectionModel", null);
5901 if (newSelectionModel == null) {
5902 throw new InvalidObjectException("Null selectionModel");
5903 }
5904 selectionModel = newSelectionModel;
5905
5906 tableHeader = (JTableHeader) f.get("tableHeader", null);
5907 int newRowHeight = f.get("rowHeight", 0);
5908 if (newRowHeight <= 0) {
5909 throw new InvalidObjectException("Row height less than 1");
5910 }
5911 rowHeight = newRowHeight;
5912
5913 rowMargin = f.get("rowMargin", 0);
5914 Color newGridColor = (Color) f.get("gridColor", null);
5915 if (newGridColor == null) {
5916 throw new InvalidObjectException("Null gridColor");
5917 }
5918 gridColor = newGridColor;
5919
5920 showHorizontalLines = f.get("showHorizontalLines", false);
5921 showVerticalLines = f.get("showVerticalLines", false);
5922 int newAutoResizeMode = f.get("autoResizeMode", 0);
5923 if (!isValidAutoResizeMode(newAutoResizeMode)) {
5924 throw new InvalidObjectException("autoResizeMode is not valid");
5925 }
5926 autoResizeMode = newAutoResizeMode;
5927 autoCreateColumnsFromModel = f.get("autoCreateColumnsFromModel", false);
5928 preferredViewportSize = (Dimension) f.get("preferredViewportSize", null);
5929 rowSelectionAllowed = f.get("rowSelectionAllowed", false);
5930 cellSelectionEnabled = f.get("cellSelectionEnabled", false);
5931 selectionForeground = (Color) f.get("selectionForeground", null);
5932 selectionBackground = (Color) f.get("selectionBackground", null);
5933 rowModel = (SizeSequence) f.get("rowModel", null);
5934
5935 boolean newDragEnabled = f.get("dragEnabled", false);
5936 checkDragEnabled(newDragEnabled);
5937 dragEnabled = newDragEnabled;
5938
5939 surrendersFocusOnKeystroke = f.get("surrendersFocusOnKeystroke", false);
5940 editorRemover = (PropertyChangeListener) f.get("editorRemover", null);
5941 columnSelectionAdjusting = f.get("columnSelectionAdjusting", false);
5942 rowSelectionAdjusting = f.get("rowSelectionAdjusting", false);
5943 printError = (Throwable) f.get("printError", null);
5944 isRowHeightSet = f.get("isRowHeightSet", false);
5945 updateSelectionOnSort = f.get("updateSelectionOnSort", false);
5946 ignoreSortChange = f.get("ignoreSortChange", false);
5947 sorterChanged = f.get("sorterChanged", false);
5948 autoCreateRowSorter = f.get("autoCreateRowSorter", false);
5949 fillsViewportHeight = f.get("fillsViewportHeight", false);
5950 DropMode newDropMode = (DropMode) f.get("dropMode",
5951 DropMode.USE_SELECTION);
5952 checkDropMode(newDropMode);
5953 dropMode = newDropMode;
5954
5955 if ((ui != null) && (getUIClassID().equals(uiClassID))) {
5956 ui.installUI(this);
5957 }
5958 createDefaultRenderers();
5959 createDefaultEditors();
5960
5961 // If ToolTipText != null, then the tooltip has already been
5962 // registered by JComponent.readObject() and we don't want
5963 // to re-register here
5964 if (getToolTipText() == null) {
5965 ToolTipManager.sharedInstance().registerComponent(this);
5966 }
5967 }
5968
5969 /* Called from the JComponent's EnableSerializationFocusListener to
5970 * do any Swing-specific pre-serialization configuration.
5971 */
5972 void compWriteObjectNotify() {
5973 super.compWriteObjectNotify();
5974 // If ToolTipText != null, then the tooltip has already been
5975 // unregistered by JComponent.compWriteObjectNotify()
5976 if (getToolTipText() == null) {
5977 ToolTipManager.sharedInstance().unregisterComponent(this);
5978 }
5979 }
5980
5981 /**
5982 * Returns a string representation of this table. This method
5983 * is intended to be used only for debugging purposes, and the
5984 * content and format of the returned string may vary between
5985 * implementations. The returned string may be empty but may not
5986 * be <code>null</code>.
5987 *
5988 * @return a string representation of this table
5989 */
5990 protected String paramString() {
5991 String gridColorString = (gridColor != null ?
5992 gridColor.toString() : "");
5993 String showHorizontalLinesString = (showHorizontalLines ?
5994 "true" : "false");
5995 String showVerticalLinesString = (showVerticalLines ?
5996 "true" : "false");
5997 String autoResizeModeString;
5998 if (autoResizeMode == AUTO_RESIZE_OFF) {
5999 autoResizeModeString = "AUTO_RESIZE_OFF";
6000 } else if (autoResizeMode == AUTO_RESIZE_NEXT_COLUMN) {
6001 autoResizeModeString = "AUTO_RESIZE_NEXT_COLUMN";
6002 } else if (autoResizeMode == AUTO_RESIZE_SUBSEQUENT_COLUMNS) {
6003 autoResizeModeString = "AUTO_RESIZE_SUBSEQUENT_COLUMNS";
6004 } else if (autoResizeMode == AUTO_RESIZE_LAST_COLUMN) {
6005 autoResizeModeString = "AUTO_RESIZE_LAST_COLUMN";
6006 } else if (autoResizeMode == AUTO_RESIZE_ALL_COLUMNS) {
6007 autoResizeModeString = "AUTO_RESIZE_ALL_COLUMNS";
6008 } else autoResizeModeString = "";
6009 String autoCreateColumnsFromModelString = (autoCreateColumnsFromModel ?
6010 "true" : "false");
6011 String preferredViewportSizeString = (preferredViewportSize != null ?
6012 preferredViewportSize.toString()
6013 : "");
6014 String rowSelectionAllowedString = (rowSelectionAllowed ?
6015 "true" : "false");
6016 String cellSelectionEnabledString = (cellSelectionEnabled ?
6017 "true" : "false");
6018 String selectionForegroundString = (selectionForeground != null ?
6019 selectionForeground.toString() :
6020 "");
6021 String selectionBackgroundString = (selectionBackground != null ?
6022 selectionBackground.toString() :
6023 "");
6024
6025 return super.paramString() +
6026 ",autoCreateColumnsFromModel=" + autoCreateColumnsFromModelString +
6027 ",autoResizeMode=" + autoResizeModeString +
6028 ",cellSelectionEnabled=" + cellSelectionEnabledString +
6029 ",editingColumn=" + editingColumn +
6030 ",editingRow=" + editingRow +
6031 ",gridColor=" + gridColorString +
6032 ",preferredViewportSize=" + preferredViewportSizeString +
6033 ",rowHeight=" + rowHeight +
6034 ",rowMargin=" + rowMargin +
6035 ",rowSelectionAllowed=" + rowSelectionAllowedString +
6036 ",selectionBackground=" + selectionBackgroundString +
6037 ",selectionForeground=" + selectionForegroundString +
6038 ",showHorizontalLines=" + showHorizontalLinesString +
6039 ",showVerticalLines=" + showVerticalLinesString;
6040 }
6041
6042 // This class tracks changes in the keyboard focus state. It is used
6043 // when the JTable is editing to determine when to cancel the edit.
6044 // If focus switches to a component outside of the jtable, but in the
6045 // same window, this will cancel editing.
6046 class CellEditorRemover implements PropertyChangeListener {
6047 KeyboardFocusManager focusManager;
6048
6049 public CellEditorRemover(KeyboardFocusManager fm) {
6050 this.focusManager = fm;
6051 }
6052
6053 @SuppressWarnings("deprecation")
6054 public void propertyChange(PropertyChangeEvent ev) {
6055 if (!isEditing() || getClientProperty("terminateEditOnFocusLost") != Boolean.TRUE) {
6056 return;
6057 }
6058
6059 Component c = focusManager.getPermanentFocusOwner();
6060 while (c != null) {
6061 if (c == JTable.this) {
6062 // focus remains inside the table
6063 return;
6064 } else if ((c instanceof Window) ||
6065 (c instanceof Applet && c.getParent() == null)) {
6066 if (c == SwingUtilities.getRoot(JTable.this)) {
6067 if (!getCellEditor().stopCellEditing()) {
6068 getCellEditor().cancelCellEditing();
6069 }
6070 }
6071 break;
6072 }
6073 c = c.getParent();
6074 }
6075 }
6076 }
6077
6078 /////////////////
6079 // Printing Support
6080 /////////////////
6081
6082 /**
6083 * A convenience method that displays a printing dialog, and then prints
6084 * this <code>JTable</code> in mode <code>PrintMode.FIT_WIDTH</code>,
6085 * with no header or footer text. A modal progress dialog, with an abort
6086 * option, will be shown for the duration of printing.
6087 * <p>
6088 * Note: In headless mode, no dialogs are shown and printing
6089 * occurs on the default printer.
6090 *
6091 * @return true, unless printing is cancelled by the user
6092 * @throws SecurityException if this thread is not allowed to
6093 * initiate a print job request
6094 * @throws PrinterException if an error in the print system causes the job
6095 * to be aborted
6096 * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
6097 * boolean, PrintRequestAttributeSet, boolean, PrintService)
6098 * @see #getPrintable
6099 *
6100 * @since 1.5
6101 */
6102 public boolean print() throws PrinterException {
6103
6104 return print(PrintMode.FIT_WIDTH);
6105 }
6106
6107 /**
6108 * A convenience method that displays a printing dialog, and then prints
6109 * this <code>JTable</code> in the given printing mode,
6110 * with no header or footer text. A modal progress dialog, with an abort
6111 * option, will be shown for the duration of printing.
6112 * <p>
6113 * Note: In headless mode, no dialogs are shown and printing
6114 * occurs on the default printer.
6115 *
6116 * @param printMode the printing mode that the printable should use
6117 * @return true, unless printing is cancelled by the user
6118 * @throws SecurityException if this thread is not allowed to
6119 * initiate a print job request
6120 * @throws PrinterException if an error in the print system causes the job
6121 * to be aborted
6122 * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
6123 * boolean, PrintRequestAttributeSet, boolean, PrintService)
6124 * @see #getPrintable
6125 *
6126 * @since 1.5
6127 */
6128 public boolean print(PrintMode printMode) throws PrinterException {
6129
6130 return print(printMode, null, null);
6131 }
6132
6133 /**
6134 * A convenience method that displays a printing dialog, and then prints
6135 * this <code>JTable</code> in the given printing mode,
6136 * with the specified header and footer text. A modal progress dialog,
6137 * with an abort option, will be shown for the duration of printing.
6138 * <p>
6139 * Note: In headless mode, no dialogs are shown and printing
6140 * occurs on the default printer.
6141 *
6142 * @param printMode the printing mode that the printable should use
6143 * @param headerFormat a <code>MessageFormat</code> specifying the text
6144 * to be used in printing a header,
6145 * or null for none
6146 * @param footerFormat a <code>MessageFormat</code> specifying the text
6147 * to be used in printing a footer,
6148 * or null for none
6149 * @return true, unless printing is cancelled by the user
6150 * @throws SecurityException if this thread is not allowed to
6151 * initiate a print job request
6152 * @throws PrinterException if an error in the print system causes the job
6153 * to be aborted
6154 * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
6155 * boolean, PrintRequestAttributeSet, boolean, PrintService)
6156 * @see #getPrintable
6157 *
6158 * @since 1.5
6159 */
6160 public boolean print(PrintMode printMode,
6161 MessageFormat headerFormat,
6162 MessageFormat footerFormat) throws PrinterException {
6163
6164 boolean showDialogs = !GraphicsEnvironment.isHeadless();
6165 return print(printMode, headerFormat, footerFormat,
6166 showDialogs, null, showDialogs);
6167 }
6168
6169 /**
6170 * Prints this table, as specified by the fully featured
6171 * {@link #print(JTable.PrintMode, MessageFormat, MessageFormat,
6172 * boolean, PrintRequestAttributeSet, boolean, PrintService) print}
6173 * method, with the default printer specified as the print service.
6174 *
6175 * @param printMode the printing mode that the printable should use
6176 * @param headerFormat a <code>MessageFormat</code> specifying the text
6177 * to be used in printing a header,
6178 * or <code>null</code> for none
6179 * @param footerFormat a <code>MessageFormat</code> specifying the text
6180 * to be used in printing a footer,
6181 * or <code>null</code> for none
6182 * @param showPrintDialog whether or not to display a print dialog
6183 * @param attr a <code>PrintRequestAttributeSet</code>
6184 * specifying any printing attributes,
6185 * or <code>null</code> for none
6186 * @param interactive whether or not to print in an interactive mode
6187 * @return true, unless printing is cancelled by the user
6188 * @throws HeadlessException if the method is asked to show a printing
6189 * dialog or run interactively, and
6190 * <code>GraphicsEnvironment.isHeadless</code>
6191 * returns <code>true</code>
6192 * @throws SecurityException if this thread is not allowed to
6193 * initiate a print job request
6194 * @throws PrinterException if an error in the print system causes the job
6195 * to be aborted
6196 * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
6197 * boolean, PrintRequestAttributeSet, boolean, PrintService)
6198 * @see #getPrintable
6199 *
6200 * @since 1.5
6201 */
6202 public boolean print(PrintMode printMode,
6203 MessageFormat headerFormat,
6204 MessageFormat footerFormat,
6205 boolean showPrintDialog,
6206 PrintRequestAttributeSet attr,
6207 boolean interactive) throws PrinterException,
6208 HeadlessException {
6209
6210 return print(printMode,
6211 headerFormat,
6212 footerFormat,
6213 showPrintDialog,
6214 attr,
6215 interactive,
6216 null);
6217 }
6218
6219 /**
6220 * Prints this <code>JTable</code>. Takes steps that the majority of
6221 * developers would take in order to print a <code>JTable</code>.
6222 * In short, it prepares the table, calls <code>getPrintable</code> to
6223 * fetch an appropriate <code>Printable</code>, and then sends it to the
6224 * printer.
6225 * <p>
6226 * A <code>boolean</code> parameter allows you to specify whether or not
6227 * a printing dialog is displayed to the user. When it is, the user may
6228 * use the dialog to change the destination printer or printing attributes,
6229 * or even to cancel the print. Another two parameters allow for a
6230 * <code>PrintService</code> and printing attributes to be specified.
6231 * These parameters can be used either to provide initial values for the
6232 * print dialog, or to specify values when the dialog is not shown.
6233 * <p>
6234 * A second <code>boolean</code> parameter allows you to specify whether
6235 * or not to perform printing in an interactive mode. If <code>true</code>,
6236 * a modal progress dialog, with an abort option, is displayed for the
6237 * duration of printing . This dialog also prevents any user action which
6238 * may affect the table. However, it can not prevent the table from being
6239 * modified by code (for example, another thread that posts updates using
6240 * <code>SwingUtilities.invokeLater</code>). It is therefore the
6241 * responsibility of the developer to ensure that no other code modifies
6242 * the table in any way during printing (invalid modifications include
6243 * changes in: size, renderers, or underlying data). Printing behavior is
6244 * undefined when the table is changed during printing.
6245 * <p>
6246 * If <code>false</code> is specified for this parameter, no dialog will
6247 * be displayed and printing will begin immediately on the event-dispatch
6248 * thread. This blocks any other events, including repaints, from being
6249 * processed until printing is complete. Although this effectively prevents
6250 * the table from being changed, it doesn't provide a good user experience.
6251 * For this reason, specifying <code>false</code> is only recommended when
6252 * printing from an application with no visible GUI.
6253 * <p>
6254 * Note: Attempting to show the printing dialog or run interactively, while
6255 * in headless mode, will result in a <code>HeadlessException</code>.
6256 * <p>
6257 * Before fetching the printable, this method will gracefully terminate
6258 * editing, if necessary, to prevent an editor from showing in the printed
6259 * result. Additionally, <code>JTable</code> will prepare its renderers
6260 * during printing such that selection and focus are not indicated.
6261 * As far as customizing further how the table looks in the printout,
6262 * developers can provide custom renderers or paint code that conditionalize
6263 * on the value of {@link javax.swing.JComponent#isPaintingForPrint()}.
6264 * <p>
6265 * See {@link #getPrintable} for more description on how the table is
6266 * printed.
6267 *
6268 * @param printMode the printing mode that the printable should use
6269 * @param headerFormat a <code>MessageFormat</code> specifying the text
6270 * to be used in printing a header,
6271 * or <code>null</code> for none
6272 * @param footerFormat a <code>MessageFormat</code> specifying the text
6273 * to be used in printing a footer,
6274 * or <code>null</code> for none
6275 * @param showPrintDialog whether or not to display a print dialog
6276 * @param attr a <code>PrintRequestAttributeSet</code>
6277 * specifying any printing attributes,
6278 * or <code>null</code> for none
6279 * @param interactive whether or not to print in an interactive mode
6280 * @param service the destination <code>PrintService</code>,
6281 * or <code>null</code> to use the default printer
6282 * @return true, unless printing is cancelled by the user
6283 * @throws HeadlessException if the method is asked to show a printing
6284 * dialog or run interactively, and
6285 * <code>GraphicsEnvironment.isHeadless</code>
6286 * returns <code>true</code>
6287 * @throws SecurityException if a security manager exists and its
6288 * {@link java.lang.SecurityManager#checkPrintJobAccess}
6289 * method disallows this thread from creating a print job request
6290 * @throws PrinterException if an error in the print system causes the job
6291 * to be aborted
6292 * @see #getPrintable
6293 * @see java.awt.GraphicsEnvironment#isHeadless
6294 *
6295 * @since 1.6
6296 */
6297 public boolean print(PrintMode printMode,
6298 MessageFormat headerFormat,
6299 MessageFormat footerFormat,
6300 boolean showPrintDialog,
6301 PrintRequestAttributeSet attr,
6302 boolean interactive,
6303 PrintService service) throws PrinterException,
6304 HeadlessException {
6305
6306 // complain early if an invalid parameter is specified for headless mode
6307 boolean isHeadless = GraphicsEnvironment.isHeadless();
6308 if (isHeadless) {
6309 if (showPrintDialog) {
6310 throw new HeadlessException("Can't show print dialog.");
6311 }
6312
6313 if (interactive) {
6314 throw new HeadlessException("Can't run interactively.");
6315 }
6316 }
6317
6318 // Get a PrinterJob.
6319 // Do this before anything with side-effects since it may throw a
6320 // security exception - in which case we don't want to do anything else.
6321 final PrinterJob job = PrinterJob.getPrinterJob();
6322
6323 if (isEditing()) {
6324 // try to stop cell editing, and failing that, cancel it
6325 if (!getCellEditor().stopCellEditing()) {
6326 getCellEditor().cancelCellEditing();
6327 }
6328 }
6329
6330 if (attr == null) {
6331 attr = new HashPrintRequestAttributeSet();
6332 }
6333
6334 final PrintingStatus printingStatus;
6335
6336 // fetch the Printable
6337 Printable printable =
6338 getPrintable(printMode, headerFormat, footerFormat);
6339
6340 if (interactive) {
6341 // wrap the Printable so that we can print on another thread
6342 printable = new ThreadSafePrintable(printable);
6343 printingStatus = PrintingStatus.createPrintingStatus(this, job);
6344 printable = printingStatus.createNotificationPrintable(printable);
6345 } else {
6346 // to please compiler
6347 printingStatus = null;
6348 }
6349
6350 // set the printable on the PrinterJob
6351 job.setPrintable(printable);
6352
6353 // if specified, set the PrintService on the PrinterJob
6354 if (service != null) {
6355 job.setPrintService(service);
6356 }
6357
6358 // if requested, show the print dialog
6359 if (showPrintDialog && !job.printDialog(attr)) {
6360 // the user cancelled the print dialog
6361 return false;
6362 }
6363
6364 // if not interactive, just print on this thread (no dialog)
6365 if (!interactive) {
6366 // do the printing
6367 job.print(attr);
6368
6369 // we're done
6370 return true;
6371 }
6372
6373 // make sure this is clear since we'll check it after
6374 printError = null;
6375
6376 // to synchronize on
6377 final Object lock = new Object();
6378
6379 // copied so we can access from the inner class
6380 final PrintRequestAttributeSet copyAttr = attr;
6381
6382 // this runnable will be used to do the printing
6383 // (and save any throwables) on another thread
6384 Runnable runnable = () -> {
6385 try {
6386 // do the printing
6387 job.print(copyAttr);
6388 } catch (Throwable t) {
6389 // save any Throwable to be rethrown
6390 synchronized(lock) {
6391 printError = t;
6392 }
6393 } finally {
6394 // we're finished - hide the dialog
6395 printingStatus.dispose();
6396 }
6397 };
6398
6399 // start printing on another thread
6400 Thread th = new Thread(null, runnable, "JTablePrint", 0, false);
6401 th.start();
6402
6403 printingStatus.showModal(true);
6404
6405 // look for any error that the printing may have generated
6406 Throwable pe;
6407 synchronized(lock) {
6408 pe = printError;
6409 printError = null;
6410 }
6411
6412 // check the type of error and handle it
6413 if (pe != null) {
6414 // a subclass of PrinterException meaning the job was aborted,
6415 // in this case, by the user
6416 if (pe instanceof PrinterAbortException) {
6417 return false;
6418 } else if (pe instanceof PrinterException) {
6419 throw (PrinterException)pe;
6420 } else if (pe instanceof RuntimeException) {
6421 throw (RuntimeException)pe;
6422 } else if (pe instanceof Error) {
6423 throw (Error)pe;
6424 }
6425
6426 // can not happen
6427 throw new AssertionError(pe);
6428 }
6429
6430 return true;
6431 }
6432
6433 /**
6434 * Return a <code>Printable</code> for use in printing this JTable.
6435 * <p>
6436 * This method is meant for those wishing to customize the default
6437 * <code>Printable</code> implementation used by <code>JTable</code>'s
6438 * <code>print</code> methods. Developers wanting simply to print the table
6439 * should use one of those methods directly.
6440 * <p>
6441 * The <code>Printable</code> can be requested in one of two printing modes.
6442 * In both modes, it spreads table rows naturally in sequence across
6443 * multiple pages, fitting as many rows as possible per page.
6444 * <code>PrintMode.NORMAL</code> specifies that the table be
6445 * printed at its current size. In this mode, there may be a need to spread
6446 * columns across pages in a similar manner to that of the rows. When the
6447 * need arises, columns are distributed in an order consistent with the
6448 * table's <code>ComponentOrientation</code>.
6449 * <code>PrintMode.FIT_WIDTH</code> specifies that the output be
6450 * scaled smaller, if necessary, to fit the table's entire width
6451 * (and thereby all columns) on each page. Width and height are scaled
6452 * equally, maintaining the aspect ratio of the output.
6453 * <p>
6454 * The <code>Printable</code> heads the portion of table on each page
6455 * with the appropriate section from the table's <code>JTableHeader</code>,
6456 * if it has one.
6457 * <p>
6458 * Header and footer text can be added to the output by providing
6459 * <code>MessageFormat</code> arguments. The printing code requests
6460 * Strings from the formats, providing a single item which may be included
6461 * in the formatted string: an <code>Integer</code> representing the current
6462 * page number.
6463 * <p>
6464 * You are encouraged to read the documentation for
6465 * <code>MessageFormat</code> as some characters, such as single-quote,
6466 * are special and need to be escaped.
6467 * <p>
6468 * Here's an example of creating a <code>MessageFormat</code> that can be
6469 * used to print "Duke's Table: Page - " and the current page number:
6470 *
6471 * <pre>
6472 * // notice the escaping of the single quote
6473 * // notice how the page number is included with "{0}"
6474 * MessageFormat format = new MessageFormat("Duke''s Table: Page - {0}");
6475 * </pre>
6476 * <p>
6477 * The <code>Printable</code> constrains what it draws to the printable
6478 * area of each page that it prints. Under certain circumstances, it may
6479 * find it impossible to fit all of a page's content into that area. In
6480 * these cases the output may be clipped, but the implementation
6481 * makes an effort to do something reasonable. Here are a few situations
6482 * where this is known to occur, and how they may be handled by this
6483 * particular implementation:
6484 * <ul>
6485 * <li>In any mode, when the header or footer text is too wide to fit
6486 * completely in the printable area -- print as much of the text as
6487 * possible starting from the beginning, as determined by the table's
6488 * <code>ComponentOrientation</code>.
6489 * <li>In any mode, when a row is too tall to fit in the
6490 * printable area -- print the upper-most portion of the row
6491 * and paint no lower border on the table.
6492 * <li>In <code>PrintMode.NORMAL</code> when a column
6493 * is too wide to fit in the printable area -- print the center
6494 * portion of the column and leave the left and right borders
6495 * off the table.
6496 * </ul>
6497 * <p>
6498 * It is entirely valid for this <code>Printable</code> to be wrapped
6499 * inside another in order to create complex reports and documents. You may
6500 * even request that different pages be rendered into different sized
6501 * printable areas. The implementation must be prepared to handle this
6502 * (possibly by doing its layout calculations on the fly). However,
6503 * providing different heights to each page will likely not work well
6504 * with <code>PrintMode.NORMAL</code> when it has to spread columns
6505 * across pages.
6506 * <p>
6507 * As far as customizing how the table looks in the printed result,
6508 * <code>JTable</code> itself will take care of hiding the selection
6509 * and focus during printing. For additional customizations, your
6510 * renderers or painting code can customize the look based on the value
6511 * of {@link javax.swing.JComponent#isPaintingForPrint()}
6512 * <p>
6513 * Also, <i>before</i> calling this method you may wish to <i>first</i>
6514 * modify the state of the table, such as to cancel cell editing or
6515 * have the user size the table appropriately. However, you must not
6516 * modify the state of the table <i>after</i> this <code>Printable</code>
6517 * has been fetched (invalid modifications include changes in size or
6518 * underlying data). The behavior of the returned <code>Printable</code>
6519 * is undefined once the table has been changed.
6520 *
6521 * @param printMode the printing mode that the printable should use
6522 * @param headerFormat a <code>MessageFormat</code> specifying the text to
6523 * be used in printing a header, or null for none
6524 * @param footerFormat a <code>MessageFormat</code> specifying the text to
6525 * be used in printing a footer, or null for none
6526 * @return a <code>Printable</code> for printing this JTable
6527 * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
6528 * boolean, PrintRequestAttributeSet, boolean)
6529 * @see Printable
6530 * @see PrinterJob
6531 *
6532 * @since 1.5
6533 */
6534 public Printable getPrintable(PrintMode printMode,
6535 MessageFormat headerFormat,
6536 MessageFormat footerFormat) {
6537
6538 return new TablePrintable(this, printMode, headerFormat, footerFormat);
6539 }
6540
6541
6542 /**
6543 * A <code>Printable</code> implementation that wraps another
6544 * <code>Printable</code>, making it safe for printing on another thread.
6545 */
6546 private class ThreadSafePrintable implements Printable {
6547
6548 /** The delegate <code>Printable</code>. */
6549 private Printable printDelegate;
6550
6551 /**
6552 * To communicate any return value when delegating.
6553 */
6554 private int retVal;
6555
6556 /**
6557 * To communicate any <code>Throwable</code> when delegating.
6558 */
6559 private Throwable retThrowable;
6560
6561 /**
6562 * Construct a <code>ThreadSafePrintable</code> around the given
6563 * delegate.
6564 *
6565 * @param printDelegate the <code>Printable</code> to delegate to
6566 */
6567 public ThreadSafePrintable(Printable printDelegate) {
6568 this.printDelegate = printDelegate;
6569 }
6570
6571 /**
6572 * Prints the specified page into the given {@link Graphics}
6573 * context, in the specified format.
6574 * <p>
6575 * Regardless of what thread this method is called on, all calls into
6576 * the delegate will be done on the event-dispatch thread.
6577 *
6578 * @param graphics the context into which the page is drawn
6579 * @param pageFormat the size and orientation of the page being drawn
6580 * @param pageIndex the zero based index of the page to be drawn
6581 * @return PAGE_EXISTS if the page is rendered successfully, or
6582 * NO_SUCH_PAGE if a non-existent page index is specified
6583 * @throws PrinterException if an error causes printing to be aborted
6584 */
6585 public int print(final Graphics graphics,
6586 final PageFormat pageFormat,
6587 final int pageIndex) throws PrinterException {
6588
6589 // We'll use this Runnable
6590 Runnable runnable = new Runnable() {
6591 public synchronized void run() {
6592 try {
6593 // call into the delegate and save the return value
6594 retVal = printDelegate.print(graphics, pageFormat, pageIndex);
6595 } catch (Throwable throwable) {
6596 // save any Throwable to be rethrown
6597 retThrowable = throwable;
6598 } finally {
6599 // notify the caller that we're done
6600 notifyAll();
6601 }
6602 }
6603 };
6604
6605 synchronized(runnable) {
6606 // make sure these are initialized
6607 retVal = -1;
6608 retThrowable = null;
6609
6610 // call into the EDT
6611 SwingUtilities.invokeLater(runnable);
6612
6613 // wait for the runnable to finish
6614 while (retVal == -1 && retThrowable == null) {
6615 try {
6616 runnable.wait();
6617 } catch (InterruptedException ie) {
6618 // short process, safe to ignore interrupts
6619 }
6620 }
6621
6622 // if the delegate threw a throwable, rethrow it here
6623 if (retThrowable != null) {
6624 if (retThrowable instanceof PrinterException) {
6625 throw (PrinterException)retThrowable;
6626 } else if (retThrowable instanceof RuntimeException) {
6627 throw (RuntimeException)retThrowable;
6628 } else if (retThrowable instanceof Error) {
6629 throw (Error)retThrowable;
6630 }
6631
6632 // can not happen
6633 throw new AssertionError(retThrowable);
6634 }
6635
6636 return retVal;
6637 }
6638 }
6639 }
6640
6641 /////////////////
6642 // Accessibility support
6643 ////////////////
6644
6645 /**
6646 * Gets the AccessibleContext associated with this JTable.
6647 * For tables, the AccessibleContext takes the form of an
6648 * AccessibleJTable.
6649 * A new AccessibleJTable instance is created if necessary.
6650 *
6651 * @return an AccessibleJTable that serves as the
6652 * AccessibleContext of this JTable
6653 */
6654 @BeanProperty(bound = false)
6655 public AccessibleContext getAccessibleContext() {
6656 if (accessibleContext == null) {
6657 accessibleContext = new AccessibleJTable();
6658 }
6659 return accessibleContext;
6660 }
6661
6662 //
6663 // *** should also implement AccessibleSelection?
6664 // *** and what's up with keyboard navigation/manipulation?
6665 //
6666 /**
6667 * This class implements accessibility support for the
6668 * <code>JTable</code> class. It provides an implementation of the
6669 * Java Accessibility API appropriate to table user-interface elements.
6670 * <p>
6671 * <strong>Warning:</strong>
6672 * Serialized objects of this class will not be compatible with
6673 * future Swing releases. The current serialization support is
6674 * appropriate for short term storage or RMI between applications running
6675 * the same version of Swing. As of 1.4, support for long term storage
6676 * of all JavaBeans™
6677 * has been added to the <code>java.beans</code> package.
6678 * Please see {@link java.beans.XMLEncoder}.
6679 */
6680 @SuppressWarnings("serial") // Same-version serialization only
6681 protected class AccessibleJTable extends AccessibleJComponent
6682 implements AccessibleSelection, ListSelectionListener, TableModelListener,
6683 TableColumnModelListener, CellEditorListener, PropertyChangeListener,
6684 AccessibleExtendedTable {
6685
6686 int previousFocusedRow;
6687 int previousFocusedCol;
6688
6689 /**
6690 * AccessibleJTable constructor
6691 *
6692 * @since 1.5
6693 */
6694 protected AccessibleJTable() {
6695 super();
6696 JTable.this.addPropertyChangeListener(this);
6697 JTable.this.getSelectionModel().addListSelectionListener(this);
6698 TableColumnModel tcm = JTable.this.getColumnModel();
6699 tcm.addColumnModelListener(this);
6700 tcm.getSelectionModel().addListSelectionListener(this);
6701 JTable.this.getModel().addTableModelListener(this);
6702 previousFocusedRow = JTable.this.getSelectionModel().
6703 getLeadSelectionIndex();
6704 previousFocusedCol = JTable.this.getColumnModel().
6705 getSelectionModel().getLeadSelectionIndex();
6706 }
6707
6708 // Listeners to track model, etc. changes to as to re-place the other
6709 // listeners
6710
6711 /**
6712 * Track changes to selection model, column model, etc. so as to
6713 * be able to re-place listeners on those in order to pass on
6714 * information to the Accessibility PropertyChange mechanism
6715 */
6716 public void propertyChange(PropertyChangeEvent e) {
6717 String name = e.getPropertyName();
6718 Object oldValue = e.getOldValue();
6719 Object newValue = e.getNewValue();
6720
6721 // re-set tableModel listeners
6722 if (name.compareTo("model") == 0) {
6723
6724 if (oldValue != null && oldValue instanceof TableModel) {
6725 ((TableModel) oldValue).removeTableModelListener(this);
6726 }
6727 if (newValue != null && newValue instanceof TableModel) {
6728 ((TableModel) newValue).addTableModelListener(this);
6729 }
6730
6731 // re-set selectionModel listeners
6732 } else if (name.compareTo("selectionModel") == 0) {
6733
6734 Object source = e.getSource();
6735 if (source == JTable.this) { // row selection model
6736
6737 if (oldValue != null &&
6738 oldValue instanceof ListSelectionModel) {
6739 ((ListSelectionModel) oldValue).removeListSelectionListener(this);
6740 }
6741 if (newValue != null &&
6742 newValue instanceof ListSelectionModel) {
6743 ((ListSelectionModel) newValue).addListSelectionListener(this);
6744 }
6745
6746 } else if (source == JTable.this.getColumnModel()) {
6747
6748 if (oldValue != null &&
6749 oldValue instanceof ListSelectionModel) {
6750 ((ListSelectionModel) oldValue).removeListSelectionListener(this);
6751 }
6752 if (newValue != null &&
6753 newValue instanceof ListSelectionModel) {
6754 ((ListSelectionModel) newValue).addListSelectionListener(this);
6755 }
6756
6757 } else {
6758 // System.out.println("!!! Bug in source of selectionModel propertyChangeEvent");
6759 }
6760
6761 // re-set columnModel listeners
6762 // and column's selection property listener as well
6763 } else if (name.compareTo("columnModel") == 0) {
6764
6765 if (oldValue != null && oldValue instanceof TableColumnModel) {
6766 TableColumnModel tcm = (TableColumnModel) oldValue;
6767 tcm.removeColumnModelListener(this);
6768 tcm.getSelectionModel().removeListSelectionListener(this);
6769 }
6770 if (newValue != null && newValue instanceof TableColumnModel) {
6771 TableColumnModel tcm = (TableColumnModel) newValue;
6772 tcm.addColumnModelListener(this);
6773 tcm.getSelectionModel().addListSelectionListener(this);
6774 }
6775
6776 // re-se cellEditor listeners
6777 } else if (name.compareTo("tableCellEditor") == 0) {
6778
6779 if (oldValue != null && oldValue instanceof TableCellEditor) {
6780 ((TableCellEditor) oldValue).removeCellEditorListener(this);
6781 }
6782 if (newValue != null && newValue instanceof TableCellEditor) {
6783 ((TableCellEditor) newValue).addCellEditorListener(this);
6784 }
6785 }
6786 }
6787
6788
6789 // Listeners to echo changes to the AccessiblePropertyChange mechanism
6790
6791 /**
6792 * Describes a change in the accessible table model.
6793 */
6794 protected class AccessibleJTableModelChange
6795 implements AccessibleTableModelChange {
6796
6797 /** The type */
6798 protected int type;
6799 /** The first row */
6800 protected int firstRow;
6801 /** The last row */
6802 protected int lastRow;
6803 /** The first column */
6804 protected int firstColumn;
6805 /** The last column */
6806 protected int lastColumn;
6807
6808 /**
6809 * Constructs an {@code AccessibleJTableModelChange}.
6810 * @param type the type
6811 * @param firstRow the first row
6812 * @param lastRow the last row
6813 * @param firstColumn the first column
6814 * @param lastColumn the last column
6815 */
6816 protected AccessibleJTableModelChange(int type, int firstRow,
6817 int lastRow, int firstColumn,
6818 int lastColumn) {
6819 this.type = type;
6820 this.firstRow = firstRow;
6821 this.lastRow = lastRow;
6822 this.firstColumn = firstColumn;
6823 this.lastColumn = lastColumn;
6824 }
6825
6826 /**
6827 * Returns the type.
6828 * @return the type
6829 */
6830 public int getType() {
6831 return type;
6832 }
6833
6834 /**
6835 * Returns the first row.
6836 * @return the first row
6837 */
6838 public int getFirstRow() {
6839 return firstRow;
6840 }
6841
6842 /**
6843 * Returns the last row.
6844 * @return the last row
6845 */
6846 public int getLastRow() {
6847 return lastRow;
6848 }
6849
6850 /**
6851 * Returns the first column.
6852 * @return the first column
6853 */
6854 public int getFirstColumn() {
6855 return firstColumn;
6856 }
6857
6858 /**
6859 * Returns the last column.
6860 * @return the last column
6861 */
6862 public int getLastColumn() {
6863 return lastColumn;
6864 }
6865 }
6866
6867 /**
6868 * Track changes to the table contents
6869 *
6870 * @param e a {@code TableModelEvent} describing the event
6871 */
6872 public void tableChanged(TableModelEvent e) {
6873 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
6874 null, null);
6875 if (e != null) {
6876 int firstColumn = e.getColumn();
6877 int lastColumn = e.getColumn();
6878 if (firstColumn == TableModelEvent.ALL_COLUMNS) {
6879 firstColumn = 0;
6880 lastColumn = getColumnCount() - 1;
6881 }
6882
6883 // Fire a property change event indicating the table model
6884 // has changed.
6885 AccessibleJTableModelChange change =
6886 new AccessibleJTableModelChange(e.getType(),
6887 e.getFirstRow(),
6888 e.getLastRow(),
6889 firstColumn,
6890 lastColumn);
6891 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
6892 null, change);
6893 }
6894 }
6895
6896 /**
6897 * Track changes to the table contents (row insertions)
6898 *
6899 * @param e a {@code TableModelEvent} describing the event
6900 */
6901 public void tableRowsInserted(TableModelEvent e) {
6902 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
6903 null, null);
6904
6905 // Fire a property change event indicating the table model
6906 // has changed.
6907 int firstColumn = e.getColumn();
6908 int lastColumn = e.getColumn();
6909 if (firstColumn == TableModelEvent.ALL_COLUMNS) {
6910 firstColumn = 0;
6911 lastColumn = getColumnCount() - 1;
6912 }
6913 AccessibleJTableModelChange change =
6914 new AccessibleJTableModelChange(e.getType(),
6915 e.getFirstRow(),
6916 e.getLastRow(),
6917 firstColumn,
6918 lastColumn);
6919 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
6920 null, change);
6921 }
6922
6923 /**
6924 * Track changes to the table contents (row deletions)
6925 *
6926 * @param e a {@code TableModelEvent} describing the event
6927 */
6928 public void tableRowsDeleted(TableModelEvent e) {
6929 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
6930 null, null);
6931
6932 // Fire a property change event indicating the table model
6933 // has changed.
6934 int firstColumn = e.getColumn();
6935 int lastColumn = e.getColumn();
6936 if (firstColumn == TableModelEvent.ALL_COLUMNS) {
6937 firstColumn = 0;
6938 lastColumn = getColumnCount() - 1;
6939 }
6940 AccessibleJTableModelChange change =
6941 new AccessibleJTableModelChange(e.getType(),
6942 e.getFirstRow(),
6943 e.getLastRow(),
6944 firstColumn,
6945 lastColumn);
6946 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
6947 null, change);
6948 }
6949
6950 /**
6951 * Track changes to the table contents (column insertions)
6952 */
6953 public void columnAdded(TableColumnModelEvent e) {
6954 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
6955 null, null);
6956
6957 // Fire a property change event indicating the table model
6958 // has changed.
6959 int type = AccessibleTableModelChange.INSERT;
6960 AccessibleJTableModelChange change =
6961 new AccessibleJTableModelChange(type,
6962 0,
6963 0,
6964 e.getFromIndex(),
6965 e.getToIndex());
6966 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
6967 null, change);
6968 }
6969
6970 /**
6971 * Track changes to the table contents (column deletions)
6972 */
6973 public void columnRemoved(TableColumnModelEvent e) {
6974 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
6975 null, null);
6976 // Fire a property change event indicating the table model
6977 // has changed.
6978 int type = AccessibleTableModelChange.DELETE;
6979 AccessibleJTableModelChange change =
6980 new AccessibleJTableModelChange(type,
6981 0,
6982 0,
6983 e.getFromIndex(),
6984 e.getToIndex());
6985 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
6986 null, change);
6987 }
6988
6989 /**
6990 * Track changes of a column repositioning.
6991 *
6992 * @see TableColumnModelListener
6993 */
6994 public void columnMoved(TableColumnModelEvent e) {
6995 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
6996 null, null);
6997
6998 // Fire property change events indicating the table model
6999 // has changed.
7000 int type = AccessibleTableModelChange.DELETE;
7001 AccessibleJTableModelChange change =
7002 new AccessibleJTableModelChange(type,
7003 0,
7004 0,
7005 e.getFromIndex(),
7006 e.getFromIndex());
7007 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
7008 null, change);
7009
7010 int type2 = AccessibleTableModelChange.INSERT;
7011 AccessibleJTableModelChange change2 =
7012 new AccessibleJTableModelChange(type2,
7013 0,
7014 0,
7015 e.getToIndex(),
7016 e.getToIndex());
7017 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
7018 null, change2);
7019 }
7020
7021 /**
7022 * Track changes of a column moving due to margin changes.
7023 *
7024 * @see TableColumnModelListener
7025 */
7026 public void columnMarginChanged(ChangeEvent e) {
7027 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
7028 null, null);
7029 }
7030
7031 /**
7032 * Track that the selection model of the TableColumnModel changed.
7033 *
7034 * @see TableColumnModelListener
7035 */
7036 public void columnSelectionChanged(ListSelectionEvent e) {
7037 // we should now re-place our TableColumn listener
7038 }
7039
7040 /**
7041 * Track changes to a cell's contents.
7042 *
7043 * Invoked when editing is finished. The changes are saved, the
7044 * editor object is discarded, and the cell is rendered once again.
7045 *
7046 * @see CellEditorListener
7047 */
7048 public void editingStopped(ChangeEvent e) {
7049 // it'd be great if we could figure out which cell, and pass that
7050 // somehow as a parameter
7051 firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
7052 null, null);
7053 }
7054
7055 /**
7056 * Invoked when editing is canceled. The editor object is discarded
7057 * and the cell is rendered once again.
7058 *
7059 * @see CellEditorListener
7060 */
7061 public void editingCanceled(ChangeEvent e) {
7062 // nothing to report, 'cause nothing changed
7063 }
7064
7065 /**
7066 * Track changes to table cell selections
7067 */
7068 public void valueChanged(ListSelectionEvent e) {
7069 firePropertyChange(AccessibleContext.ACCESSIBLE_SELECTION_PROPERTY,
7070 Boolean.valueOf(false), Boolean.valueOf(true));
7071
7072 // Using lead selection index to cover both cases: node selected and node
7073 // is focused but not selected (Ctrl+up/down)
7074 int focusedRow = JTable.this.getSelectionModel().getLeadSelectionIndex();
7075 int focusedCol = JTable.this.getColumnModel().getSelectionModel().
7076 getLeadSelectionIndex();
7077
7078 if (focusedRow != previousFocusedRow ||
7079 focusedCol != previousFocusedCol) {
7080 Accessible oldA = getAccessibleAt(previousFocusedRow, previousFocusedCol);
7081 Accessible newA = getAccessibleAt(focusedRow, focusedCol);
7082 firePropertyChange(AccessibleContext.ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY,
7083 oldA, newA);
7084 previousFocusedRow = focusedRow;
7085 previousFocusedCol = focusedCol;
7086 }
7087 }
7088
7089
7090
7091
7092 // AccessibleContext support
7093
7094 /**
7095 * Get the AccessibleSelection associated with this object. In the
7096 * implementation of the Java Accessibility API for this class,
7097 * return this object, which is responsible for implementing the
7098 * AccessibleSelection interface on behalf of itself.
7099 *
7100 * @return this object
7101 */
7102 public AccessibleSelection getAccessibleSelection() {
7103 return this;
7104 }
7105
7106 /**
7107 * Gets the role of this object.
7108 *
7109 * @return an instance of AccessibleRole describing the role of the
7110 * object
7111 * @see AccessibleRole
7112 */
7113 public AccessibleRole getAccessibleRole() {
7114 return AccessibleRole.TABLE;
7115 }
7116
7117 /**
7118 * Returns the <code>Accessible</code> child, if one exists,
7119 * contained at the local coordinate <code>Point</code>.
7120 *
7121 * @param p the point defining the top-left corner of the
7122 * <code>Accessible</code>, given in the coordinate space
7123 * of the object's parent
7124 * @return the <code>Accessible</code>, if it exists,
7125 * at the specified location; else <code>null</code>
7126 */
7127 public Accessible getAccessibleAt(Point p) {
7128 int column = columnAtPoint(p);
7129 int row = rowAtPoint(p);
7130
7131 if ((column != -1) && (row != -1)) {
7132 TableColumn aColumn = getColumnModel().getColumn(column);
7133 TableCellRenderer renderer = aColumn.getCellRenderer();
7134 if (renderer == null) {
7135 Class<?> columnClass = getColumnClass(column);
7136 renderer = getDefaultRenderer(columnClass);
7137 }
7138 Component component = renderer.getTableCellRendererComponent(
7139 JTable.this, null, false, false,
7140 row, column);
7141 return new AccessibleJTableCell(JTable.this, row, column,
7142 getAccessibleIndexAt(row, column));
7143 }
7144 return null;
7145 }
7146
7147 /**
7148 * Returns the number of accessible children in the object. If all
7149 * of the children of this object implement <code>Accessible</code>,
7150 * then this method should return the number of children of this object.
7151 *
7152 * @return the number of accessible children in the object
7153 */
7154 public int getAccessibleChildrenCount() {
7155 return (JTable.this.getColumnCount() * JTable.this.getRowCount());
7156 }
7157
7158 /**
7159 * Returns the nth <code>Accessible</code> child of the object.
7160 *
7161 * @param i zero-based index of child
7162 * @return the nth Accessible child of the object
7163 */
7164 public Accessible getAccessibleChild(int i) {
7165 if (i < 0 || i >= getAccessibleChildrenCount()) {
7166 return null;
7167 } else {
7168 // children increase across, and then down, for tables
7169 // (arbitrary decision)
7170 int column = getAccessibleColumnAtIndex(i);
7171 int row = getAccessibleRowAtIndex(i);
7172
7173 TableColumn aColumn = getColumnModel().getColumn(column);
7174 TableCellRenderer renderer = aColumn.getCellRenderer();
7175 if (renderer == null) {
7176 Class<?> columnClass = getColumnClass(column);
7177 renderer = getDefaultRenderer(columnClass);
7178 }
7179 Component component = renderer.getTableCellRendererComponent(
7180 JTable.this, null, false, false,
7181 row, column);
7182 return new AccessibleJTableCell(JTable.this, row, column,
7183 getAccessibleIndexAt(row, column));
7184 }
7185 }
7186
7187 // AccessibleSelection support
7188
7189 /**
7190 * Returns the number of <code>Accessible</code> children
7191 * currently selected.
7192 * If no children are selected, the return value will be 0.
7193 *
7194 * @return the number of items currently selected
7195 */
7196 public int getAccessibleSelectionCount() {
7197 int rowsSel = JTable.this.getSelectedRowCount();
7198 int colsSel = JTable.this.getSelectedColumnCount();
7199
7200 if (JTable.this.cellSelectionEnabled) { // a contiguous block
7201 return rowsSel * colsSel;
7202
7203 } else {
7204 // a column swath and a row swath, with a shared block
7205 if (JTable.this.getRowSelectionAllowed() &&
7206 JTable.this.getColumnSelectionAllowed()) {
7207 return rowsSel * JTable.this.getColumnCount() +
7208 colsSel * JTable.this.getRowCount() -
7209 rowsSel * colsSel;
7210
7211 // just one or more rows in selection
7212 } else if (JTable.this.getRowSelectionAllowed()) {
7213 return rowsSel * JTable.this.getColumnCount();
7214
7215 // just one or more rows in selection
7216 } else if (JTable.this.getColumnSelectionAllowed()) {
7217 return colsSel * JTable.this.getRowCount();
7218
7219 } else {
7220 return 0; // JTable doesn't allow selections
7221 }
7222 }
7223 }
7224
7225 /**
7226 * Returns an <code>Accessible</code> representing the
7227 * specified selected child in the object. If there
7228 * isn't a selection, or there are fewer children selected
7229 * than the integer passed in, the return
7230 * value will be <code>null</code>.
7231 * <p>Note that the index represents the i-th selected child, which
7232 * is different from the i-th child.
7233 *
7234 * @param i the zero-based index of selected children
7235 * @return the i-th selected child
7236 * @see #getAccessibleSelectionCount
7237 */
7238 public Accessible getAccessibleSelection(int i) {
7239 if (i < 0 || i > getAccessibleSelectionCount()) {
7240 return null;
7241 }
7242
7243 int rowsSel = JTable.this.getSelectedRowCount();
7244 int colsSel = JTable.this.getSelectedColumnCount();
7245 int rowIndicies[] = getSelectedRows();
7246 int colIndicies[] = getSelectedColumns();
7247 int ttlCols = JTable.this.getColumnCount();
7248 int ttlRows = JTable.this.getRowCount();
7249 int r;
7250 int c;
7251
7252 if (JTable.this.cellSelectionEnabled) { // a contiguous block
7253 r = rowIndicies[i / colsSel];
7254 c = colIndicies[i % colsSel];
7255 return getAccessibleChild((r * ttlCols) + c);
7256 } else {
7257
7258 // a column swath and a row swath, with a shared block
7259 if (JTable.this.getRowSelectionAllowed() &&
7260 JTable.this.getColumnSelectionAllowed()) {
7261
7262 // Situation:
7263 // We have a table, like the 6x3 table below,
7264 // wherein three colums and one row selected
7265 // (selected cells marked with "*", unselected "0"):
7266 //
7267 // 0 * 0 * * 0
7268 // * * * * * *
7269 // 0 * 0 * * 0
7270 //
7271
7272 // State machine below walks through the array of
7273 // selected rows in two states: in a selected row,
7274 // and not in one; continuing until we are in a row
7275 // in which the ith selection exists. Then we return
7276 // the appropriate cell. In the state machine, we
7277 // always do rows above the "current" selected row first,
7278 // then the cells in the selected row. If we're done
7279 // with the state machine before finding the requested
7280 // selected child, we handle the rows below the last
7281 // selected row at the end.
7282 //
7283 int curIndex = i;
7284 final int IN_ROW = 0;
7285 final int NOT_IN_ROW = 1;
7286 int state = (rowIndicies[0] == 0 ? IN_ROW : NOT_IN_ROW);
7287 int j = 0;
7288 int prevRow = -1;
7289 while (j < rowIndicies.length) {
7290 switch (state) {
7291
7292 case IN_ROW: // on individual row full of selections
7293 if (curIndex < ttlCols) { // it's here!
7294 c = curIndex % ttlCols;
7295 r = rowIndicies[j];
7296 return getAccessibleChild((r * ttlCols) + c);
7297 } else { // not here
7298 curIndex -= ttlCols;
7299 }
7300 // is the next row in table selected or not?
7301 if (j + 1 == rowIndicies.length ||
7302 rowIndicies[j] != rowIndicies[j+1] - 1) {
7303 state = NOT_IN_ROW;
7304 prevRow = rowIndicies[j];
7305 }
7306 j++; // we didn't return earlier, so go to next row
7307 break;
7308
7309 case NOT_IN_ROW: // sparse bunch of rows of selections
7310 if (curIndex <
7311 (colsSel * (rowIndicies[j] -
7312 (prevRow == -1 ? 0 : (prevRow + 1))))) {
7313
7314 // it's here!
7315 c = colIndicies[curIndex % colsSel];
7316 r = (j > 0 ? rowIndicies[j-1] + 1 : 0)
7317 + curIndex / colsSel;
7318 return getAccessibleChild((r * ttlCols) + c);
7319 } else { // not here
7320 curIndex -= colsSel * (rowIndicies[j] -
7321 (prevRow == -1 ? 0 : (prevRow + 1)));
7322 }
7323 state = IN_ROW;
7324 break;
7325 }
7326 }
7327 // we got here, so we didn't find it yet; find it in
7328 // the last sparse bunch of rows
7329 if (curIndex <
7330 (colsSel * (ttlRows -
7331 (prevRow == -1 ? 0 : (prevRow + 1))))) { // it's here!
7332 c = colIndicies[curIndex % colsSel];
7333 r = rowIndicies[j-1] + curIndex / colsSel + 1;
7334 return getAccessibleChild((r * ttlCols) + c);
7335 } else { // not here
7336 // we shouldn't get to this spot in the code!
7337 // System.out.println("Bug in AccessibleJTable.getAccessibleSelection()");
7338 }
7339
7340 // one or more rows selected
7341 } else if (JTable.this.getRowSelectionAllowed()) {
7342 c = i % ttlCols;
7343 r = rowIndicies[i / ttlCols];
7344 return getAccessibleChild((r * ttlCols) + c);
7345
7346 // one or more columns selected
7347 } else if (JTable.this.getColumnSelectionAllowed()) {
7348 c = colIndicies[i % colsSel];
7349 r = i / colsSel;
7350 return getAccessibleChild((r * ttlCols) + c);
7351 }
7352 }
7353 return null;
7354 }
7355
7356 /**
7357 * Determines if the current child of this object is selected.
7358 *
7359 * @param i the zero-based index of the child in this
7360 * <code>Accessible</code> object
7361 * @return true if the current child of this object is selected
7362 * @see AccessibleContext#getAccessibleChild
7363 */
7364 public boolean isAccessibleChildSelected(int i) {
7365 int column = getAccessibleColumnAtIndex(i);
7366 int row = getAccessibleRowAtIndex(i);
7367 return JTable.this.isCellSelected(row, column);
7368 }
7369
7370 /**
7371 * Adds the specified <code>Accessible</code> child of the
7372 * object to the object's selection. If the object supports
7373 * multiple selections, the specified child is added to
7374 * any existing selection, otherwise
7375 * it replaces any existing selection in the object. If the
7376 * specified child is already selected, this method has no effect.
7377 * <p>
7378 * This method only works on <code>JTable</code>s which have
7379 * individual cell selection enabled.
7380 *
7381 * @param i the zero-based index of the child
7382 * @see AccessibleContext#getAccessibleChild
7383 */
7384 public void addAccessibleSelection(int i) {
7385 // TIGER - 4495286
7386 int column = getAccessibleColumnAtIndex(i);
7387 int row = getAccessibleRowAtIndex(i);
7388 JTable.this.changeSelection(row, column, true, false);
7389 }
7390
7391 /**
7392 * Removes the specified child of the object from the object's
7393 * selection. If the specified item isn't currently selected, this
7394 * method has no effect.
7395 * <p>
7396 * This method only works on <code>JTables</code> which have
7397 * individual cell selection enabled.
7398 *
7399 * @param i the zero-based index of the child
7400 * @see AccessibleContext#getAccessibleChild
7401 */
7402 public void removeAccessibleSelection(int i) {
7403 if (JTable.this.cellSelectionEnabled) {
7404 int column = getAccessibleColumnAtIndex(i);
7405 int row = getAccessibleRowAtIndex(i);
7406 JTable.this.removeRowSelectionInterval(row, row);
7407 JTable.this.removeColumnSelectionInterval(column, column);
7408 }
7409 }
7410
7411 /**
7412 * Clears the selection in the object, so that no children in the
7413 * object are selected.
7414 */
7415 public void clearAccessibleSelection() {
7416 JTable.this.clearSelection();
7417 }
7418
7419 /**
7420 * Causes every child of the object to be selected, but only
7421 * if the <code>JTable</code> supports multiple selections,
7422 * and if individual cell selection is enabled.
7423 */
7424 public void selectAllAccessibleSelection() {
7425 if (JTable.this.cellSelectionEnabled) {
7426 JTable.this.selectAll();
7427 }
7428 }
7429
7430 // begin AccessibleExtendedTable implementation -------------
7431
7432 /**
7433 * Returns the row number of an index in the table.
7434 *
7435 * @param index the zero-based index in the table
7436 * @return the zero-based row of the table if one exists;
7437 * otherwise -1.
7438 * @since 1.4
7439 */
7440 public int getAccessibleRow(int index) {
7441 return getAccessibleRowAtIndex(index);
7442 }
7443
7444 /**
7445 * Returns the column number of an index in the table.
7446 *
7447 * @param index the zero-based index in the table
7448 * @return the zero-based column of the table if one exists;
7449 * otherwise -1.
7450 * @since 1.4
7451 */
7452 public int getAccessibleColumn(int index) {
7453 return getAccessibleColumnAtIndex(index);
7454 }
7455
7456 /**
7457 * Returns the index at a row and column in the table.
7458 *
7459 * @param r zero-based row of the table
7460 * @param c zero-based column of the table
7461 * @return the zero-based index in the table if one exists;
7462 * otherwise -1.
7463 * @since 1.4
7464 */
7465 public int getAccessibleIndex(int r, int c) {
7466 return getAccessibleIndexAt(r, c);
7467 }
7468
7469 // end of AccessibleExtendedTable implementation ------------
7470
7471 // start of AccessibleTable implementation ------------------
7472
7473 private Accessible caption;
7474 private Accessible summary;
7475 private Accessible [] rowDescription;
7476 private Accessible [] columnDescription;
7477
7478 /**
7479 * Gets the <code>AccessibleTable</code> associated with this
7480 * object. In the implementation of the Java Accessibility
7481 * API for this class, return this object, which is responsible
7482 * for implementing the <code>AccessibleTables</code> interface
7483 * on behalf of itself.
7484 *
7485 * @return this object
7486 * @since 1.3
7487 */
7488 public AccessibleTable getAccessibleTable() {
7489 return this;
7490 }
7491
7492 /**
7493 * Returns the caption for the table.
7494 *
7495 * @return the caption for the table
7496 * @since 1.3
7497 */
7498 public Accessible getAccessibleCaption() {
7499 return this.caption;
7500 }
7501
7502 /**
7503 * Sets the caption for the table.
7504 *
7505 * @param a the caption for the table
7506 * @since 1.3
7507 */
7508 public void setAccessibleCaption(Accessible a) {
7509 Accessible oldCaption = caption;
7510 this.caption = a;
7511 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_CAPTION_CHANGED,
7512 oldCaption, this.caption);
7513 }
7514
7515 /**
7516 * Returns the summary description of the table.
7517 *
7518 * @return the summary description of the table
7519 * @since 1.3
7520 */
7521 public Accessible getAccessibleSummary() {
7522 return this.summary;
7523 }
7524
7525 /**
7526 * Sets the summary description of the table.
7527 *
7528 * @param a the summary description of the table
7529 * @since 1.3
7530 */
7531 public void setAccessibleSummary(Accessible a) {
7532 Accessible oldSummary = summary;
7533 this.summary = a;
7534 firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_SUMMARY_CHANGED,
7535 oldSummary, this.summary);
7536 }
7537
7538 /*
7539 * Returns the total number of rows in this table.
7540 *
7541 * @return the total number of rows in this table
7542 */
7543 public int getAccessibleRowCount() {
7544 return JTable.this.getRowCount();
7545 }
7546
7547 /*
7548 * Returns the total number of columns in the table.
7549 *
7550 * @return the total number of columns in the table
7551 */
7552 public int getAccessibleColumnCount() {
7553 return JTable.this.getColumnCount();
7554 }
7555
7556 /*
7557 * Returns the <code>Accessible</code> at a specified row
7558 * and column in the table.
7559 *
7560 * @param r zero-based row of the table
7561 * @param c zero-based column of the table
7562 * @return the <code>Accessible</code> at the specified row and column
7563 * in the table
7564 */
7565 public Accessible getAccessibleAt(int r, int c) {
7566 return getAccessibleChild((r * getAccessibleColumnCount()) + c);
7567 }
7568
7569 /**
7570 * Returns the number of rows occupied by the <code>Accessible</code>
7571 * at a specified row and column in the table.
7572 *
7573 * @return the number of rows occupied by the <code>Accessible</code>
7574 * at a specified row and column in the table
7575 * @since 1.3
7576 */
7577 public int getAccessibleRowExtentAt(int r, int c) {
7578 return 1;
7579 }
7580
7581 /**
7582 * Returns the number of columns occupied by the
7583 * <code>Accessible</code> at a given (row, column).
7584 *
7585 * @return the number of columns occupied by the <code>Accessible</code>
7586 * at a specified row and column in the table
7587 * @since 1.3
7588 */
7589 public int getAccessibleColumnExtentAt(int r, int c) {
7590 return 1;
7591 }
7592
7593 /**
7594 * Returns the row headers as an <code>AccessibleTable</code>.
7595 *
7596 * @return an <code>AccessibleTable</code> representing the row
7597 * headers
7598 * @since 1.3
7599 */
7600 public AccessibleTable getAccessibleRowHeader() {
7601 // row headers are not supported
7602 return null;
7603 }
7604
7605 /**
7606 * Sets the row headers as an <code>AccessibleTable</code>.
7607 *
7608 * @param a an <code>AccessibleTable</code> representing the row
7609 * headers
7610 * @since 1.3
7611 */
7612 public void setAccessibleRowHeader(AccessibleTable a) {
7613 // row headers are not supported
7614 }
7615
7616 /**
7617 * Returns the column headers as an <code>AccessibleTable</code>.
7618 *
7619 * @return an <code>AccessibleTable</code> representing the column
7620 * headers, or <code>null</code> if the table header is
7621 * <code>null</code>
7622 * @since 1.3
7623 */
7624 public AccessibleTable getAccessibleColumnHeader() {
7625 JTableHeader header = JTable.this.getTableHeader();
7626 return header == null ? null : new AccessibleTableHeader(header);
7627 }
7628
7629 /*
7630 * Private class representing a table column header
7631 */
7632 private class AccessibleTableHeader implements AccessibleTable {
7633 private JTableHeader header;
7634 private TableColumnModel headerModel;
7635
7636 AccessibleTableHeader(JTableHeader header) {
7637 this.header = header;
7638 this.headerModel = header.getColumnModel();
7639 }
7640
7641 /**
7642 * Returns the caption for the table.
7643 *
7644 * @return the caption for the table
7645 */
7646 public Accessible getAccessibleCaption() { return null; }
7647
7648
7649 /**
7650 * Sets the caption for the table.
7651 *
7652 * @param a the caption for the table
7653 */
7654 public void setAccessibleCaption(Accessible a) {}
7655
7656 /**
7657 * Returns the summary description of the table.
7658 *
7659 * @return the summary description of the table
7660 */
7661 public Accessible getAccessibleSummary() { return null; }
7662
7663 /**
7664 * Sets the summary description of the table
7665 *
7666 * @param a the summary description of the table
7667 */
7668 public void setAccessibleSummary(Accessible a) {}
7669
7670 /**
7671 * Returns the number of rows in the table.
7672 *
7673 * @return the number of rows in the table
7674 */
7675 public int getAccessibleRowCount() { return 1; }
7676
7677 /**
7678 * Returns the number of columns in the table.
7679 *
7680 * @return the number of columns in the table
7681 */
7682 public int getAccessibleColumnCount() {
7683 return headerModel.getColumnCount();
7684 }
7685
7686 /**
7687 * Returns the Accessible at a specified row and column
7688 * in the table.
7689 *
7690 * @param row zero-based row of the table
7691 * @param column zero-based column of the table
7692 * @return the Accessible at the specified row and column
7693 */
7694 public Accessible getAccessibleAt(int row, int column) {
7695
7696
7697 // TIGER - 4715503
7698 TableColumn aColumn = headerModel.getColumn(column);
7699 TableCellRenderer renderer = aColumn.getHeaderRenderer();
7700 if (renderer == null) {
7701 renderer = header.getDefaultRenderer();
7702 }
7703 Component component = renderer.getTableCellRendererComponent(
7704 header.getTable(),
7705 aColumn.getHeaderValue(), false, false,
7706 -1, column);
7707
7708 return new AccessibleJTableHeaderCell(row, column,
7709 JTable.this.getTableHeader(),
7710 component);
7711 }
7712
7713 /**
7714 * Returns the number of rows occupied by the Accessible at
7715 * a specified row and column in the table.
7716 *
7717 * @return the number of rows occupied by the Accessible at a
7718 * given specified (row, column)
7719 */
7720 public int getAccessibleRowExtentAt(int r, int c) { return 1; }
7721
7722 /**
7723 * Returns the number of columns occupied by the Accessible at
7724 * a specified row and column in the table.
7725 *
7726 * @return the number of columns occupied by the Accessible at a
7727 * given specified row and column
7728 */
7729 public int getAccessibleColumnExtentAt(int r, int c) { return 1; }
7730
7731 /**
7732 * Returns the row headers as an AccessibleTable.
7733 *
7734 * @return an AccessibleTable representing the row
7735 * headers
7736 */
7737 public AccessibleTable getAccessibleRowHeader() { return null; }
7738
7739 /**
7740 * Sets the row headers.
7741 *
7742 * @param table an AccessibleTable representing the
7743 * row headers
7744 */
7745 public void setAccessibleRowHeader(AccessibleTable table) {}
7746
7747 /**
7748 * Returns the column headers as an AccessibleTable.
7749 *
7750 * @return an AccessibleTable representing the column
7751 * headers
7752 */
7753 public AccessibleTable getAccessibleColumnHeader() { return null; }
7754
7755 /**
7756 * Sets the column headers.
7757 *
7758 * @param table an AccessibleTable representing the
7759 * column headers
7760 * @since 1.3
7761 */
7762 public void setAccessibleColumnHeader(AccessibleTable table) {}
7763
7764 /**
7765 * Returns the description of the specified row in the table.
7766 *
7767 * @param r zero-based row of the table
7768 * @return the description of the row
7769 * @since 1.3
7770 */
7771 public Accessible getAccessibleRowDescription(int r) { return null; }
7772
7773 /**
7774 * Sets the description text of the specified row of the table.
7775 *
7776 * @param r zero-based row of the table
7777 * @param a the description of the row
7778 * @since 1.3
7779 */
7780 public void setAccessibleRowDescription(int r, Accessible a) {}
7781
7782 /**
7783 * Returns the description text of the specified column in the table.
7784 *
7785 * @param c zero-based column of the table
7786 * @return the text description of the column
7787 * @since 1.3
7788 */
7789 public Accessible getAccessibleColumnDescription(int c) { return null; }
7790
7791 /**
7792 * Sets the description text of the specified column in the table.
7793 *
7794 * @param c zero-based column of the table
7795 * @param a the text description of the column
7796 * @since 1.3
7797 */
7798 public void setAccessibleColumnDescription(int c, Accessible a) {}
7799
7800 /**
7801 * Returns a boolean value indicating whether the accessible at
7802 * a specified row and column is selected.
7803 *
7804 * @param r zero-based row of the table
7805 * @param c zero-based column of the table
7806 * @return the boolean value true if the accessible at the
7807 * row and column is selected. Otherwise, the boolean value
7808 * false
7809 * @since 1.3
7810 */
7811 public boolean isAccessibleSelected(int r, int c) { return false; }
7812
7813 /**
7814 * Returns a boolean value indicating whether the specified row
7815 * is selected.
7816 *
7817 * @param r zero-based row of the table
7818 * @return the boolean value true if the specified row is selected.
7819 * Otherwise, false.
7820 * @since 1.3
7821 */
7822 public boolean isAccessibleRowSelected(int r) { return false; }
7823
7824 /**
7825 * Returns a boolean value indicating whether the specified column
7826 * is selected.
7827 *
7828 * @param c zero-based column of the table
7829 * @return the boolean value true if the specified column is selected.
7830 * Otherwise, false.
7831 * @since 1.3
7832 */
7833 public boolean isAccessibleColumnSelected(int c) { return false; }
7834
7835 /**
7836 * Returns the selected rows in a table.
7837 *
7838 * @return an array of selected rows where each element is a
7839 * zero-based row of the table
7840 * @since 1.3
7841 */
7842 public int [] getSelectedAccessibleRows() { return new int[0]; }
7843
7844 /**
7845 * Returns the selected columns in a table.
7846 *
7847 * @return an array of selected columns where each element is a
7848 * zero-based column of the table
7849 * @since 1.3
7850 */
7851 public int [] getSelectedAccessibleColumns() { return new int[0]; }
7852 }
7853
7854
7855 /**
7856 * Sets the column headers as an <code>AccessibleTable</code>.
7857 *
7858 * @param a an <code>AccessibleTable</code> representing the
7859 * column headers
7860 * @since 1.3
7861 */
7862 public void setAccessibleColumnHeader(AccessibleTable a) {
7863 // XXX not implemented
7864 }
7865
7866 /**
7867 * Returns the description of the specified row in the table.
7868 *
7869 * @param r zero-based row of the table
7870 * @return the description of the row
7871 * @since 1.3
7872 */
7873 public Accessible getAccessibleRowDescription(int r) {
7874 if (r < 0 || r >= getAccessibleRowCount()) {
7875 throw new IllegalArgumentException(Integer.toString(r));
7876 }
7877 if (rowDescription == null) {
7878 return null;
7879 } else {
7880 return rowDescription[r];
7881 }
7882 }
7883
7884 /**
7885 * Sets the description text of the specified row of the table.
7886 *
7887 * @param r zero-based row of the table
7888 * @param a the description of the row
7889 * @since 1.3
7890 */
7891 public void setAccessibleRowDescription(int r, Accessible a) {
7892 if (r < 0 || r >= getAccessibleRowCount()) {
7893 throw new IllegalArgumentException(Integer.toString(r));
7894 }
7895 if (rowDescription == null) {
7896 int numRows = getAccessibleRowCount();
7897 rowDescription = new Accessible[numRows];
7898 }
7899 rowDescription[r] = a;
7900 }
7901
7902 /**
7903 * Returns the description of the specified column in the table.
7904 *
7905 * @param c zero-based column of the table
7906 * @return the description of the column
7907 * @since 1.3
7908 */
7909 public Accessible getAccessibleColumnDescription(int c) {
7910 if (c < 0 || c >= getAccessibleColumnCount()) {
7911 throw new IllegalArgumentException(Integer.toString(c));
7912 }
7913 if (columnDescription == null) {
7914 return null;
7915 } else {
7916 return columnDescription[c];
7917 }
7918 }
7919
7920 /**
7921 * Sets the description text of the specified column of the table.
7922 *
7923 * @param c zero-based column of the table
7924 * @param a the description of the column
7925 * @since 1.3
7926 */
7927 public void setAccessibleColumnDescription(int c, Accessible a) {
7928 if (c < 0 || c >= getAccessibleColumnCount()) {
7929 throw new IllegalArgumentException(Integer.toString(c));
7930 }
7931 if (columnDescription == null) {
7932 int numColumns = getAccessibleColumnCount();
7933 columnDescription = new Accessible[numColumns];
7934 }
7935 columnDescription[c] = a;
7936 }
7937
7938 /**
7939 * Returns a boolean value indicating whether the accessible at a
7940 * given (row, column) is selected.
7941 *
7942 * @param r zero-based row of the table
7943 * @param c zero-based column of the table
7944 * @return the boolean value true if the accessible at (row, column)
7945 * is selected; otherwise, the boolean value false
7946 * @since 1.3
7947 */
7948 public boolean isAccessibleSelected(int r, int c) {
7949 return JTable.this.isCellSelected(r, c);
7950 }
7951
7952 /**
7953 * Returns a boolean value indicating whether the specified row
7954 * is selected.
7955 *
7956 * @param r zero-based row of the table
7957 * @return the boolean value true if the specified row is selected;
7958 * otherwise, false
7959 * @since 1.3
7960 */
7961 public boolean isAccessibleRowSelected(int r) {
7962 return JTable.this.isRowSelected(r);
7963 }
7964
7965 /**
7966 * Returns a boolean value indicating whether the specified column
7967 * is selected.
7968 *
7969 * @param c zero-based column of the table
7970 * @return the boolean value true if the specified column is selected;
7971 * otherwise, false
7972 * @since 1.3
7973 */
7974 public boolean isAccessibleColumnSelected(int c) {
7975 return JTable.this.isColumnSelected(c);
7976 }
7977
7978 /**
7979 * Returns the selected rows in a table.
7980 *
7981 * @return an array of selected rows where each element is a
7982 * zero-based row of the table
7983 * @since 1.3
7984 */
7985 public int [] getSelectedAccessibleRows() {
7986 return JTable.this.getSelectedRows();
7987 }
7988
7989 /**
7990 * Returns the selected columns in a table.
7991 *
7992 * @return an array of selected columns where each element is a
7993 * zero-based column of the table
7994 * @since 1.3
7995 */
7996 public int [] getSelectedAccessibleColumns() {
7997 return JTable.this.getSelectedColumns();
7998 }
7999
8000 /**
8001 * Returns the row at a given index into the table.
8002 *
8003 * @param i zero-based index into the table
8004 * @return the row at a given index
8005 * @since 1.3
8006 */
8007 public int getAccessibleRowAtIndex(int i) {
8008 int columnCount = getAccessibleColumnCount();
8009 if (columnCount == 0) {
8010 return -1;
8011 } else {
8012 return (i / columnCount);
8013 }
8014 }
8015
8016 /**
8017 * Returns the column at a given index into the table.
8018 *
8019 * @param i zero-based index into the table
8020 * @return the column at a given index
8021 * @since 1.3
8022 */
8023 public int getAccessibleColumnAtIndex(int i) {
8024 int columnCount = getAccessibleColumnCount();
8025 if (columnCount == 0) {
8026 return -1;
8027 } else {
8028 return (i % columnCount);
8029 }
8030 }
8031
8032 /**
8033 * Returns the index at a given (row, column) in the table.
8034 *
8035 * @param r zero-based row of the table
8036 * @param c zero-based column of the table
8037 * @return the index into the table
8038 * @since 1.3
8039 */
8040 public int getAccessibleIndexAt(int r, int c) {
8041 return ((r * getAccessibleColumnCount()) + c);
8042 }
8043
8044 // end of AccessibleTable implementation --------------------
8045
8046 /**
8047 * The class provides an implementation of the Java Accessibility
8048 * API appropriate to table cells.
8049 */
8050 protected class AccessibleJTableCell extends AccessibleContext
8051 implements Accessible, AccessibleComponent {
8052
8053 private JTable parent;
8054 private int row;
8055 private int column;
8056 private int index;
8057
8058 /**
8059 * Constructs an <code>AccessibleJTableHeaderEntry</code>.
8060 *
8061 * @param t a {@code JTable}
8062 * @param r an {@code int} specifying a row
8063 * @param c an {@code int} specifying a column
8064 * @param i an {@code int} specifying the index to this cell
8065 * @since 1.4
8066 */
8067 public AccessibleJTableCell(JTable t, int r, int c, int i) {
8068 parent = t;
8069 row = r;
8070 column = c;
8071 index = i;
8072 this.setAccessibleParent(parent);
8073 }
8074
8075 /**
8076 * Gets the <code>AccessibleContext</code> associated with this
8077 * component. In the implementation of the Java Accessibility
8078 * API for this class, return this object, which is its own
8079 * <code>AccessibleContext</code>.
8080 *
8081 * @return this object
8082 */
8083 public AccessibleContext getAccessibleContext() {
8084 return this;
8085 }
8086
8087 /**
8088 * Gets the AccessibleContext for the table cell renderer.
8089 *
8090 * @return the <code>AccessibleContext</code> for the table
8091 * cell renderer if one exists;
8092 * otherwise, returns <code>null</code>.
8093 * @since 1.6
8094 */
8095 protected AccessibleContext getCurrentAccessibleContext() {
8096 TableColumn aColumn = getColumnModel().getColumn(column);
8097 TableCellRenderer renderer = aColumn.getCellRenderer();
8098 if (renderer == null) {
8099 Class<?> columnClass = getColumnClass(column);
8100 renderer = getDefaultRenderer(columnClass);
8101 }
8102 Component component = renderer.getTableCellRendererComponent(
8103 JTable.this, getValueAt(row, column),
8104 false, false, row, column);
8105 if (component instanceof Accessible) {
8106 return component.getAccessibleContext();
8107 } else {
8108 return null;
8109 }
8110 }
8111
8112 /**
8113 * Gets the table cell renderer component.
8114 *
8115 * @return the table cell renderer component if one exists;
8116 * otherwise, returns <code>null</code>.
8117 * @since 1.6
8118 */
8119 protected Component getCurrentComponent() {
8120 TableColumn aColumn = getColumnModel().getColumn(column);
8121 TableCellRenderer renderer = aColumn.getCellRenderer();
8122 if (renderer == null) {
8123 Class<?> columnClass = getColumnClass(column);
8124 renderer = getDefaultRenderer(columnClass);
8125 }
8126 return renderer.getTableCellRendererComponent(
8127 JTable.this, null, false, false,
8128 row, column);
8129 }
8130
8131 // AccessibleContext methods
8132
8133 /**
8134 * Gets the accessible name of this object.
8135 *
8136 * @return the localized name of the object; <code>null</code>
8137 * if this object does not have a name
8138 */
8139 public String getAccessibleName() {
8140 AccessibleContext ac = getCurrentAccessibleContext();
8141 if (ac != null) {
8142 String name = ac.getAccessibleName();
8143 if ((name != null) && (name != "")) {
8144 // return the cell renderer's AccessibleName
8145 return name;
8146 }
8147 }
8148 if ((accessibleName != null) && (accessibleName != "")) {
8149 return accessibleName;
8150 } else {
8151 // fall back to the client property
8152 return (String)getClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY);
8153 }
8154 }
8155
8156 /**
8157 * Sets the localized accessible name of this object.
8158 *
8159 * @param s the new localized name of the object
8160 */
8161 public void setAccessibleName(String s) {
8162 AccessibleContext ac = getCurrentAccessibleContext();
8163 if (ac != null) {
8164 ac.setAccessibleName(s);
8165 } else {
8166 super.setAccessibleName(s);
8167 }
8168 }
8169
8170 //
8171 // *** should check toolTip text for desc. (needs MouseEvent)
8172 //
8173 /**
8174 * Gets the accessible description of this object.
8175 *
8176 * @return the localized description of the object;
8177 * <code>null</code> if this object does not have
8178 * a description
8179 */
8180 public String getAccessibleDescription() {
8181 AccessibleContext ac = getCurrentAccessibleContext();
8182 if (ac != null) {
8183 return ac.getAccessibleDescription();
8184 } else {
8185 return super.getAccessibleDescription();
8186 }
8187 }
8188
8189 /**
8190 * Sets the accessible description of this object.
8191 *
8192 * @param s the new localized description of the object
8193 */
8194 public void setAccessibleDescription(String s) {
8195 AccessibleContext ac = getCurrentAccessibleContext();
8196 if (ac != null) {
8197 ac.setAccessibleDescription(s);
8198 } else {
8199 super.setAccessibleDescription(s);
8200 }
8201 }
8202
8203 /**
8204 * Gets the role of this object.
8205 *
8206 * @return an instance of <code>AccessibleRole</code>
8207 * describing the role of the object
8208 * @see AccessibleRole
8209 */
8210 public AccessibleRole getAccessibleRole() {
8211 AccessibleContext ac = getCurrentAccessibleContext();
8212 if (ac != null) {
8213 return ac.getAccessibleRole();
8214 } else {
8215 return AccessibleRole.UNKNOWN;
8216 }
8217 }
8218
8219 /**
8220 * Gets the state set of this object.
8221 *
8222 * @return an instance of <code>AccessibleStateSet</code>
8223 * containing the current state set of the object
8224 * @see AccessibleState
8225 */
8226 public AccessibleStateSet getAccessibleStateSet() {
8227 AccessibleContext ac = getCurrentAccessibleContext();
8228 AccessibleStateSet as = null;
8229
8230 if (ac != null) {
8231 as = ac.getAccessibleStateSet();
8232 }
8233 if (as == null) {
8234 as = new AccessibleStateSet();
8235 }
8236 Rectangle rjt = JTable.this.getVisibleRect();
8237 Rectangle rcell = JTable.this.getCellRect(row, column, false);
8238 if (rjt.intersects(rcell)) {
8239 as.add(AccessibleState.SHOWING);
8240 } else {
8241 if (as.contains(AccessibleState.SHOWING)) {
8242 as.remove(AccessibleState.SHOWING);
8243 }
8244 }
8245 if (parent.isCellSelected(row, column)) {
8246 as.add(AccessibleState.SELECTED);
8247 } else if (as.contains(AccessibleState.SELECTED)) {
8248 as.remove(AccessibleState.SELECTED);
8249 }
8250 if ((row == getSelectedRow()) && (column == getSelectedColumn())) {
8251 as.add(AccessibleState.ACTIVE);
8252 }
8253 as.add(AccessibleState.TRANSIENT);
8254 return as;
8255 }
8256
8257 /**
8258 * Gets the <code>Accessible</code> parent of this object.
8259 *
8260 * @return the Accessible parent of this object;
8261 * <code>null</code> if this object does not
8262 * have an <code>Accessible</code> parent
8263 */
8264 public Accessible getAccessibleParent() {
8265 return parent;
8266 }
8267
8268 /**
8269 * Gets the index of this object in its accessible parent.
8270 *
8271 * @return the index of this object in its parent; -1 if this
8272 * object does not have an accessible parent
8273 * @see #getAccessibleParent
8274 */
8275 public int getAccessibleIndexInParent() {
8276 return index;
8277 }
8278
8279 /**
8280 * Returns the number of accessible children in the object.
8281 *
8282 * @return the number of accessible children in the object
8283 */
8284 public int getAccessibleChildrenCount() {
8285 AccessibleContext ac = getCurrentAccessibleContext();
8286 if (ac != null) {
8287 return ac.getAccessibleChildrenCount();
8288 } else {
8289 return 0;
8290 }
8291 }
8292
8293 /**
8294 * Returns the specified <code>Accessible</code> child of the
8295 * object.
8296 *
8297 * @param i zero-based index of child
8298 * @return the <code>Accessible</code> child of the object
8299 */
8300 public Accessible getAccessibleChild(int i) {
8301 AccessibleContext ac = getCurrentAccessibleContext();
8302 if (ac != null) {
8303 Accessible accessibleChild = ac.getAccessibleChild(i);
8304 ac.setAccessibleParent(this);
8305 return accessibleChild;
8306 } else {
8307 return null;
8308 }
8309 }
8310
8311 /**
8312 * Gets the locale of the component. If the component
8313 * does not have a locale, then the locale of its parent
8314 * is returned.
8315 *
8316 * @return this component's locale; if this component does
8317 * not have a locale, the locale of its parent is returned
8318 * @exception IllegalComponentStateException if the
8319 * <code>Component</code> does not have its own locale
8320 * and has not yet been added to a containment hierarchy
8321 * such that the locale can be determined from the
8322 * containing parent
8323 * @see #setLocale
8324 */
8325 public Locale getLocale() {
8326 AccessibleContext ac = getCurrentAccessibleContext();
8327 if (ac != null) {
8328 return ac.getLocale();
8329 } else {
8330 return null;
8331 }
8332 }
8333
8334 /**
8335 * Adds a <code>PropertyChangeListener</code> to the listener list.
8336 * The listener is registered for all properties.
8337 *
8338 * @param l the <code>PropertyChangeListener</code>
8339 * to be added
8340 */
8341 public void addPropertyChangeListener(PropertyChangeListener l) {
8342 AccessibleContext ac = getCurrentAccessibleContext();
8343 if (ac != null) {
8344 ac.addPropertyChangeListener(l);
8345 } else {
8346 super.addPropertyChangeListener(l);
8347 }
8348 }
8349
8350 /**
8351 * Removes a <code>PropertyChangeListener</code> from the
8352 * listener list. This removes a <code>PropertyChangeListener</code>
8353 * that was registered for all properties.
8354 *
8355 * @param l the <code>PropertyChangeListener</code>
8356 * to be removed
8357 */
8358 public void removePropertyChangeListener(PropertyChangeListener l) {
8359 AccessibleContext ac = getCurrentAccessibleContext();
8360 if (ac != null) {
8361 ac.removePropertyChangeListener(l);
8362 } else {
8363 super.removePropertyChangeListener(l);
8364 }
8365 }
8366
8367 /**
8368 * Gets the <code>AccessibleAction</code> associated with this
8369 * object if one exists. Otherwise returns <code>null</code>.
8370 *
8371 * @return the <code>AccessibleAction</code>, or <code>null</code>
8372 */
8373 public AccessibleAction getAccessibleAction() {
8374 return getCurrentAccessibleContext().getAccessibleAction();
8375 }
8376
8377 /**
8378 * Gets the <code>AccessibleComponent</code> associated with
8379 * this object if one exists. Otherwise returns <code>null</code>.
8380 *
8381 * @return the <code>AccessibleComponent</code>, or
8382 * <code>null</code>
8383 */
8384 public AccessibleComponent getAccessibleComponent() {
8385 return this; // to override getBounds()
8386 }
8387
8388 /**
8389 * Gets the <code>AccessibleSelection</code> associated with
8390 * this object if one exists. Otherwise returns <code>null</code>.
8391 *
8392 * @return the <code>AccessibleSelection</code>, or
8393 * <code>null</code>
8394 */
8395 public AccessibleSelection getAccessibleSelection() {
8396 return getCurrentAccessibleContext().getAccessibleSelection();
8397 }
8398
8399 /**
8400 * Gets the <code>AccessibleText</code> associated with this
8401 * object if one exists. Otherwise returns <code>null</code>.
8402 *
8403 * @return the <code>AccessibleText</code>, or <code>null</code>
8404 */
8405 public AccessibleText getAccessibleText() {
8406 return getCurrentAccessibleContext().getAccessibleText();
8407 }
8408
8409 /**
8410 * Gets the <code>AccessibleValue</code> associated with
8411 * this object if one exists. Otherwise returns <code>null</code>.
8412 *
8413 * @return the <code>AccessibleValue</code>, or <code>null</code>
8414 */
8415 public AccessibleValue getAccessibleValue() {
8416 return getCurrentAccessibleContext().getAccessibleValue();
8417 }
8418
8419
8420 // AccessibleComponent methods
8421
8422 /**
8423 * Gets the background color of this object.
8424 *
8425 * @return the background color, if supported, of the object;
8426 * otherwise, <code>null</code>
8427 */
8428 public Color getBackground() {
8429 AccessibleContext ac = getCurrentAccessibleContext();
8430 if (ac instanceof AccessibleComponent) {
8431 return ((AccessibleComponent) ac).getBackground();
8432 } else {
8433 Component c = getCurrentComponent();
8434 if (c != null) {
8435 return c.getBackground();
8436 } else {
8437 return null;
8438 }
8439 }
8440 }
8441
8442 /**
8443 * Sets the background color of this object.
8444 *
8445 * @param c the new <code>Color</code> for the background
8446 */
8447 public void setBackground(Color c) {
8448 AccessibleContext ac = getCurrentAccessibleContext();
8449 if (ac instanceof AccessibleComponent) {
8450 ((AccessibleComponent) ac).setBackground(c);
8451 } else {
8452 Component cp = getCurrentComponent();
8453 if (cp != null) {
8454 cp.setBackground(c);
8455 }
8456 }
8457 }
8458
8459 /**
8460 * Gets the foreground color of this object.
8461 *
8462 * @return the foreground color, if supported, of the object;
8463 * otherwise, <code>null</code>
8464 */
8465 public Color getForeground() {
8466 AccessibleContext ac = getCurrentAccessibleContext();
8467 if (ac instanceof AccessibleComponent) {
8468 return ((AccessibleComponent) ac).getForeground();
8469 } else {
8470 Component c = getCurrentComponent();
8471 if (c != null) {
8472 return c.getForeground();
8473 } else {
8474 return null;
8475 }
8476 }
8477 }
8478
8479 /**
8480 * Sets the foreground color of this object.
8481 *
8482 * @param c the new <code>Color</code> for the foreground
8483 */
8484 public void setForeground(Color c) {
8485 AccessibleContext ac = getCurrentAccessibleContext();
8486 if (ac instanceof AccessibleComponent) {
8487 ((AccessibleComponent) ac).setForeground(c);
8488 } else {
8489 Component cp = getCurrentComponent();
8490 if (cp != null) {
8491 cp.setForeground(c);
8492 }
8493 }
8494 }
8495
8496 /**
8497 * Gets the <code>Cursor</code> of this object.
8498 *
8499 * @return the <code>Cursor</code>, if supported,
8500 * of the object; otherwise, <code>null</code>
8501 */
8502 public Cursor getCursor() {
8503 AccessibleContext ac = getCurrentAccessibleContext();
8504 if (ac instanceof AccessibleComponent) {
8505 return ((AccessibleComponent) ac).getCursor();
8506 } else {
8507 Component c = getCurrentComponent();
8508 if (c != null) {
8509 return c.getCursor();
8510 } else {
8511 Accessible ap = getAccessibleParent();
8512 if (ap instanceof AccessibleComponent) {
8513 return ((AccessibleComponent) ap).getCursor();
8514 } else {
8515 return null;
8516 }
8517 }
8518 }
8519 }
8520
8521 /**
8522 * Sets the <code>Cursor</code> of this object.
8523 *
8524 * @param c the new <code>Cursor</code> for the object
8525 */
8526 public void setCursor(Cursor c) {
8527 AccessibleContext ac = getCurrentAccessibleContext();
8528 if (ac instanceof AccessibleComponent) {
8529 ((AccessibleComponent) ac).setCursor(c);
8530 } else {
8531 Component cp = getCurrentComponent();
8532 if (cp != null) {
8533 cp.setCursor(c);
8534 }
8535 }
8536 }
8537
8538 /**
8539 * Gets the <code>Font</code> of this object.
8540 *
8541 * @return the <code>Font</code>,if supported,
8542 * for the object; otherwise, <code>null</code>
8543 */
8544 public Font getFont() {
8545 AccessibleContext ac = getCurrentAccessibleContext();
8546 if (ac instanceof AccessibleComponent) {
8547 return ((AccessibleComponent) ac).getFont();
8548 } else {
8549 Component c = getCurrentComponent();
8550 if (c != null) {
8551 return c.getFont();
8552 } else {
8553 return null;
8554 }
8555 }
8556 }
8557
8558 /**
8559 * Sets the <code>Font</code> of this object.
8560 *
8561 * @param f the new <code>Font</code> for the object
8562 */
8563 public void setFont(Font f) {
8564 AccessibleContext ac = getCurrentAccessibleContext();
8565 if (ac instanceof AccessibleComponent) {
8566 ((AccessibleComponent) ac).setFont(f);
8567 } else {
8568 Component c = getCurrentComponent();
8569 if (c != null) {
8570 c.setFont(f);
8571 }
8572 }
8573 }
8574
8575 /**
8576 * Gets the <code>FontMetrics</code> of this object.
8577 *
8578 * @param f the <code>Font</code>
8579 * @return the <code>FontMetrics</code> object, if supported;
8580 * otherwise <code>null</code>
8581 * @see #getFont
8582 */
8583 public FontMetrics getFontMetrics(Font f) {
8584 AccessibleContext ac = getCurrentAccessibleContext();
8585 if (ac instanceof AccessibleComponent) {
8586 return ((AccessibleComponent) ac).getFontMetrics(f);
8587 } else {
8588 Component c = getCurrentComponent();
8589 if (c != null) {
8590 return c.getFontMetrics(f);
8591 } else {
8592 return null;
8593 }
8594 }
8595 }
8596
8597 /**
8598 * Determines if the object is enabled.
8599 *
8600 * @return true if object is enabled; otherwise, false
8601 */
8602 public boolean isEnabled() {
8603 AccessibleContext ac = getCurrentAccessibleContext();
8604 if (ac instanceof AccessibleComponent) {
8605 return ((AccessibleComponent) ac).isEnabled();
8606 } else {
8607 Component c = getCurrentComponent();
8608 if (c != null) {
8609 return c.isEnabled();
8610 } else {
8611 return false;
8612 }
8613 }
8614 }
8615
8616 /**
8617 * Sets the enabled state of the object.
8618 *
8619 * @param b if true, enables this object; otherwise, disables it
8620 */
8621 public void setEnabled(boolean b) {
8622 AccessibleContext ac = getCurrentAccessibleContext();
8623 if (ac instanceof AccessibleComponent) {
8624 ((AccessibleComponent) ac).setEnabled(b);
8625 } else {
8626 Component c = getCurrentComponent();
8627 if (c != null) {
8628 c.setEnabled(b);
8629 }
8630 }
8631 }
8632
8633 /**
8634 * Determines if this object is visible. Note: this means that the
8635 * object intends to be visible; however, it may not in fact be
8636 * showing on the screen because one of the objects that this object
8637 * is contained by is not visible. To determine if an object is
8638 * showing on the screen, use <code>isShowing</code>.
8639 *
8640 * @return true if object is visible; otherwise, false
8641 */
8642 public boolean isVisible() {
8643 AccessibleContext ac = getCurrentAccessibleContext();
8644 if (ac instanceof AccessibleComponent) {
8645 return ((AccessibleComponent) ac).isVisible();
8646 } else {
8647 Component c = getCurrentComponent();
8648 if (c != null) {
8649 return c.isVisible();
8650 } else {
8651 return false;
8652 }
8653 }
8654 }
8655
8656 /**
8657 * Sets the visible state of the object.
8658 *
8659 * @param b if true, shows this object; otherwise, hides it
8660 */
8661 public void setVisible(boolean b) {
8662 AccessibleContext ac = getCurrentAccessibleContext();
8663 if (ac instanceof AccessibleComponent) {
8664 ((AccessibleComponent) ac).setVisible(b);
8665 } else {
8666 Component c = getCurrentComponent();
8667 if (c != null) {
8668 c.setVisible(b);
8669 }
8670 }
8671 }
8672
8673 /**
8674 * Determines if the object is showing. This is determined
8675 * by checking the visibility of the object and ancestors
8676 * of the object. Note: this will return true even if the
8677 * object is obscured by another (for example,
8678 * it happens to be underneath a menu that was pulled down).
8679 *
8680 * @return true if the object is showing; otherwise, false
8681 */
8682 public boolean isShowing() {
8683 AccessibleContext ac = getCurrentAccessibleContext();
8684 if (ac instanceof AccessibleComponent) {
8685 if (ac.getAccessibleParent() != null) {
8686 return ((AccessibleComponent) ac).isShowing();
8687 } else {
8688 // Fixes 4529616 - AccessibleJTableCell.isShowing()
8689 // returns false when the cell on the screen
8690 // if no parent
8691 return isVisible();
8692 }
8693 } else {
8694 Component c = getCurrentComponent();
8695 if (c != null) {
8696 return c.isShowing();
8697 } else {
8698 return false;
8699 }
8700 }
8701 }
8702
8703 /**
8704 * Checks whether the specified point is within this
8705 * object's bounds, where the point's x and y coordinates
8706 * are defined to be relative to the coordinate system of
8707 * the object.
8708 *
8709 * @param p the <code>Point</code> relative to the
8710 * coordinate system of the object
8711 * @return true if object contains <code>Point</code>;
8712 * otherwise false
8713 */
8714 public boolean contains(Point p) {
8715 AccessibleContext ac = getCurrentAccessibleContext();
8716 if (ac instanceof AccessibleComponent) {
8717 Rectangle r = ((AccessibleComponent) ac).getBounds();
8718 return r.contains(p);
8719 } else {
8720 Component c = getCurrentComponent();
8721 if (c != null) {
8722 Rectangle r = c.getBounds();
8723 return r.contains(p);
8724 } else {
8725 return getBounds().contains(p);
8726 }
8727 }
8728 }
8729
8730 /**
8731 * Returns the location of the object on the screen.
8732 *
8733 * @return location of object on screen -- can be
8734 * <code>null</code> if this object is not on the screen
8735 */
8736 public Point getLocationOnScreen() {
8737 if (parent != null && parent.isShowing()) {
8738 Point parentLocation = parent.getLocationOnScreen();
8739 Point componentLocation = getLocation();
8740 componentLocation.translate(parentLocation.x, parentLocation.y);
8741 return componentLocation;
8742 } else {
8743 return null;
8744 }
8745 }
8746
8747 /**
8748 * Gets the location of the object relative to the parent
8749 * in the form of a point specifying the object's
8750 * top-left corner in the screen's coordinate space.
8751 *
8752 * @return an instance of <code>Point</code> representing
8753 * the top-left corner of the object's bounds in the
8754 * coordinate space of the screen; <code>null</code> if
8755 * this object or its parent are not on the screen
8756 */
8757 public Point getLocation() {
8758 if (parent != null) {
8759 Rectangle r = parent.getCellRect(row, column, false);
8760 if (r != null) {
8761 return r.getLocation();
8762 }
8763 }
8764 return null;
8765 }
8766
8767 /**
8768 * Sets the location of the object relative to the parent.
8769 */
8770 public void setLocation(Point p) {
8771 // if ((parent != null) && (parent.contains(p))) {
8772 // ensureIndexIsVisible(indexInParent);
8773 // }
8774 }
8775
8776 public Rectangle getBounds() {
8777 if (parent != null) {
8778 return parent.getCellRect(row, column, false);
8779 } else {
8780 return null;
8781 }
8782 }
8783
8784 public void setBounds(Rectangle r) {
8785 AccessibleContext ac = getCurrentAccessibleContext();
8786 if (ac instanceof AccessibleComponent) {
8787 ((AccessibleComponent) ac).setBounds(r);
8788 } else {
8789 Component c = getCurrentComponent();
8790 if (c != null) {
8791 c.setBounds(r);
8792 }
8793 }
8794 }
8795
8796 public Dimension getSize() {
8797 if (parent != null) {
8798 Rectangle r = parent.getCellRect(row, column, false);
8799 if (r != null) {
8800 return r.getSize();
8801 }
8802 }
8803 return null;
8804 }
8805
8806 public void setSize (Dimension d) {
8807 AccessibleContext ac = getCurrentAccessibleContext();
8808 if (ac instanceof AccessibleComponent) {
8809 ((AccessibleComponent) ac).setSize(d);
8810 } else {
8811 Component c = getCurrentComponent();
8812 if (c != null) {
8813 c.setSize(d);
8814 }
8815 }
8816 }
8817
8818 public Accessible getAccessibleAt(Point p) {
8819 AccessibleContext ac = getCurrentAccessibleContext();
8820 if (ac instanceof AccessibleComponent) {
8821 return ((AccessibleComponent) ac).getAccessibleAt(p);
8822 } else {
8823 return null;
8824 }
8825 }
8826
8827 @SuppressWarnings("deprecation")
8828 public boolean isFocusTraversable() {
8829 AccessibleContext ac = getCurrentAccessibleContext();
8830 if (ac instanceof AccessibleComponent) {
8831 return ((AccessibleComponent) ac).isFocusTraversable();
8832 } else {
8833 Component c = getCurrentComponent();
8834 if (c != null) {
8835 return c.isFocusTraversable();
8836 } else {
8837 return false;
8838 }
8839 }
8840 }
8841
8842 public void requestFocus() {
8843 AccessibleContext ac = getCurrentAccessibleContext();
8844 if (ac instanceof AccessibleComponent) {
8845 ((AccessibleComponent) ac).requestFocus();
8846 } else {
8847 Component c = getCurrentComponent();
8848 if (c != null) {
8849 c.requestFocus();
8850 }
8851 }
8852 }
8853
8854 public void addFocusListener(FocusListener l) {
8855 AccessibleContext ac = getCurrentAccessibleContext();
8856 if (ac instanceof AccessibleComponent) {
8857 ((AccessibleComponent) ac).addFocusListener(l);
8858 } else {
8859 Component c = getCurrentComponent();
8860 if (c != null) {
8861 c.addFocusListener(l);
8862 }
8863 }
8864 }
8865
8866 public void removeFocusListener(FocusListener l) {
8867 AccessibleContext ac = getCurrentAccessibleContext();
8868 if (ac instanceof AccessibleComponent) {
8869 ((AccessibleComponent) ac).removeFocusListener(l);
8870 } else {
8871 Component c = getCurrentComponent();
8872 if (c != null) {
8873 c.removeFocusListener(l);
8874 }
8875 }
8876 }
8877
8878 } // inner class AccessibleJTableCell
8879
8880 // Begin AccessibleJTableHeader ========== // TIGER - 4715503
8881
8882 /**
8883 * This class implements accessibility for JTable header cells.
8884 */
8885 private class AccessibleJTableHeaderCell extends AccessibleContext
8886 implements Accessible, AccessibleComponent {
8887
8888 private int row;
8889 private int column;
8890 private JTableHeader parent;
8891 private Component rendererComponent;
8892
8893 /**
8894 * Constructs an <code>AccessibleJTableHeaderEntry</code> instance.
8895 *
8896 * @param row header cell row index
8897 * @param column header cell column index
8898 * @param parent header cell parent
8899 * @param rendererComponent component that renders the header cell
8900 */
8901 public AccessibleJTableHeaderCell(int row, int column,
8902 JTableHeader parent,
8903 Component rendererComponent) {
8904 this.row = row;
8905 this.column = column;
8906 this.parent = parent;
8907 this.rendererComponent = rendererComponent;
8908 this.setAccessibleParent(parent);
8909 }
8910
8911 /**
8912 * Gets the <code>AccessibleContext</code> associated with this
8913 * component. In the implementation of the Java Accessibility
8914 * API for this class, return this object, which is its own
8915 * <code>AccessibleContext</code>.
8916 *
8917 * @return this object
8918 */
8919 public AccessibleContext getAccessibleContext() {
8920 return this;
8921 }
8922
8923 /*
8924 * Returns the AccessibleContext for the header cell
8925 * renderer.
8926 */
8927 private AccessibleContext getCurrentAccessibleContext() {
8928 return rendererComponent.getAccessibleContext();
8929 }
8930
8931 /*
8932 * Returns the component that renders the header cell.
8933 */
8934 private Component getCurrentComponent() {
8935 return rendererComponent;
8936 }
8937
8938 // AccessibleContext methods ==========
8939
8940 /**
8941 * Gets the accessible name of this object.
8942 *
8943 * @return the localized name of the object; <code>null</code>
8944 * if this object does not have a name
8945 */
8946 public String getAccessibleName() {
8947 AccessibleContext ac = getCurrentAccessibleContext();
8948 if (ac != null) {
8949 String name = ac.getAccessibleName();
8950 if ((name != null) && (name != "")) {
8951 return ac.getAccessibleName();
8952 }
8953 }
8954 if ((accessibleName != null) && (accessibleName != "")) {
8955 return accessibleName;
8956 } else {
8957 return null;
8958 }
8959 }
8960
8961 /**
8962 * Sets the localized accessible name of this object.
8963 *
8964 * @param s the new localized name of the object
8965 */
8966 public void setAccessibleName(String s) {
8967 AccessibleContext ac = getCurrentAccessibleContext();
8968 if (ac != null) {
8969 ac.setAccessibleName(s);
8970 } else {
8971 super.setAccessibleName(s);
8972 }
8973 }
8974
8975 /**
8976 * Gets the accessible description of this object.
8977 *
8978 * @return the localized description of the object;
8979 * <code>null</code> if this object does not have
8980 * a description
8981 */
8982 public String getAccessibleDescription() {
8983 AccessibleContext ac = getCurrentAccessibleContext();
8984 if (ac != null) {
8985 return ac.getAccessibleDescription();
8986 } else {
8987 return super.getAccessibleDescription();
8988 }
8989 }
8990
8991 /**
8992 * Sets the accessible description of this object.
8993 *
8994 * @param s the new localized description of the object
8995 */
8996 public void setAccessibleDescription(String s) {
8997 AccessibleContext ac = getCurrentAccessibleContext();
8998 if (ac != null) {
8999 ac.setAccessibleDescription(s);
9000 } else {
9001 super.setAccessibleDescription(s);
9002 }
9003 }
9004
9005 /**
9006 * Gets the role of this object.
9007 *
9008 * @return an instance of <code>AccessibleRole</code>
9009 * describing the role of the object
9010 * @see AccessibleRole
9011 */
9012 public AccessibleRole getAccessibleRole() {
9013 AccessibleContext ac = getCurrentAccessibleContext();
9014 if (ac != null) {
9015 return ac.getAccessibleRole();
9016 } else {
9017 return AccessibleRole.UNKNOWN;
9018 }
9019 }
9020
9021 /**
9022 * Gets the state set of this object.
9023 *
9024 * @return an instance of <code>AccessibleStateSet</code>
9025 * containing the current state set of the object
9026 * @see AccessibleState
9027 */
9028 public AccessibleStateSet getAccessibleStateSet() {
9029 AccessibleContext ac = getCurrentAccessibleContext();
9030 AccessibleStateSet as = null;
9031
9032 if (ac != null) {
9033 as = ac.getAccessibleStateSet();
9034 }
9035 if (as == null) {
9036 as = new AccessibleStateSet();
9037 }
9038 Rectangle rjt = JTable.this.getVisibleRect();
9039 Rectangle rcell = JTable.this.getCellRect(row, column, false);
9040 if (rjt.intersects(rcell)) {
9041 as.add(AccessibleState.SHOWING);
9042 } else {
9043 if (as.contains(AccessibleState.SHOWING)) {
9044 as.remove(AccessibleState.SHOWING);
9045 }
9046 }
9047 if (JTable.this.isCellSelected(row, column)) {
9048 as.add(AccessibleState.SELECTED);
9049 } else if (as.contains(AccessibleState.SELECTED)) {
9050 as.remove(AccessibleState.SELECTED);
9051 }
9052 if ((row == getSelectedRow()) && (column == getSelectedColumn())) {
9053 as.add(AccessibleState.ACTIVE);
9054 }
9055 as.add(AccessibleState.TRANSIENT);
9056 return as;
9057 }
9058
9059 /**
9060 * Gets the <code>Accessible</code> parent of this object.
9061 *
9062 * @return the Accessible parent of this object;
9063 * <code>null</code> if this object does not
9064 * have an <code>Accessible</code> parent
9065 */
9066 public Accessible getAccessibleParent() {
9067 return parent;
9068 }
9069
9070 /**
9071 * Gets the index of this object in its accessible parent.
9072 *
9073 * @return the index of this object in its parent; -1 if this
9074 * object does not have an accessible parent
9075 * @see #getAccessibleParent
9076 */
9077 public int getAccessibleIndexInParent() {
9078 return column;
9079 }
9080
9081 /**
9082 * Returns the number of accessible children in the object.
9083 *
9084 * @return the number of accessible children in the object
9085 */
9086 public int getAccessibleChildrenCount() {
9087 AccessibleContext ac = getCurrentAccessibleContext();
9088 if (ac != null) {
9089 return ac.getAccessibleChildrenCount();
9090 } else {
9091 return 0;
9092 }
9093 }
9094
9095 /**
9096 * Returns the specified <code>Accessible</code> child of the
9097 * object.
9098 *
9099 * @param i zero-based index of child
9100 * @return the <code>Accessible</code> child of the object
9101 */
9102 public Accessible getAccessibleChild(int i) {
9103 AccessibleContext ac = getCurrentAccessibleContext();
9104 if (ac != null) {
9105 Accessible accessibleChild = ac.getAccessibleChild(i);
9106 ac.setAccessibleParent(this);
9107 return accessibleChild;
9108 } else {
9109 return null;
9110 }
9111 }
9112
9113 /**
9114 * Gets the locale of the component. If the component
9115 * does not have a locale, then the locale of its parent
9116 * is returned.
9117 *
9118 * @return this component's locale; if this component does
9119 * not have a locale, the locale of its parent is returned
9120 * @exception IllegalComponentStateException if the
9121 * <code>Component</code> does not have its own locale
9122 * and has not yet been added to a containment hierarchy
9123 * such that the locale can be determined from the
9124 * containing parent
9125 * @see #setLocale
9126 */
9127 public Locale getLocale() {
9128 AccessibleContext ac = getCurrentAccessibleContext();
9129 if (ac != null) {
9130 return ac.getLocale();
9131 } else {
9132 return null;
9133 }
9134 }
9135
9136 /**
9137 * Adds a <code>PropertyChangeListener</code> to the listener list.
9138 * The listener is registered for all properties.
9139 *
9140 * @param l the <code>PropertyChangeListener</code>
9141 * to be added
9142 */
9143 public void addPropertyChangeListener(PropertyChangeListener l) {
9144 AccessibleContext ac = getCurrentAccessibleContext();
9145 if (ac != null) {
9146 ac.addPropertyChangeListener(l);
9147 } else {
9148 super.addPropertyChangeListener(l);
9149 }
9150 }
9151
9152 /**
9153 * Removes a <code>PropertyChangeListener</code> from the
9154 * listener list. This removes a <code>PropertyChangeListener</code>
9155 * that was registered for all properties.
9156 *
9157 * @param l the <code>PropertyChangeListener</code>
9158 * to be removed
9159 */
9160 public void removePropertyChangeListener(PropertyChangeListener l) {
9161 AccessibleContext ac = getCurrentAccessibleContext();
9162 if (ac != null) {
9163 ac.removePropertyChangeListener(l);
9164 } else {
9165 super.removePropertyChangeListener(l);
9166 }
9167 }
9168
9169 /**
9170 * Gets the <code>AccessibleAction</code> associated with this
9171 * object if one exists. Otherwise returns <code>null</code>.
9172 *
9173 * @return the <code>AccessibleAction</code>, or <code>null</code>
9174 */
9175 public AccessibleAction getAccessibleAction() {
9176 return getCurrentAccessibleContext().getAccessibleAction();
9177 }
9178
9179 /**
9180 * Gets the <code>AccessibleComponent</code> associated with
9181 * this object if one exists. Otherwise returns <code>null</code>.
9182 *
9183 * @return the <code>AccessibleComponent</code>, or
9184 * <code>null</code>
9185 */
9186 public AccessibleComponent getAccessibleComponent() {
9187 return this; // to override getBounds()
9188 }
9189
9190 /**
9191 * Gets the <code>AccessibleSelection</code> associated with
9192 * this object if one exists. Otherwise returns <code>null</code>.
9193 *
9194 * @return the <code>AccessibleSelection</code>, or
9195 * <code>null</code>
9196 */
9197 public AccessibleSelection getAccessibleSelection() {
9198 return getCurrentAccessibleContext().getAccessibleSelection();
9199 }
9200
9201 /**
9202 * Gets the <code>AccessibleText</code> associated with this
9203 * object if one exists. Otherwise returns <code>null</code>.
9204 *
9205 * @return the <code>AccessibleText</code>, or <code>null</code>
9206 */
9207 public AccessibleText getAccessibleText() {
9208 return getCurrentAccessibleContext().getAccessibleText();
9209 }
9210
9211 /**
9212 * Gets the <code>AccessibleValue</code> associated with
9213 * this object if one exists. Otherwise returns <code>null</code>.
9214 *
9215 * @return the <code>AccessibleValue</code>, or <code>null</code>
9216 */
9217 public AccessibleValue getAccessibleValue() {
9218 return getCurrentAccessibleContext().getAccessibleValue();
9219 }
9220
9221
9222 // AccessibleComponent methods ==========
9223
9224 /**
9225 * Gets the background color of this object.
9226 *
9227 * @return the background color, if supported, of the object;
9228 * otherwise, <code>null</code>
9229 */
9230 public Color getBackground() {
9231 AccessibleContext ac = getCurrentAccessibleContext();
9232 if (ac instanceof AccessibleComponent) {
9233 return ((AccessibleComponent) ac).getBackground();
9234 } else {
9235 Component c = getCurrentComponent();
9236 if (c != null) {
9237 return c.getBackground();
9238 } else {
9239 return null;
9240 }
9241 }
9242 }
9243
9244 /**
9245 * Sets the background color of this object.
9246 *
9247 * @param c the new <code>Color</code> for the background
9248 */
9249 public void setBackground(Color c) {
9250 AccessibleContext ac = getCurrentAccessibleContext();
9251 if (ac instanceof AccessibleComponent) {
9252 ((AccessibleComponent) ac).setBackground(c);
9253 } else {
9254 Component cp = getCurrentComponent();
9255 if (cp != null) {
9256 cp.setBackground(c);
9257 }
9258 }
9259 }
9260
9261 /**
9262 * Gets the foreground color of this object.
9263 *
9264 * @return the foreground color, if supported, of the object;
9265 * otherwise, <code>null</code>
9266 */
9267 public Color getForeground() {
9268 AccessibleContext ac = getCurrentAccessibleContext();
9269 if (ac instanceof AccessibleComponent) {
9270 return ((AccessibleComponent) ac).getForeground();
9271 } else {
9272 Component c = getCurrentComponent();
9273 if (c != null) {
9274 return c.getForeground();
9275 } else {
9276 return null;
9277 }
9278 }
9279 }
9280
9281 /**
9282 * Sets the foreground color of this object.
9283 *
9284 * @param c the new <code>Color</code> for the foreground
9285 */
9286 public void setForeground(Color c) {
9287 AccessibleContext ac = getCurrentAccessibleContext();
9288 if (ac instanceof AccessibleComponent) {
9289 ((AccessibleComponent) ac).setForeground(c);
9290 } else {
9291 Component cp = getCurrentComponent();
9292 if (cp != null) {
9293 cp.setForeground(c);
9294 }
9295 }
9296 }
9297
9298 /**
9299 * Gets the <code>Cursor</code> of this object.
9300 *
9301 * @return the <code>Cursor</code>, if supported,
9302 * of the object; otherwise, <code>null</code>
9303 */
9304 public Cursor getCursor() {
9305 AccessibleContext ac = getCurrentAccessibleContext();
9306 if (ac instanceof AccessibleComponent) {
9307 return ((AccessibleComponent) ac).getCursor();
9308 } else {
9309 Component c = getCurrentComponent();
9310 if (c != null) {
9311 return c.getCursor();
9312 } else {
9313 Accessible ap = getAccessibleParent();
9314 if (ap instanceof AccessibleComponent) {
9315 return ((AccessibleComponent) ap).getCursor();
9316 } else {
9317 return null;
9318 }
9319 }
9320 }
9321 }
9322
9323 /**
9324 * Sets the <code>Cursor</code> of this object.
9325 *
9326 * @param c the new <code>Cursor</code> for the object
9327 */
9328 public void setCursor(Cursor c) {
9329 AccessibleContext ac = getCurrentAccessibleContext();
9330 if (ac instanceof AccessibleComponent) {
9331 ((AccessibleComponent) ac).setCursor(c);
9332 } else {
9333 Component cp = getCurrentComponent();
9334 if (cp != null) {
9335 cp.setCursor(c);
9336 }
9337 }
9338 }
9339
9340 /**
9341 * Gets the <code>Font</code> of this object.
9342 *
9343 * @return the <code>Font</code>,if supported,
9344 * for the object; otherwise, <code>null</code>
9345 */
9346 public Font getFont() {
9347 AccessibleContext ac = getCurrentAccessibleContext();
9348 if (ac instanceof AccessibleComponent) {
9349 return ((AccessibleComponent) ac).getFont();
9350 } else {
9351 Component c = getCurrentComponent();
9352 if (c != null) {
9353 return c.getFont();
9354 } else {
9355 return null;
9356 }
9357 }
9358 }
9359
9360 /**
9361 * Sets the <code>Font</code> of this object.
9362 *
9363 * @param f the new <code>Font</code> for the object
9364 */
9365 public void setFont(Font f) {
9366 AccessibleContext ac = getCurrentAccessibleContext();
9367 if (ac instanceof AccessibleComponent) {
9368 ((AccessibleComponent) ac).setFont(f);
9369 } else {
9370 Component c = getCurrentComponent();
9371 if (c != null) {
9372 c.setFont(f);
9373 }
9374 }
9375 }
9376
9377 /**
9378 * Gets the <code>FontMetrics</code> of this object.
9379 *
9380 * @param f the <code>Font</code>
9381 * @return the <code>FontMetrics</code> object, if supported;
9382 * otherwise <code>null</code>
9383 * @see #getFont
9384 */
9385 public FontMetrics getFontMetrics(Font f) {
9386 AccessibleContext ac = getCurrentAccessibleContext();
9387 if (ac instanceof AccessibleComponent) {
9388 return ((AccessibleComponent) ac).getFontMetrics(f);
9389 } else {
9390 Component c = getCurrentComponent();
9391 if (c != null) {
9392 return c.getFontMetrics(f);
9393 } else {
9394 return null;
9395 }
9396 }
9397 }
9398
9399 /**
9400 * Determines if the object is enabled.
9401 *
9402 * @return true if object is enabled; otherwise, false
9403 */
9404 public boolean isEnabled() {
9405 AccessibleContext ac = getCurrentAccessibleContext();
9406 if (ac instanceof AccessibleComponent) {
9407 return ((AccessibleComponent) ac).isEnabled();
9408 } else {
9409 Component c = getCurrentComponent();
9410 if (c != null) {
9411 return c.isEnabled();
9412 } else {
9413 return false;
9414 }
9415 }
9416 }
9417
9418 /**
9419 * Sets the enabled state of the object.
9420 *
9421 * @param b if true, enables this object; otherwise, disables it
9422 */
9423 public void setEnabled(boolean b) {
9424 AccessibleContext ac = getCurrentAccessibleContext();
9425 if (ac instanceof AccessibleComponent) {
9426 ((AccessibleComponent) ac).setEnabled(b);
9427 } else {
9428 Component c = getCurrentComponent();
9429 if (c != null) {
9430 c.setEnabled(b);
9431 }
9432 }
9433 }
9434
9435 /**
9436 * Determines if this object is visible. Note: this means that the
9437 * object intends to be visible; however, it may not in fact be
9438 * showing on the screen because one of the objects that this object
9439 * is contained by is not visible. To determine if an object is
9440 * showing on the screen, use <code>isShowing</code>.
9441 *
9442 * @return true if object is visible; otherwise, false
9443 */
9444 public boolean isVisible() {
9445 AccessibleContext ac = getCurrentAccessibleContext();
9446 if (ac instanceof AccessibleComponent) {
9447 return ((AccessibleComponent) ac).isVisible();
9448 } else {
9449 Component c = getCurrentComponent();
9450 if (c != null) {
9451 return c.isVisible();
9452 } else {
9453 return false;
9454 }
9455 }
9456 }
9457
9458 /**
9459 * Sets the visible state of the object.
9460 *
9461 * @param b if true, shows this object; otherwise, hides it
9462 */
9463 public void setVisible(boolean b) {
9464 AccessibleContext ac = getCurrentAccessibleContext();
9465 if (ac instanceof AccessibleComponent) {
9466 ((AccessibleComponent) ac).setVisible(b);
9467 } else {
9468 Component c = getCurrentComponent();
9469 if (c != null) {
9470 c.setVisible(b);
9471 }
9472 }
9473 }
9474
9475 /**
9476 * Determines if the object is showing. This is determined
9477 * by checking the visibility of the object and ancestors
9478 * of the object. Note: this will return true even if the
9479 * object is obscured by another (for example,
9480 * it happens to be underneath a menu that was pulled down).
9481 *
9482 * @return true if the object is showing; otherwise, false
9483 */
9484 public boolean isShowing() {
9485 AccessibleContext ac = getCurrentAccessibleContext();
9486 if (ac instanceof AccessibleComponent) {
9487 if (ac.getAccessibleParent() != null) {
9488 return ((AccessibleComponent) ac).isShowing();
9489 } else {
9490 // Fixes 4529616 - AccessibleJTableCell.isShowing()
9491 // returns false when the cell on the screen
9492 // if no parent
9493 return isVisible();
9494 }
9495 } else {
9496 Component c = getCurrentComponent();
9497 if (c != null) {
9498 return c.isShowing();
9499 } else {
9500 return false;
9501 }
9502 }
9503 }
9504
9505 /**
9506 * Checks whether the specified point is within this
9507 * object's bounds, where the point's x and y coordinates
9508 * are defined to be relative to the coordinate system of
9509 * the object.
9510 *
9511 * @param p the <code>Point</code> relative to the
9512 * coordinate system of the object
9513 * @return true if object contains <code>Point</code>;
9514 * otherwise false
9515 */
9516 public boolean contains(Point p) {
9517 AccessibleContext ac = getCurrentAccessibleContext();
9518 if (ac instanceof AccessibleComponent) {
9519 Rectangle r = ((AccessibleComponent) ac).getBounds();
9520 return r.contains(p);
9521 } else {
9522 Component c = getCurrentComponent();
9523 if (c != null) {
9524 Rectangle r = c.getBounds();
9525 return r.contains(p);
9526 } else {
9527 return getBounds().contains(p);
9528 }
9529 }
9530 }
9531
9532 /**
9533 * Returns the location of the object on the screen.
9534 *
9535 * @return location of object on screen -- can be
9536 * <code>null</code> if this object is not on the screen
9537 */
9538 public Point getLocationOnScreen() {
9539 if (parent != null && parent.isShowing()) {
9540 Point parentLocation = parent.getLocationOnScreen();
9541 Point componentLocation = getLocation();
9542 componentLocation.translate(parentLocation.x, parentLocation.y);
9543 return componentLocation;
9544 } else {
9545 return null;
9546 }
9547 }
9548
9549 /**
9550 * Gets the location of the object relative to the parent
9551 * in the form of a point specifying the object's
9552 * top-left corner in the screen's coordinate space.
9553 *
9554 * @return an instance of <code>Point</code> representing
9555 * the top-left corner of the object's bounds in the
9556 * coordinate space of the screen; <code>null</code> if
9557 * this object or its parent are not on the screen
9558 */
9559 public Point getLocation() {
9560 if (parent != null) {
9561 Rectangle r = parent.getHeaderRect(column);
9562 if (r != null) {
9563 return r.getLocation();
9564 }
9565 }
9566 return null;
9567 }
9568
9569 /**
9570 * Sets the location of the object relative to the parent.
9571 * @param p the new position for the top-left corner
9572 * @see #getLocation
9573 */
9574 public void setLocation(Point p) {
9575 }
9576
9577 /**
9578 * Gets the bounds of this object in the form of a Rectangle object.
9579 * The bounds specify this object's width, height, and location
9580 * relative to its parent.
9581 *
9582 * @return A rectangle indicating this component's bounds; null if
9583 * this object is not on the screen.
9584 * @see #contains
9585 */
9586 public Rectangle getBounds() {
9587 if (parent != null) {
9588 return parent.getHeaderRect(column);
9589 } else {
9590 return null;
9591 }
9592 }
9593
9594 /**
9595 * Sets the bounds of this object in the form of a Rectangle object.
9596 * The bounds specify this object's width, height, and location
9597 * relative to its parent.
9598 *
9599 * @param r rectangle indicating this component's bounds
9600 * @see #getBounds
9601 */
9602 public void setBounds(Rectangle r) {
9603 AccessibleContext ac = getCurrentAccessibleContext();
9604 if (ac instanceof AccessibleComponent) {
9605 ((AccessibleComponent) ac).setBounds(r);
9606 } else {
9607 Component c = getCurrentComponent();
9608 if (c != null) {
9609 c.setBounds(r);
9610 }
9611 }
9612 }
9613
9614 /**
9615 * Returns the size of this object in the form of a Dimension object.
9616 * The height field of the Dimension object contains this object's
9617 * height, and the width field of the Dimension object contains this
9618 * object's width.
9619 *
9620 * @return A Dimension object that indicates the size of this component;
9621 * null if this object is not on the screen
9622 * @see #setSize
9623 */
9624 public Dimension getSize() {
9625 if (parent != null) {
9626 Rectangle r = parent.getHeaderRect(column);
9627 if (r != null) {
9628 return r.getSize();
9629 }
9630 }
9631 return null;
9632 }
9633
9634 /**
9635 * Resizes this object so that it has width and height.
9636 *
9637 * @param d The dimension specifying the new size of the object.
9638 * @see #getSize
9639 */
9640 public void setSize (Dimension d) {
9641 AccessibleContext ac = getCurrentAccessibleContext();
9642 if (ac instanceof AccessibleComponent) {
9643 ((AccessibleComponent) ac).setSize(d);
9644 } else {
9645 Component c = getCurrentComponent();
9646 if (c != null) {
9647 c.setSize(d);
9648 }
9649 }
9650 }
9651
9652 /**
9653 * Returns the Accessible child, if one exists, contained at the local
9654 * coordinate Point.
9655 *
9656 * @param p The point relative to the coordinate system of this object.
9657 * @return the Accessible, if it exists, at the specified location;
9658 * otherwise null
9659 */
9660 public Accessible getAccessibleAt(Point p) {
9661 AccessibleContext ac = getCurrentAccessibleContext();
9662 if (ac instanceof AccessibleComponent) {
9663 return ((AccessibleComponent) ac).getAccessibleAt(p);
9664 } else {
9665 return null;
9666 }
9667 }
9668
9669 /**
9670 * Returns whether this object can accept focus or not. Objects that
9671 * can accept focus will also have the AccessibleState.FOCUSABLE state
9672 * set in their AccessibleStateSets.
9673 *
9674 * @return true if object can accept focus; otherwise false
9675 * @see AccessibleContext#getAccessibleStateSet
9676 * @see AccessibleState#FOCUSABLE
9677 * @see AccessibleState#FOCUSED
9678 * @see AccessibleStateSet
9679 */
9680 @SuppressWarnings("deprecation")
9681 public boolean isFocusTraversable() {
9682 AccessibleContext ac = getCurrentAccessibleContext();
9683 if (ac instanceof AccessibleComponent) {
9684 return ((AccessibleComponent) ac).isFocusTraversable();
9685 } else {
9686 Component c = getCurrentComponent();
9687 if (c != null) {
9688 return c.isFocusTraversable();
9689 } else {
9690 return false;
9691 }
9692 }
9693 }
9694
9695 /**
9696 * Requests focus for this object. If this object cannot accept focus,
9697 * nothing will happen. Otherwise, the object will attempt to take
9698 * focus.
9699 * @see #isFocusTraversable
9700 */
9701 public void requestFocus() {
9702 AccessibleContext ac = getCurrentAccessibleContext();
9703 if (ac instanceof AccessibleComponent) {
9704 ((AccessibleComponent) ac).requestFocus();
9705 } else {
9706 Component c = getCurrentComponent();
9707 if (c != null) {
9708 c.requestFocus();
9709 }
9710 }
9711 }
9712
9713 /**
9714 * Adds the specified focus listener to receive focus events from this
9715 * component.
9716 *
9717 * @param l the focus listener
9718 * @see #removeFocusListener
9719 */
9720 public void addFocusListener(FocusListener l) {
9721 AccessibleContext ac = getCurrentAccessibleContext();
9722 if (ac instanceof AccessibleComponent) {
9723 ((AccessibleComponent) ac).addFocusListener(l);
9724 } else {
9725 Component c = getCurrentComponent();
9726 if (c != null) {
9727 c.addFocusListener(l);
9728 }
9729 }
9730 }
9731
9732 /**
9733 * Removes the specified focus listener so it no longer receives focus
9734 * events from this component.
9735 *
9736 * @param l the focus listener
9737 * @see #addFocusListener
9738 */
9739 public void removeFocusListener(FocusListener l) {
9740 AccessibleContext ac = getCurrentAccessibleContext();
9741 if (ac instanceof AccessibleComponent) {
9742 ((AccessibleComponent) ac).removeFocusListener(l);
9743 } else {
9744 Component c = getCurrentComponent();
9745 if (c != null) {
9746 c.removeFocusListener(l);
9747 }
9748 }
9749 }
9750
9751 } // inner class AccessibleJTableHeaderCell
9752
9753 } // inner class AccessibleJTable
9754
9755 } // End of Class JTable