       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 &lt; 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&trade;
     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() &amp;&amp;
    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         return selectionModel.getSelectedIndices();

    2272     }
    2273
    2274     /**
    2275      * Returns the indices of all selected columns.
    2276      *
    2277      * @return an array of integers containing the indices of all selected columns,
    2278      *         or an empty array if no column is selected
    2279      * @see #getSelectedColumn
    2280      */
    2281     @BeanProperty(bound = false)
    2282     public int[] getSelectedColumns() {
    2283         return columnModel.getSelectedColumns();
    2284     }
    2285
    2286     /**
    2287      * Returns the number of selected rows.
    2288      *
    2289      * @return the number of selected rows, 0 if no rows are selected
    2290      */
    2291     @BeanProperty(bound = false)
    2292     public int getSelectedRowCount() {
    2293         return selectionModel.getSelectedItemsCount();

    2294     }
    2295
    2296     /**
    2297      * Returns the number of selected columns.
    2298      *
    2299      * @return the number of selected columns, 0 if no columns are selected
    2300      */
    2301     @BeanProperty(bound = false)
    2302     public int getSelectedColumnCount() {
    2303         return columnModel.getSelectedColumnCount();
    2304     }
    2305
    2306     /**
    2307      * Returns true if the specified index is in the valid range of rows,
    2308      * and the row at that index is selected.
    2309      *
    2310      * @param row a row in the row model
    2311      * @return true if <code>row</code> is a valid index and the row at
    2312      *              that index is selected (where 0 is the first row)
    2313      */
    2314     public boolean isRowSelected(int row) {
    2315         return selectionModel.isSelectedIndex(row);
    2316     }
    2317
    2318     /**
    2319      * Returns true if the specified index is in the valid range of columns,
    2320      * and the column at that index is selected.
    2321      *
    2322      * @param   column   the column in the column model
    2323      * @return true if <code>column</code> is a valid index and the column at
    2324      *              that index is selected (where 0 is the first column)
    2325      */
    2326     public boolean isColumnSelected(int column) {
    2327         return columnModel.getSelectionModel().isSelectedIndex(column);
    2328     }
    2329
    2330     /**
    2331      * Returns true if the specified indices are in the valid range of rows
    2332      * and columns and the cell at the specified position is selected.
    2333      * @param row   the row being queried
    2334      * @param column  the column being queried
    2335      *
    2336      * @return true if <code>row</code> and <code>column</code> are valid indices
    2337      *              and the cell at index <code>(row, column)</code> is selected,
    2338      *              where the first row and first column are at index 0
    2339      */
    2340     public boolean isCellSelected(int row, int column) {
    2341         if (!getRowSelectionAllowed() && !getColumnSelectionAllowed()) {
    2342             return false;
    2343         }
    2344         return (!getRowSelectionAllowed() || isRowSelected(row)) &&
    2345                (!getColumnSelectionAllowed() || isColumnSelected(column));
    2346     }
    2347
    2348     private void changeSelectionModel(ListSelectionModel sm, int index,
    2349                                       boolean toggle, boolean extend, boolean selected,
    2350                                       int anchor, boolean anchorSelected) {
    2351         if (extend) {
    2352             if (toggle) {
    2353                 if (anchorSelected) {
    2354                     sm.addSelectionInterval(anchor, index);
    2355                 } else {
    2356                     sm.removeSelectionInterval(anchor, index);
    2357                     // this is a Windows-only behavior that we want for file lists
    2358                     if (Boolean.TRUE == getClientProperty("Table.isFileList")) {
    2359                         sm.addSelectionInterval(index, index);
    2360                         sm.setAnchorSelectionIndex(anchor);
    2361                     }
    2362                 }
    2363             }
    2364             else {
    2365                 sm.setSelectionInterval(anchor, index);
    2366             }
    2367         }
    2368         else {
    2369             if (toggle) {
    2370                 if (selected) {
    2371                     sm.removeSelectionInterval(index, index);
    2372                 }
    2373                 else {
    2374                     sm.addSelectionInterval(index, index);
    2375                 }
    2376             }
    2377             else {
    2378                 sm.setSelectionInterval(index, index);
    2379             }
    2380         }
    2381     }
    2382
    2383     /**
    2384      * Updates the selection models of the table, depending on the state of the
    2385      * two flags: <code>toggle</code> and <code>extend</code>. Most changes
    2386      * to the selection that are the result of keyboard or mouse events received
    2387      * by the UI are channeled through this method so that the behavior may be
    2388      * overridden by a subclass. Some UIs may need more functionality than
    2389      * this method provides, such as when manipulating the lead for discontiguous
    2390      * selection, and may not call into this method for some selection changes.
    2391      * <p>
    2392      * This implementation uses the following conventions:
    2393      * <ul>
    2394      * <li> <code>toggle</code>: <em>false</em>, <code>extend</code>: <em>false</em>.
    2395      *      Clear the previous selection and ensure the new cell is selected.
    2396      * <li> <code>toggle</code>: <em>false</em>, <code>extend</code>: <em>true</em>.
    2397      *      Extend the previous selection from the anchor to the specified cell,
    2398      *      clearing all other selections.
    2399      * <li> <code>toggle</code>: <em>true</em>, <code>extend</code>: <em>false</em>.
    2400      *      If the specified cell is selected, deselect it. If it is not selected, select it.
    2401      * <li> <code>toggle</code>: <em>true</em>, <code>extend</code>: <em>true</em>.
    2402      *      Apply the selection state of the anchor to all cells between it and the
    2403      *      specified cell.
    2404      * </ul>
    2405      * @param  rowIndex   affects the selection at <code>row</code>
    2406      * @param  columnIndex  affects the selection at <code>column</code>
    2407      * @param  toggle  see description above
    2408      * @param  extend  if true, extend the current selection
    2409      *
    2410      * @since 1.3
    2411      */
    2412     public void changeSelection(int rowIndex, int columnIndex, boolean toggle, boolean extend) {
    2413         ListSelectionModel rsm = getSelectionModel();
    2414         ListSelectionModel csm = getColumnModel().getSelectionModel();
    2415
    2416         int anchorRow = getAdjustedIndex(rsm.getAnchorSelectionIndex(), true);
    2417         int anchorCol = getAdjustedIndex(csm.getAnchorSelectionIndex(), false);
    2418
    2419         boolean anchorSelected = true;
    2420
    2421         if (anchorRow == -1) {
    2422             if (getRowCount() > 0) {
    2423                 anchorRow = 0;
    2424             }
    2425             anchorSelected = false;
    2426         }
    2427
    2428         if (anchorCol == -1) {
    2429             if (getColumnCount() > 0) {
    2430                 anchorCol = 0;
    2431             }
    2432             anchorSelected = false;
    2433         }
    2434
    2435         // Check the selection here rather than in each selection model.
    2436         // This is significant in cell selection mode if we are supposed
    2437         // to be toggling the selection. In this case it is better to
    2438         // ensure that the cell's selection state will indeed be changed.
    2439         // If this were done in the code for the selection model it
    2440         // might leave a cell in selection state if the row was
    2441         // selected but the column was not - as it would toggle them both.
    2442         boolean selected = isCellSelected(rowIndex, columnIndex);
    2443         anchorSelected = anchorSelected && isCellSelected(anchorRow, anchorCol);
    2444
    2445         changeSelectionModel(csm, columnIndex, toggle, extend, selected,
    2446                              anchorCol, anchorSelected);
    2447         changeSelectionModel(rsm, rowIndex, toggle, extend, selected,
    2448                              anchorRow, anchorSelected);
    2449
    2450         // Scroll after changing the selection as blit scrolling is immediate,
    2451         // so that if we cause the repaint after the scroll we end up painting
    2452         // everything!
    2453         if (getAutoscrolls()) {
    2454             Rectangle cellRect = getCellRect(rowIndex, columnIndex, false);
    2455             if (cellRect != null) {
    2456                 scrollRectToVisible(cellRect);
    2457             }
    2458         }
    2459     }
    2460
    2461     /**
    2462      * Returns the foreground color for selected cells.
    2463      *
    2464      * @return the <code>Color</code> object for the foreground property
    2465      * @see #setSelectionForeground
    2466      * @see #setSelectionBackground
    2467      */
    2468     public Color getSelectionForeground() {
    2469         return selectionForeground;
    2470     }
    2471
    2472     /**
    2473      * Sets the foreground color for selected cells.  Cell renderers
    2474      * can use this color to render text and graphics for selected
    2475      * cells.
    2476      * <p>
    2477      * The default value of this property is defined by the look
    2478      * and feel implementation.
    2479      * <p>
    2480      * This is a <a href="http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html">JavaBeans</a> bound property.
    2481      *
    2482      * @param selectionForeground  the <code>Color</code> to use in the foreground
    2483      *                             for selected list items
    2484      * @see #getSelectionForeground
    2485      * @see #setSelectionBackground
    2486      * @see #setForeground
    2487      * @see #setBackground
    2488      * @see #setFont
    2489      */
    2490     @BeanProperty(description
    2491             = "A default foreground color for selected cells.")
    2492     public void setSelectionForeground(Color selectionForeground) {
    2493         Color old = this.selectionForeground;
    2494         this.selectionForeground = selectionForeground;
    2495         firePropertyChange("selectionForeground", old, selectionForeground);
    2496         repaint();
    2497     }
    2498
    2499     /**
    2500      * Returns the background color for selected cells.
    2501      *
    2502      * @return the <code>Color</code> used for the background of selected list items
    2503      * @see #setSelectionBackground
    2504      * @see #setSelectionForeground
    2505      */
    2506     public Color getSelectionBackground() {
    2507         return selectionBackground;
    2508     }
    2509
    2510     /**
    2511      * Sets the background color for selected cells.  Cell renderers
    2512      * can use this color to the fill selected cells.
    2513      * <p>
    2514      * The default value of this property is defined by the look
    2515      * and feel implementation.
    2516      * <p>
    2517      * This is a <a href="http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html">JavaBeans</a> bound property.
    2518      *
    2519      * @param selectionBackground  the <code>Color</code> to use for the background
    2520      *                             of selected cells
    2521      * @see #getSelectionBackground
    2522      * @see #setSelectionForeground
    2523      * @see #setForeground
    2524      * @see #setBackground
    2525      * @see #setFont
    2526      */
    2527     @BeanProperty(description
    2528             = "A default background color for selected cells.")
    2529     public void setSelectionBackground(Color selectionBackground) {
    2530         Color old = this.selectionBackground;
    2531         this.selectionBackground = selectionBackground;
    2532         firePropertyChange("selectionBackground", old, selectionBackground);
    2533         repaint();
    2534     }
    2535
    2536     /**
    2537      * Returns the <code>TableColumn</code> object for the column in the table
    2538      * whose identifier is equal to <code>identifier</code>, when compared using
    2539      * <code>equals</code>.
    2540      *
    2541      * @return  the <code>TableColumn</code> object that matches the identifier
    2542      * @exception IllegalArgumentException      if <code>identifier</code> is <code>null</code> or no <code>TableColumn</code> has this identifier
    2543      *
    2544      * @param   identifier                      the identifier object
    2545      */
    2546     public TableColumn getColumn(Object identifier) {
    2547         TableColumnModel cm = getColumnModel();
    2548         int columnIndex = cm.getColumnIndex(identifier);
    2549         return cm.getColumn(columnIndex);
    2550     }
    2551
    2552 //
    2553 // Informally implement the TableModel interface.
    2554 //
    2555
    2556     /**
    2557      * Maps the index of the column in the view at
    2558      * <code>viewColumnIndex</code> to the index of the column
    2559      * in the table model.  Returns the index of the corresponding
    2560      * column in the model.  If <code>viewColumnIndex</code>
    2561      * is less than zero, returns <code>viewColumnIndex</code>.
    2562      *
    2563      * @param   viewColumnIndex     the index of the column in the view
    2564      * @return  the index of the corresponding column in the model
    2565      *
    2566      * @see #convertColumnIndexToView
    2567      */
    2568     public int convertColumnIndexToModel(int viewColumnIndex) {
    2569         return SwingUtilities2.convertColumnIndexToModel(
    2570                 getColumnModel(), viewColumnIndex);
    2571     }
    2572
    2573     /**
    2574      * Maps the index of the column in the table model at
    2575      * <code>modelColumnIndex</code> to the index of the column
    2576      * in the view.  Returns the index of the
    2577      * corresponding column in the view; returns -1 if this column is not
    2578      * being displayed.  If <code>modelColumnIndex</code> is less than zero,
    2579      * returns <code>modelColumnIndex</code>.
    2580      *
    2581      * @param   modelColumnIndex     the index of the column in the model
    2582      * @return   the index of the corresponding column in the view
    2583      *
    2584      * @see #convertColumnIndexToModel
    2585      */
    2586     public int convertColumnIndexToView(int modelColumnIndex) {
    2587         return SwingUtilities2.convertColumnIndexToView(
    2588                 getColumnModel(), modelColumnIndex);
    2589     }
    2590
    2591     /**
    2592      * Maps the index of the row in terms of the
    2593      * <code>TableModel</code> to the view.  If the contents of the
    2594      * model are not sorted the model and view indices are the same.
    2595      *
    2596      * @param modelRowIndex the index of the row in terms of the model
    2597      * @return the index of the corresponding row in the view, or -1 if
    2598      *         the row isn't visible
    2599      * @throws IndexOutOfBoundsException if sorting is enabled and passed an
    2600      *         index outside the number of rows of the <code>TableModel</code>
    2601      * @see javax.swing.table.TableRowSorter
    2602      * @since 1.6
    2603      */
    2604     public int convertRowIndexToView(int modelRowIndex) {
    2605         RowSorter<?> sorter = getRowSorter();
    2606         if (sorter != null) {
    2607             return sorter.convertRowIndexToView(modelRowIndex);
    2608         }
    2609         return modelRowIndex;
    2610     }
    2611
    2612     /**
    2613      * Maps the index of the row in terms of the view to the
    2614      * underlying <code>TableModel</code>.  If the contents of the
    2615      * model are not sorted the model and view indices are the same.
    2616      *
    2617      * @param viewRowIndex the index of the row in the view
    2618      * @return the index of the corresponding row in the model
    2619      * @throws IndexOutOfBoundsException if sorting is enabled and passed an
    2620      *         index outside the range of the <code>JTable</code> as
    2621      *         determined by the method <code>getRowCount</code>
    2622      * @see javax.swing.table.TableRowSorter
    2623      * @see #getRowCount
    2624      * @since 1.6
    2625      */
    2626     public int convertRowIndexToModel(int viewRowIndex) {
    2627         RowSorter<?> sorter = getRowSorter();
    2628         if (sorter != null) {
    2629             return sorter.convertRowIndexToModel(viewRowIndex);
    2630         }
    2631         return viewRowIndex;
    2632     }
    2633
    2634     /**
    2635      * Returns the number of rows that can be shown in the
    2636      * <code>JTable</code>, given unlimited space.  If a
    2637      * <code>RowSorter</code> with a filter has been specified, the
    2638      * number of rows returned may differ from that of the underlying
    2639      * <code>TableModel</code>.
    2640      *
    2641      * @return the number of rows shown in the <code>JTable</code>
    2642      * @see #getColumnCount
    2643      */
    2644     @BeanProperty(bound = false)
    2645     public int getRowCount() {
    2646         RowSorter<?> sorter = getRowSorter();
    2647         if (sorter != null) {
    2648             return sorter.getViewRowCount();
    2649         }
    2650         return getModel().getRowCount();
    2651     }
    2652
    2653     /**
    2654      * Returns the number of columns in the column model. Note that this may
    2655      * be different from the number of columns in the table model.
    2656      *
    2657      * @return  the number of columns in the table
    2658      * @see #getRowCount
    2659      * @see #removeColumn
    2660      */
    2661     @BeanProperty(bound = false)
    2662     public int getColumnCount() {
    2663         return getColumnModel().getColumnCount();
    2664     }
    2665
    2666     /**
    2667      * Returns the name of the column appearing in the view at
    2668      * column position <code>column</code>.
    2669      *
    2670      * @param  column    the column in the view being queried
    2671      * @return the name of the column at position <code>column</code>
    2672                         in the view where the first column is column 0
    2673      */
    2674     public String getColumnName(int column) {
    2675         return getModel().getColumnName(convertColumnIndexToModel(column));
    2676     }
    2677
    2678     /**
    2679      * Returns the type of the column appearing in the view at
    2680      * column position <code>column</code>.
    2681      *
    2682      * @param   column   the column in the view being queried
    2683      * @return the type of the column at position <code>column</code>
    2684      *          in the view where the first column is column 0
    2685      */
    2686     public Class<?> getColumnClass(int column) {
    2687         return getModel().getColumnClass(convertColumnIndexToModel(column));
    2688     }
    2689
    2690     /**
    2691      * Returns the cell value at <code>row</code> and <code>column</code>.
    2692      * <p>
    2693      * <b>Note</b>: The column is specified in the table view's display
    2694      *              order, and not in the <code>TableModel</code>'s column
    2695      *              order.  This is an important distinction because as the
    2696      *              user rearranges the columns in the table,
    2697      *              the column at a given index in the view will change.
    2698      *              Meanwhile the user's actions never affect the model's
    2699      *              column ordering.
    2700      *
    2701      * @param   row             the row whose value is to be queried
    2702      * @param   column          the column whose value is to be queried
    2703      * @return  the Object at the specified cell
    2704      */
    2705     public Object getValueAt(int row, int column) {
    2706         return getModel().getValueAt(convertRowIndexToModel(row),
    2707                                      convertColumnIndexToModel(column));
    2708     }
    2709
    2710     /**
    2711      * Sets the value for the cell in the table model at <code>row</code>
    2712      * and <code>column</code>.
    2713      * <p>
    2714      * <b>Note</b>: The column is specified in the table view's display
    2715      *              order, and not in the <code>TableModel</code>'s column
    2716      *              order.  This is an important distinction because as the
    2717      *              user rearranges the columns in the table,
    2718      *              the column at a given index in the view will change.
    2719      *              Meanwhile the user's actions never affect the model's
    2720      *              column ordering.
    2721      *
    2722      * <code>aValue</code> is the new value.
    2723      *
    2724      * @param   aValue          the new value
    2725      * @param   row             the row of the cell to be changed
    2726      * @param   column          the column of the cell to be changed
    2727      * @see #getValueAt
    2728      */
    2729     public void setValueAt(Object aValue, int row, int column) {
    2730         getModel().setValueAt(aValue, convertRowIndexToModel(row),
    2731                               convertColumnIndexToModel(column));
    2732     }
    2733
    2734     /**
    2735      * Returns true if the cell at <code>row</code> and <code>column</code>
    2736      * is editable.  Otherwise, invoking <code>setValueAt</code> on the cell
    2737      * will have no effect.
    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      *
    2748      * @param   row      the row whose value is to be queried
    2749      * @param   column   the column whose value is to be queried
    2750      * @return  true if the cell is editable
    2751      * @see #setValueAt
    2752      */
    2753     public boolean isCellEditable(int row, int column) {
    2754         return getModel().isCellEditable(convertRowIndexToModel(row),
    2755                                          convertColumnIndexToModel(column));
    2756     }
    2757 //
    2758 // Adding and removing columns in the view
    2759 //
    2760
    2761     /**
    2762      *  Appends <code>aColumn</code> to the end of the array of columns held by
    2763      *  this <code>JTable</code>'s column model.
    2764      *  If the column name of <code>aColumn</code> is <code>null</code>,
    2765      *  sets the column name of <code>aColumn</code> to the name
    2766      *  returned by <code>getModel().getColumnName()</code>.
    2767      *  <p>
    2768      *  To add a column to this <code>JTable</code> to display the
    2769      *  <code>modelColumn</code>'th column of data in the model with a
    2770      *  given <code>width</code>, <code>cellRenderer</code>,
    2771      *  and <code>cellEditor</code> you can use:
    2772      *  <pre>
    2773      *
    2774      *      addColumn(new TableColumn(modelColumn, width, cellRenderer, cellEditor));
    2775      *
    2776      *  </pre>
    2777      *  [Any of the <code>TableColumn</code> constructors can be used
    2778      *  instead of this one.]
    2779      *  The model column number is stored inside the <code>TableColumn</code>
    2780      *  and is used during rendering and editing to locate the appropriates
    2781      *  data values in the model. The model column number does not change
    2782      *  when columns are reordered in the view.
    2783      *
    2784      *  @param  aColumn         the <code>TableColumn</code> to be added
    2785      *  @see    #removeColumn
    2786      */
    2787     public void addColumn(TableColumn aColumn) {
    2788         if (aColumn.getHeaderValue() == null) {
    2789             int modelColumn = aColumn.getModelIndex();
    2790             String columnName = getModel().getColumnName(modelColumn);
    2791             aColumn.setHeaderValue(columnName);
    2792         }
    2793         getColumnModel().addColumn(aColumn);
    2794     }
    2795
    2796     /**
    2797      *  Removes <code>aColumn</code> from this <code>JTable</code>'s
    2798      *  array of columns.  Note: this method does not remove the column
    2799      *  of data from the model; it just removes the <code>TableColumn</code>
    2800      *  that was responsible for displaying it.
    2801      *
    2802      *  @param  aColumn         the <code>TableColumn</code> to be removed
    2803      *  @see    #addColumn
    2804      */
    2805     public void removeColumn(TableColumn aColumn) {
    2806         getColumnModel().removeColumn(aColumn);
    2807     }
    2808
    2809     /**
    2810      * Moves the column <code>column</code> to the position currently
    2811      * occupied by the column <code>targetColumn</code> in the view.
    2812      * The old column at <code>targetColumn</code> is
    2813      * shifted left or right to make room.
    2814      *
    2815      * @param   column                  the index of column to be moved
    2816      * @param   targetColumn            the new index of the column
    2817      */
    2818     public void moveColumn(int column, int targetColumn) {
    2819         getColumnModel().moveColumn(column, targetColumn);
    2820     }
    2821
    2822 //
    2823 // Cover methods for various models and helper methods
    2824 //
    2825
    2826     /**
    2827      * Returns the index of the column that <code>point</code> lies in,
    2828      * or -1 if the result is not in the range
    2829      * [0, <code>getColumnCount()</code>-1].
    2830      *
    2831      * @param   point   the location of interest
    2832      * @return  the index of the column that <code>point</code> lies in,
    2833      *          or -1 if the result is not in the range
    2834      *          [0, <code>getColumnCount()</code>-1]
    2835      * @see     #rowAtPoint
    2836      */
    2837     public int columnAtPoint(Point point) {
    2838         int x = point.x;
    2839         if( !getComponentOrientation().isLeftToRight() ) {
    2840             x = getWidth() - x - 1;
    2841         }
    2842         return getColumnModel().getColumnIndexAtX(x);
    2843     }
    2844
    2845     /**
    2846      * Returns the index of the row that <code>point</code> lies in,
    2847      * or -1 if the result is not in the range
    2848      * [0, <code>getRowCount()</code>-1].
    2849      *
    2850      * @param   point   the location of interest
    2851      * @return  the index of the row that <code>point</code> lies in,
    2852      *          or -1 if the result is not in the range
    2853      *          [0, <code>getRowCount()</code>-1]
    2854      * @see     #columnAtPoint
    2855      */
    2856     public int rowAtPoint(Point point) {
    2857         int y = point.y;
    2858         int result = (rowModel == null) ?  y/getRowHeight() : rowModel.getIndex(y);
    2859         if (result < 0) {
    2860             return -1;
    2861         }
    2862         else if (result >= getRowCount()) {
    2863             return -1;
    2864         }
    2865         else {
    2866             return result;
    2867         }
    2868     }
    2869
    2870     /**
    2871      * Returns a rectangle for the cell that lies at the intersection of
    2872      * <code>row</code> and <code>column</code>.
    2873      * If <code>includeSpacing</code> is true then the value returned
    2874      * has the full height and width of the row and column
    2875      * specified. If it is false, the returned rectangle is inset by the
    2876      * intercell spacing to return the true bounds of the rendering or
    2877      * editing component as it will be set during rendering.
    2878      * <p>
    2879      * If the column index is valid but the row index is less
    2880      * than zero the method returns a rectangle with the
    2881      * <code>y</code> and <code>height</code> values set appropriately
    2882      * and the <code>x</code> and <code>width</code> values both set
    2883      * to zero. In general, when either the row or column indices indicate a
    2884      * cell outside the appropriate range, the method returns a rectangle
    2885      * depicting the closest edge of the closest cell that is within
    2886      * the table's range. When both row and column indices are out
    2887      * of range the returned rectangle covers the closest
    2888      * point of the closest cell.
    2889      * <p>
    2890      * In all cases, calculations that use this method to calculate
    2891      * results along one axis will not fail because of anomalies in
    2892      * calculations along the other axis. When the cell is not valid
    2893      * the <code>includeSpacing</code> parameter is ignored.
    2894      *
    2895      * @param   row                   the row index where the desired cell
    2896      *                                is located
    2897      * @param   column                the column index where the desired cell
    2898      *                                is located in the display; this is not
    2899      *                                necessarily the same as the column index
    2900      *                                in the data model for the table; the
    2901      *                                {@link #convertColumnIndexToView(int)}
    2902      *                                method may be used to convert a data
    2903      *                                model column index to a display
    2904      *                                column index
    2905      * @param   includeSpacing        if false, return the true cell bounds -
    2906      *                                computed by subtracting the intercell
    2907      *                                spacing from the height and widths of
    2908      *                                the column and row models
    2909      *
    2910      * @return  the rectangle containing the cell at location
    2911      *          <code>row</code>,<code>column</code>
    2912      * @see #getIntercellSpacing
    2913      */
    2914     public Rectangle getCellRect(int row, int column, boolean includeSpacing) {
    2915         Rectangle r = new Rectangle();
    2916         boolean valid = true;
    2917         if (row < 0) {
    2918             // y = height = 0;
    2919             valid = false;
    2920         }
    2921         else if (row >= getRowCount()) {
    2922             r.y = getHeight();
    2923             valid = false;
    2924         }
    2925         else {
    2926             r.height = getRowHeight(row);
    2927             r.y = (rowModel == null) ? row * r.height : rowModel.getPosition(row);
    2928         }
    2929
    2930         if (column < 0) {
    2931             if( !getComponentOrientation().isLeftToRight() ) {
    2932                 r.x = getWidth();
    2933             }
    2934             // otherwise, x = width = 0;
    2935             valid = false;
    2936         }
    2937         else if (column >= getColumnCount()) {
    2938             if( getComponentOrientation().isLeftToRight() ) {
    2939                 r.x = getWidth();
    2940             }
    2941             // otherwise, x = width = 0;
    2942             valid = false;
    2943         }
    2944         else {
    2945             TableColumnModel cm = getColumnModel();
    2946             if( getComponentOrientation().isLeftToRight() ) {
    2947                 for(int i = 0; i < column; i++) {
    2948                     r.x += cm.getColumn(i).getWidth();
    2949                 }
    2950             } else {
    2951                 for(int i = cm.getColumnCount()-1; i > column; i--) {
    2952                     r.x += cm.getColumn(i).getWidth();
    2953                 }
    2954             }
    2955             r.width = cm.getColumn(column).getWidth();
    2956         }
    2957
    2958         if (valid && !includeSpacing) {
    2959             // Bound the margins by their associated dimensions to prevent
    2960             // returning bounds with negative dimensions.
    2961             int rm = Math.min(getRowMargin(), r.height);
    2962             int cm = Math.min(getColumnModel().getColumnMargin(), r.width);
    2963             // This is not the same as grow(), it rounds differently.
    2964             r.setBounds(r.x + cm/2, r.y + rm/2, r.width - cm, r.height - rm);
    2965         }
    2966         return r;
    2967     }
    2968
    2969     private int viewIndexForColumn(TableColumn aColumn) {
    2970         TableColumnModel cm = getColumnModel();
    2971         for (int column = 0; column < cm.getColumnCount(); column++) {
    2972             if (cm.getColumn(column) == aColumn) {
    2973                 return column;
    2974             }
    2975         }
    2976         return -1;
    2977     }
    2978
    2979     /**
    2980      * Causes this table to lay out its rows and columns.  Overridden so
    2981      * that columns can be resized to accommodate a change in the size of
    2982      * a containing parent.
    2983      * Resizes one or more of the columns in the table
    2984      * so that the total width of all of this <code>JTable</code>'s
    2985      * columns is equal to the width of the table.
    2986      * <p>
    2987      * Before the layout begins the method gets the
    2988      * <code>resizingColumn</code> of the <code>tableHeader</code>.
    2989      * When the method is called as a result of the resizing of an enclosing window,
    2990      * the <code>resizingColumn</code> is <code>null</code>. This means that resizing
    2991      * has taken place "outside" the <code>JTable</code> and the change -
    2992      * or "delta" - should be distributed to all of the columns regardless
    2993      * of this <code>JTable</code>'s automatic resize mode.
    2994      * <p>
    2995      * If the <code>resizingColumn</code> is not <code>null</code>, it is one of
    2996      * the columns in the table that has changed size rather than
    2997      * the table itself. In this case the auto-resize modes govern
    2998      * the way the extra (or deficit) space is distributed
    2999      * amongst the available columns.
    3000      * <p>
    3001      * The modes are:
    3002      * <ul>
    3003      * <li>  AUTO_RESIZE_OFF: Don't automatically adjust the column's
    3004      * widths at all. Use a horizontal scrollbar to accommodate the
    3005      * columns when their sum exceeds the width of the
    3006      * <code>Viewport</code>.  If the <code>JTable</code> is not
    3007      * enclosed in a <code>JScrollPane</code> this may
    3008      * leave parts of the table invisible.
    3009      * <li>  AUTO_RESIZE_NEXT_COLUMN: Use just the column after the
    3010      * resizing column. This results in the "boundary" or divider
    3011      * between adjacent cells being independently adjustable.
    3012      * <li>  AUTO_RESIZE_SUBSEQUENT_COLUMNS: Use all columns after the
    3013      * one being adjusted to absorb the changes.  This is the
    3014      * default behavior.
    3015      * <li>  AUTO_RESIZE_LAST_COLUMN: Automatically adjust the
    3016      * size of the last column only. If the bounds of the last column
    3017      * prevent the desired size from being allocated, set the
    3018      * width of the last column to the appropriate limit and make
    3019      * no further adjustments.
    3020      * <li>  AUTO_RESIZE_ALL_COLUMNS: Spread the delta amongst all the columns
    3021      * in the <code>JTable</code>, including the one that is being
    3022      * adjusted.
    3023      * </ul>
    3024      * <p>
    3025      * <b>Note:</b> When a <code>JTable</code> makes adjustments
    3026      *   to the widths of the columns it respects their minimum and
    3027      *   maximum values absolutely.  It is therefore possible that,
    3028      *   even after this method is called, the total width of the columns
    3029      *   is still not equal to the width of the table. When this happens
    3030      *   the <code>JTable</code> does not put itself
    3031      *   in AUTO_RESIZE_OFF mode to bring up a scroll bar, or break other
    3032      *   commitments of its current auto-resize mode -- instead it
    3033      *   allows its bounds to be set larger (or smaller) than the total of the
    3034      *   column minimum or maximum, meaning, either that there
    3035      *   will not be enough room to display all of the columns, or that the
    3036      *   columns will not fill the <code>JTable</code>'s bounds.
    3037      *   These respectively, result in the clipping of some columns
    3038      *   or an area being painted in the <code>JTable</code>'s
    3039      *   background color during painting.
    3040      * <p>
    3041      *   The mechanism for distributing the delta amongst the available
    3042      *   columns is provided in a private method in the <code>JTable</code>
    3043      *   class:
    3044      * <pre>
    3045      *   adjustSizes(long targetSize, final Resizable3 r, boolean inverse)
    3046      * </pre>
    3047      *   an explanation of which is provided in the following section.
    3048      *   <code>Resizable3</code> is a private
    3049      *   interface that allows any data structure containing a collection
    3050      *   of elements with a size, preferred size, maximum size and minimum size
    3051      *   to have its elements manipulated by the algorithm.
    3052      *
    3053      * <H3> Distributing the delta </H3>
    3054      *
    3055      * <H4> Overview </H4>
    3056      * <P>
    3057      * Call "DELTA" the difference between the target size and the
    3058      * sum of the preferred sizes of the elements in r. The individual
    3059      * sizes are calculated by taking the original preferred
    3060      * sizes and adding a share of the DELTA - that share being based on
    3061      * how far each preferred size is from its limiting bound (minimum or
    3062      * maximum).
    3063      *
    3064      * <H4>Definition</H4>
    3065      * <P>
    3066      * Call the individual constraints min[i], max[i], and pref[i].
    3067      * <p>
    3068      * Call their respective sums: MIN, MAX, and PREF.
    3069      * <p>
    3070      * Each new size will be calculated using:
    3071      *
    3072      * <pre>
    3073      *          size[i] = pref[i] + delta[i]
    3074      * </pre>
    3075      * where each individual delta[i] is calculated according to:
    3076      * <p>
    3077      * If (DELTA &lt; 0) we are in shrink mode where:
    3078      *
    3079      * <PRE>
    3080      *                        DELTA
    3081      *          delta[i] = ------------ * (pref[i] - min[i])
    3082      *                     (PREF - MIN)
    3083      * </PRE>
    3084      * If (DELTA &gt; 0) we are in expand mode where:
    3085      *
    3086      * <PRE>
    3087      *                        DELTA
    3088      *          delta[i] = ------------ * (max[i] - pref[i])
    3089      *                      (MAX - PREF)
    3090      * </PRE>
    3091      * <P>
    3092      * The overall effect is that the total size moves that same percentage,
    3093      * k, towards the total minimum or maximum and that percentage guarantees
    3094      * accommodation of the required space, DELTA.
    3095      *
    3096      * <H4>Details</H4>
    3097      * <P>
    3098      * Naive evaluation of the formulae presented here would be subject to
    3099      * the aggregated rounding errors caused by doing this operation in finite
    3100      * precision (using ints). To deal with this, the multiplying factor above,
    3101      * is constantly recalculated and this takes account of the rounding
    3102      * errors in the previous iterations. The result is an algorithm that
    3103      * produces a set of integers whose values exactly sum to the supplied
    3104      * <code>targetSize</code>, and does so by spreading the rounding
    3105      * errors evenly over the given elements.
    3106      *
    3107      * <H4>When the MAX and MIN bounds are hit</H4>
    3108      * <P>
    3109      * When <code>targetSize</code> is outside the [MIN, MAX] range,
    3110      * the algorithm sets all sizes to their appropriate limiting value
    3111      * (maximum or minimum).
    3112      *
    3113      */
    3114     public void doLayout() {
    3115         TableColumn resizingColumn = getResizingColumn();
    3116         if (resizingColumn == null) {
    3117             setWidthsFromPreferredWidths(false);
    3118         }
    3119         else {
    3120             // JTable behaves like a layout manger - but one in which the
    3121             // user can come along and dictate how big one of the children
    3122             // (columns) is supposed to be.
    3123
    3124             // A column has been resized and JTable may need to distribute
    3125             // any overall delta to other columns, according to the resize mode.
    3126             int columnIndex = viewIndexForColumn(resizingColumn);
    3127             int delta = getWidth() - getColumnModel().getTotalColumnWidth();
    3128             accommodateDelta(columnIndex, delta);
    3129             delta = getWidth() - getColumnModel().getTotalColumnWidth();
    3130
    3131             // If the delta cannot be completely accomodated, then the
    3132             // resizing column will have to take any remainder. This means
    3133             // that the column is not being allowed to take the requested
    3134             // width. This happens under many circumstances: For example,
    3135             // AUTO_RESIZE_NEXT_COLUMN specifies that any delta be distributed
    3136             // to the column after the resizing column. If one were to attempt
    3137             // to resize the last column of the table, there would be no
    3138             // columns after it, and hence nowhere to distribute the delta.
    3139             // It would then be given entirely back to the resizing column,
    3140             // preventing it from changing size.
    3141             if (delta != 0) {
    3142                 resizingColumn.setWidth(resizingColumn.getWidth() + delta);
    3143             }
    3144
    3145             // At this point the JTable has to work out what preferred sizes
    3146             // would have resulted in the layout the user has chosen.
    3147             // Thereafter, during window resizing etc. it has to work off
    3148             // the preferred sizes as usual - the idea being that, whatever
    3149             // the user does, everything stays in synch and things don't jump
    3150             // around.
    3151             setWidthsFromPreferredWidths(true);
    3152         }
    3153
    3154         super.doLayout();
    3155     }
    3156
    3157     private TableColumn getResizingColumn() {
    3158         return (tableHeader == null) ? null
    3159                                      : tableHeader.getResizingColumn();
    3160     }
    3161
    3162     /**
    3163      * Sizes the table columns to fit the available space.
    3164      *
    3165      * @param lastColumnOnly determines whether to resize last column only
    3166      * @deprecated As of Swing version 1.0.3,
    3167      * replaced by <code>doLayout()</code>.
    3168      * @see #doLayout
    3169      */
    3170     @Deprecated
    3171     public void sizeColumnsToFit(boolean lastColumnOnly) {
    3172         int oldAutoResizeMode = autoResizeMode;
    3173         setAutoResizeMode(lastColumnOnly ? AUTO_RESIZE_LAST_COLUMN
    3174                                          : AUTO_RESIZE_ALL_COLUMNS);
    3175         sizeColumnsToFit(-1);
    3176         setAutoResizeMode(oldAutoResizeMode);
    3177     }
    3178
    3179     /**
    3180      * Obsolete as of Java 2 platform v1.4.  Please use the
    3181      * <code>doLayout()</code> method instead.
    3182      * @param resizingColumn    the column whose resizing made this adjustment
    3183      *                          necessary or -1 if there is no such column
    3184      * @see  #doLayout
    3185      */
    3186     public void sizeColumnsToFit(int resizingColumn) {
    3187         if (resizingColumn == -1) {
    3188             setWidthsFromPreferredWidths(false);
    3189         }
    3190         else {
    3191             if (autoResizeMode == AUTO_RESIZE_OFF) {
    3192                 TableColumn aColumn = getColumnModel().getColumn(resizingColumn);
    3193                 aColumn.setPreferredWidth(aColumn.getWidth());
    3194             }
    3195             else {
    3196                 int delta = getWidth() - getColumnModel().getTotalColumnWidth();
    3197                 accommodateDelta(resizingColumn, delta);
    3198                 setWidthsFromPreferredWidths(true);
    3199             }
    3200         }
    3201     }
    3202
    3203     private void setWidthsFromPreferredWidths(final boolean inverse) {
    3204         int totalWidth     = getWidth();
    3205         int totalPreferred = getPreferredSize().width;
    3206         int target = !inverse ? totalWidth : totalPreferred;
    3207
    3208         final TableColumnModel cm = columnModel;
    3209         Resizable3 r = new Resizable3() {
    3210             public int  getElementCount()      { return cm.getColumnCount(); }
    3211             public int  getLowerBoundAt(int i) { return cm.getColumn(i).getMinWidth(); }
    3212             public int  getUpperBoundAt(int i) { return cm.getColumn(i).getMaxWidth(); }
    3213             public int  getMidPointAt(int i)  {
    3214                 if (!inverse) {
    3215                     return cm.getColumn(i).getPreferredWidth();
    3216                 }
    3217                 else {
    3218                     return cm.getColumn(i).getWidth();
    3219                 }
    3220             }
    3221             public void setSizeAt(int s, int i) {
    3222                 if (!inverse) {
    3223                     cm.getColumn(i).setWidth(s);
    3224                 }
    3225                 else {
    3226                     cm.getColumn(i).setPreferredWidth(s);
    3227                 }
    3228             }
    3229         };
    3230
    3231         adjustSizes(target, r, inverse);
    3232     }
    3233
    3234
    3235     // Distribute delta over columns, as indicated by the autoresize mode.
    3236     private void accommodateDelta(int resizingColumnIndex, int delta) {
    3237         int columnCount = getColumnCount();
    3238         int from = resizingColumnIndex;
    3239         int to;
    3240
    3241         // Use the mode to determine how to absorb the changes.
    3242         switch(autoResizeMode) {
    3243             case AUTO_RESIZE_NEXT_COLUMN:
    3244                 from = from + 1;
    3245                 to = Math.min(from + 1, columnCount); break;
    3246             case AUTO_RESIZE_SUBSEQUENT_COLUMNS:
    3247                 from = from + 1;
    3248                 to = columnCount; break;
    3249             case AUTO_RESIZE_LAST_COLUMN:
    3250                 from = columnCount - 1;
    3251                 to = from + 1; break;
    3252             case AUTO_RESIZE_ALL_COLUMNS:
    3253                 from = 0;
    3254                 to = columnCount; break;
    3255             default:
    3256                 return;
    3257         }
    3258
    3259         final int start = from;
    3260         final int end = to;
    3261         final TableColumnModel cm = columnModel;
    3262         Resizable3 r = new Resizable3() {
    3263             public int  getElementCount()       { return end-start; }
    3264             public int  getLowerBoundAt(int i)  { return cm.getColumn(i+start).getMinWidth(); }
    3265             public int  getUpperBoundAt(int i)  { return cm.getColumn(i+start).getMaxWidth(); }
    3266             public int  getMidPointAt(int i)    { return cm.getColumn(i+start).getWidth(); }
    3267             public void setSizeAt(int s, int i) {        cm.getColumn(i+start).setWidth(s); }
    3268         };
    3269
    3270         int totalWidth = 0;
    3271         for(int i = from; i < to; i++) {
    3272             TableColumn aColumn = columnModel.getColumn(i);
    3273             int input = aColumn.getWidth();
    3274             totalWidth = totalWidth + input;
    3275         }
    3276
    3277         adjustSizes(totalWidth + delta, r, false);
    3278     }
    3279
    3280     private interface Resizable2 {
    3281         public int  getElementCount();
    3282         public int  getLowerBoundAt(int i);
    3283         public int  getUpperBoundAt(int i);
    3284         public void setSizeAt(int newSize, int i);
    3285     }
    3286
    3287     private interface Resizable3 extends Resizable2 {
    3288         public int  getMidPointAt(int i);
    3289     }
    3290
    3291
    3292     private void adjustSizes(long target, final Resizable3 r, boolean inverse) {
    3293         int N = r.getElementCount();
    3294         long totalPreferred = 0;
    3295         for(int i = 0; i < N; i++) {
    3296             totalPreferred += r.getMidPointAt(i);
    3297         }
    3298         Resizable2 s;
    3299         if ((target < totalPreferred) == !inverse) {
    3300             s = new Resizable2() {
    3301                 public int  getElementCount()      { return r.getElementCount(); }
    3302                 public int  getLowerBoundAt(int i) { return r.getLowerBoundAt(i); }
    3303                 public int  getUpperBoundAt(int i) { return r.getMidPointAt(i); }
    3304                 public void setSizeAt(int newSize, int i) { r.setSizeAt(newSize, i); }
    3305
    3306             };
    3307         }
    3308         else {
    3309             s = new Resizable2() {
    3310                 public int  getElementCount()      { return r.getElementCount(); }
    3311                 public int  getLowerBoundAt(int i) { return r.getMidPointAt(i); }
    3312                 public int  getUpperBoundAt(int i) { return r.getUpperBoundAt(i); }
    3313                 public void setSizeAt(int newSize, int i) { r.setSizeAt(newSize, i); }
    3314
    3315             };
    3316         }
    3317         adjustSizes(target, s, !inverse);
    3318     }
    3319
    3320     private void adjustSizes(long target, Resizable2 r, boolean limitToRange) {
    3321         long totalLowerBound = 0;
    3322         long totalUpperBound = 0;
    3323         for(int i = 0; i < r.getElementCount(); i++) {
    3324             totalLowerBound += r.getLowerBoundAt(i);
    3325             totalUpperBound += r.getUpperBoundAt(i);
    3326         }
    3327
    3328         if (limitToRange) {
    3329             target = Math.min(Math.max(totalLowerBound, target), totalUpperBound);
    3330         }
    3331
    3332         for(int i = 0; i < r.getElementCount(); i++) {
    3333             int lowerBound = r.getLowerBoundAt(i);
    3334             int upperBound = r.getUpperBoundAt(i);
    3335             // Check for zero. This happens when the distribution of the delta
    3336             // finishes early due to a series of "fixed" entries at the end.
    3337             // In this case, lowerBound == upperBound, for all subsequent terms.
    3338             int newSize;
    3339             if (totalLowerBound == totalUpperBound) {
    3340                 newSize = lowerBound;
    3341             }
    3342             else {
    3343                 double f = (double)(target - totalLowerBound)/(totalUpperBound - totalLowerBound);
    3344                 newSize = (int)Math.round(lowerBound+f*(upperBound - lowerBound));
    3345                 // We'd need to round manually in an all integer version.
    3346                 // size[i] = (int)(((totalUpperBound - target) * lowerBound +
    3347                 //     (target - totalLowerBound) * upperBound)/(totalUpperBound-totalLowerBound));
    3348             }
    3349             r.setSizeAt(newSize, i);
    3350             target -= newSize;
    3351             totalLowerBound -= lowerBound;
    3352             totalUpperBound -= upperBound;
    3353         }
    3354     }
    3355
    3356     /**
    3357      * Overrides <code>JComponent</code>'s <code>getToolTipText</code>
    3358      * method in order to allow the renderer's tips to be used
    3359      * if it has text set.
    3360      * <p>
    3361      * <b>Note:</b> For <code>JTable</code> to properly display
    3362      * tooltips of its renderers
    3363      * <code>JTable</code> must be a registered component with the
    3364      * <code>ToolTipManager</code>.
    3365      * This is done automatically in <code>initializeLocalVars</code>,
    3366      * but if at a later point <code>JTable</code> is told
    3367      * <code>setToolTipText(null)</code> it will unregister the table
    3368      * component, and no tips from renderers will display anymore.
    3369      *
    3370      * @see JComponent#getToolTipText
    3371      */
    3372     public String getToolTipText(MouseEvent event) {
    3373         String tip = null;
    3374         Point p = event.getPoint();
    3375
    3376         // Locate the renderer under the event location
    3377         int hitColumnIndex = columnAtPoint(p);
    3378         int hitRowIndex = rowAtPoint(p);
    3379
    3380         if ((hitColumnIndex != -1) && (hitRowIndex != -1)) {
    3381             TableCellRenderer renderer = getCellRenderer(hitRowIndex, hitColumnIndex);
    3382             Component component = prepareRenderer(renderer, hitRowIndex, hitColumnIndex);
    3383
    3384             // Now have to see if the component is a JComponent before
    3385             // getting the tip
    3386             if (component instanceof JComponent) {
    3387                 // Convert the event to the renderer's coordinate system
    3388                 Rectangle cellRect = getCellRect(hitRowIndex, hitColumnIndex, false);
    3389                 p.translate(-cellRect.x, -cellRect.y);
    3390                 @SuppressWarnings("deprecation")
    3391                 final int modifiers = event.getModifiers();
    3392                 MouseEvent newEvent = new MouseEvent(component, event.getID(),
    3393                                           event.getWhen(), modifiers,
    3394                                           p.x, p.y,
    3395                                           event.getXOnScreen(),
    3396                                           event.getYOnScreen(),
    3397                                           event.getClickCount(),
    3398                                           event.isPopupTrigger(),
    3399                                           MouseEvent.NOBUTTON);
    3400                 MouseEventAccessor meAccessor = AWTAccessor.getMouseEventAccessor();
    3401                 meAccessor.setCausedByTouchEvent(newEvent,
    3402                     meAccessor.isCausedByTouchEvent(event));
    3403
    3404                 tip = ((JComponent)component).getToolTipText(newEvent);
    3405             }
    3406         }
    3407
    3408         // No tip from the renderer get our own tip
    3409         if (tip == null)
    3410             tip = getToolTipText();
    3411
    3412         return tip;
    3413     }
    3414
    3415 //
    3416 // Editing Support
    3417 //
    3418
    3419     /**
    3420      * Sets whether editors in this JTable get the keyboard focus
    3421      * when an editor is activated as a result of the JTable
    3422      * forwarding keyboard events for a cell.
    3423      * By default, this property is false, and the JTable
    3424      * retains the focus unless the cell is clicked.
    3425      *
    3426      * @param surrendersFocusOnKeystroke true if the editor should get the focus
    3427      *          when keystrokes cause the editor to be
    3428      *          activated
    3429      *
    3430      *
    3431      * @see #getSurrendersFocusOnKeystroke
    3432      * @since 1.4
    3433      */
    3434     public void setSurrendersFocusOnKeystroke(boolean surrendersFocusOnKeystroke) {
    3435         this.surrendersFocusOnKeystroke = surrendersFocusOnKeystroke;
    3436     }
    3437
    3438     /**
    3439      * Returns true if the editor should get the focus
    3440      * when keystrokes cause the editor to be activated
    3441      *
    3442      * @return  true if the editor should get the focus
    3443      *          when keystrokes cause the editor to be
    3444      *          activated
    3445      *
    3446      * @see #setSurrendersFocusOnKeystroke
    3447      * @since 1.4
    3448      */
    3449     public boolean getSurrendersFocusOnKeystroke() {
    3450         return surrendersFocusOnKeystroke;
    3451     }
    3452
    3453     /**
    3454      * Programmatically starts editing the cell at <code>row</code> and
    3455      * <code>column</code>, if those indices are in the valid range, and
    3456      * the cell at those indices is editable.
    3457      * Note that this is a convenience method for
    3458      * <code>editCellAt(int, int, null)</code>.
    3459      *
    3460      * @param   row                             the row to be edited
    3461      * @param   column                          the column to be edited
    3462      * @return  false if for any reason the cell cannot be edited,
    3463      *                or if the indices are invalid
    3464      */
    3465     public boolean editCellAt(int row, int column) {
    3466         return editCellAt(row, column, null);
    3467     }
    3468
    3469     /**
    3470      * Programmatically starts editing the cell at <code>row</code> and
    3471      * <code>column</code>, if those indices are in the valid range, and
    3472      * the cell at those indices is editable.
    3473      * To prevent the <code>JTable</code> from
    3474      * editing a particular table, column or cell value, return false from
    3475      * the <code>isCellEditable</code> method in the <code>TableModel</code>
    3476      * interface.
    3477      *
    3478      * @param   row     the row to be edited
    3479      * @param   column  the column to be edited
    3480      * @param   e       event to pass into <code>shouldSelectCell</code>;
    3481      *                  note that as of Java 2 platform v1.2, the call to
    3482      *                  <code>shouldSelectCell</code> is no longer made
    3483      * @return  false if for any reason the cell cannot be edited,
    3484      *                or if the indices are invalid
    3485      */
    3486     public boolean editCellAt(int row, int column, EventObject e){
    3487         if (cellEditor != null && !cellEditor.stopCellEditing()) {
    3488             return false;
    3489         }
    3490
    3491         if (row < 0 || row >= getRowCount() ||
    3492             column < 0 || column >= getColumnCount()) {
    3493             return false;
    3494         }
    3495
    3496         if (!isCellEditable(row, column))
    3497             return false;
    3498
    3499         if (editorRemover == null) {
    3500             KeyboardFocusManager fm =
    3501                 KeyboardFocusManager.getCurrentKeyboardFocusManager();
    3502             editorRemover = new CellEditorRemover(fm);
    3503             fm.addPropertyChangeListener("permanentFocusOwner", editorRemover);
    3504         }
    3505
    3506         TableCellEditor editor = getCellEditor(row, column);
    3507         if (editor != null && editor.isCellEditable(e)) {
    3508             editorComp = prepareEditor(editor, row, column);
    3509             if (editorComp == null) {
    3510                 removeEditor();
    3511                 return false;
    3512             }
    3513             editorComp.setBounds(getCellRect(row, column, false));
    3514             add(editorComp);
    3515             editorComp.validate();
    3516             editorComp.repaint();
    3517
    3518             setCellEditor(editor);
    3519             setEditingRow(row);
    3520             setEditingColumn(column);
    3521             editor.addCellEditorListener(this);
    3522
    3523             return true;
    3524         }
    3525         return false;
    3526     }
    3527
    3528     /**
    3529      * Returns true if a cell is being edited.
    3530      *
    3531      * @return  true if the table is editing a cell
    3532      * @see     #editingColumn
    3533      * @see     #editingRow
    3534      */
    3535     @BeanProperty(bound = false)
    3536     public boolean isEditing() {
    3537         return cellEditor != null;
    3538     }
    3539
    3540     /**
    3541      * Returns the component that is handling the editing session.
    3542      * If nothing is being edited, returns null.
    3543      *
    3544      * @return  Component handling editing session
    3545      */
    3546     @BeanProperty(bound = false)
    3547     public Component getEditorComponent() {
    3548         return editorComp;
    3549     }
    3550
    3551     /**
    3552      * Returns the index of the column that contains the cell currently
    3553      * being edited.  If nothing is being edited, returns -1.
    3554      *
    3555      * @return  the index of the column that contains the cell currently
    3556      *          being edited; returns -1 if nothing being edited
    3557      * @see #editingRow
    3558      */
    3559     public int getEditingColumn() {
    3560         return editingColumn;
    3561     }
    3562
    3563     /**
    3564      * Returns the index of the row that contains the cell currently
    3565      * being edited.  If nothing is being edited, returns -1.
    3566      *
    3567      * @return  the index of the row that contains the cell currently
    3568      *          being edited; returns -1 if nothing being edited
    3569      * @see #editingColumn
    3570      */
    3571     public int getEditingRow() {
    3572         return editingRow;
    3573     }
    3574
    3575 //
    3576 // Managing TableUI
    3577 //
    3578
    3579     /**
    3580      * Returns the L&amp;F object that renders this component.
    3581      *
    3582      * @return the <code>TableUI</code> object that renders this component
    3583      */
    3584     public TableUI getUI() {
    3585         return (TableUI)ui;
    3586     }
    3587
    3588     /**
    3589      * Sets the L&amp;F object that renders this component and repaints.
    3590      *
    3591      * @param ui  the TableUI L&amp;F object
    3592      * @see UIDefaults#getUI
    3593      */
    3594     @BeanProperty(hidden = true, visualUpdate = true, description
    3595             = "The UI object that implements the Component's LookAndFeel.")
    3596     public void setUI(TableUI ui) {
    3597         if (this.ui != ui) {
    3598             super.setUI(ui);
    3599             repaint();
    3600         }
    3601     }
    3602
    3603     /**
    3604      * Notification from the <code>UIManager</code> that the L&amp;F has changed.
    3605      * Replaces the current UI object with the latest version from the
    3606      * <code>UIManager</code>.
    3607      *
    3608      * @see JComponent#updateUI
    3609      */
    3610     public void updateUI() {
    3611         if (updateInProgress) {
    3612             return;
    3613         }
    3614
    3615         updateInProgress = true;
    3616
    3617         try {
    3618             // Update the UIs of the cell renderers, cell editors and header renderers.
    3619             TableColumnModel cm = getColumnModel();
    3620             for(int column = 0; column < cm.getColumnCount(); column++) {
    3621                 TableColumn aColumn = cm.getColumn(column);
    3622                 SwingUtilities.updateRendererOrEditorUI(aColumn.getCellRenderer());
    3623                 SwingUtilities.updateRendererOrEditorUI(aColumn.getCellEditor());
    3624                 SwingUtilities.updateRendererOrEditorUI(aColumn.getHeaderRenderer());
    3625             }
    3626
    3627             // Update the UIs of all the default renderers.
    3628             Enumeration<?> defaultRenderers = defaultRenderersByColumnClass.elements();
    3629             while (defaultRenderers.hasMoreElements()) {
    3630                 SwingUtilities.updateRendererOrEditorUI(defaultRenderers.nextElement());
    3631             }
    3632
    3633             // Update the UIs of all the default editors.
    3634             Enumeration<?> defaultEditors = defaultEditorsByColumnClass.elements();
    3635             while (defaultEditors.hasMoreElements()) {
    3636                 SwingUtilities.updateRendererOrEditorUI(defaultEditors.nextElement());
    3637             }
    3638
    3639             // Update the UI of the table header
    3640             if (tableHeader != null && tableHeader.getParent() == null) {
    3641                 tableHeader.updateUI();
    3642             }
    3643
    3644             // Update UI applied to parent ScrollPane
    3645             configureEnclosingScrollPaneUI();
    3646
    3647             setUI((TableUI)UIManager.getUI(this));
    3648         } finally {
    3649             updateInProgress = false;
    3650         }
    3651     }
    3652
    3653     /**
    3654      * Returns the suffix used to construct the name of the L&amp;F class used to
    3655      * render this component.
    3656      *
    3657      * @return the string "TableUI"
    3658      * @see JComponent#getUIClassID
    3659      * @see UIDefaults#getUI
    3660      */
    3661     @BeanProperty(bound = false)
    3662     public String getUIClassID() {
    3663         return uiClassID;
    3664     }
    3665
    3666
    3667 //
    3668 // Managing models
    3669 //
    3670
    3671     /**
    3672      * Sets the data model for this table to {@code dataModel} and registers
    3673      * with it for listener notifications from the new data model.
    3674      *
    3675      * @param  dataModel the new data source for this table
    3676      * @throws IllegalArgumentException if {@code dataModel} is {@code null}
    3677      * @see #getModel
    3678      */
    3679     @BeanProperty(description
    3680             = "The model that is the source of the data for this view.")
    3681     public void setModel(final TableModel dataModel) {
    3682         if (dataModel == null) {
    3683             throw new IllegalArgumentException("Cannot set a null TableModel");
    3684         }
    3685         if (this.dataModel != dataModel) {
    3686             TableModel old = this.dataModel;
    3687             if (old != null) {
    3688                 old.removeTableModelListener(this);
    3689             }
    3690             this.dataModel = dataModel;
    3691             dataModel.addTableModelListener(this);
    3692
    3693             tableChanged(new TableModelEvent(dataModel, TableModelEvent.HEADER_ROW));
    3694
    3695             firePropertyChange("model", old, dataModel);
    3696
    3697             if (getAutoCreateRowSorter()) {
    3698                 setRowSorter(new TableRowSorter<TableModel>(dataModel));
    3699             }
    3700         }
    3701     }
    3702
    3703     /**
    3704      * Returns the {@code TableModel} that provides the data displayed by this
    3705      * {@code JTable}.
    3706      *
    3707      * @return the {@code TableModel} that provides the data displayed by this
    3708      *         {@code JTable}
    3709      * @see #setModel
    3710      */
    3711     public TableModel getModel() {
    3712         return dataModel;
    3713     }
    3714
    3715     /**
    3716      * Sets the column model for this table to {@code columnModel} and registers
    3717      * for listener notifications from the new column model. Also sets the
    3718      * column model of the {@code JTableHeader} to {@code columnModel}.
    3719      *
    3720      * @param  columnModel the new data source for this table
    3721      * @throws IllegalArgumentException if {@code columnModel} is {@code null}
    3722      * @see #getColumnModel
    3723      */
    3724     @BeanProperty(description
    3725             = "The object governing the way columns appear in the view.")
    3726     public void setColumnModel(final TableColumnModel columnModel) {
    3727         if (columnModel == null) {
    3728             throw new IllegalArgumentException("Cannot set a null ColumnModel");
    3729         }
    3730         TableColumnModel old = this.columnModel;
    3731         if (columnModel != old) {
    3732             if (old != null) {
    3733                 old.removeColumnModelListener(this);
    3734             }
    3735             this.columnModel = columnModel;
    3736             columnModel.addColumnModelListener(this);
    3737
    3738             // Set the column model of the header as well.
    3739             if (tableHeader != null) {
    3740                 tableHeader.setColumnModel(columnModel);
    3741             }
    3742
    3743             firePropertyChange("columnModel", old, columnModel);
    3744             resizeAndRepaint();
    3745         }
    3746     }
    3747
    3748     /**
    3749      * Returns the {@code TableColumnModel} that contains all column information
    3750      * of this table.
    3751      *
    3752      * @return the object that provides the column state of the table
    3753      * @see #setColumnModel
    3754      */
    3755     public TableColumnModel getColumnModel() {
    3756         return columnModel;
    3757     }
    3758
    3759     /**
    3760      * Sets the row selection model for this table to {@code selectionModel}
    3761      * and registers for listener notifications from the new selection model.
    3762      *
    3763      * @param  selectionModel the new selection model
    3764      * @throws IllegalArgumentException if {@code selectionModel} is
    3765      *         {@code null}
    3766      * @see #getSelectionModel
    3767      */
    3768     @BeanProperty(description
    3769             = "The selection model for rows.")
    3770     public void setSelectionModel(final ListSelectionModel selectionModel) {
    3771         if (selectionModel == null) {
    3772             throw new IllegalArgumentException("Cannot set a null SelectionModel");
    3773         }
    3774
    3775         ListSelectionModel oldModel = this.selectionModel;
    3776
    3777         if (selectionModel != oldModel) {
    3778             if (oldModel != null) {
    3779                 oldModel.removeListSelectionListener(this);
    3780             }
    3781
    3782             this.selectionModel = selectionModel;
    3783             selectionModel.addListSelectionListener(this);
    3784
    3785             firePropertyChange("selectionModel", oldModel, selectionModel);
    3786             repaint();
    3787         }
    3788     }
    3789
    3790     /**
    3791      * Returns the {@code ListSelectionModel} that is used to maintain row
    3792      * selection state.
    3793      *
    3794      * @return the object that provides row selection state, {@code null} if row
    3795      *         selection is not allowed
    3796      * @see #setSelectionModel
    3797      */
    3798     public ListSelectionModel getSelectionModel() {
    3799         return selectionModel;
    3800     }
    3801
    3802 //
    3803 // RowSorterListener
    3804 //
    3805
    3806     /**
    3807      * <code>RowSorterListener</code> notification that the
    3808      * <code>RowSorter</code> has changed in some way.
    3809      *
    3810      * @param e the <code>RowSorterEvent</code> describing the change
    3811      * @throws NullPointerException if <code>e</code> is <code>null</code>
    3812      * @since 1.6
    3813      */
    3814     public void sorterChanged(RowSorterEvent e) {
    3815         if (e.getType() == RowSorterEvent.Type.SORT_ORDER_CHANGED) {
    3816             JTableHeader header = getTableHeader();
    3817             if (header != null) {
    3818                 header.repaint();
    3819             }
    3820         }
    3821         else if (e.getType() == RowSorterEvent.Type.SORTED) {
    3822             sorterChanged = true;
    3823             if (!ignoreSortChange) {
    3824                 sortedTableChanged(e, null);
    3825             }
    3826         }
    3827     }
    3828
    3829
    3830     /**
    3831      * SortManager provides support for managing the selection and variable
    3832      * row heights when sorting is enabled. This information is encapsulated
    3833      * into a class to avoid bulking up JTable.
    3834      */
    3835     private final class SortManager {
    3836         RowSorter<? extends TableModel> sorter;
    3837
    3838         // Selection, in terms of the model. This is lazily created
    3839         // as needed.
    3840         private ListSelectionModel modelSelection;
    3841         private int modelLeadIndex;
    3842         // Set to true while in the process of changing the selection.
    3843         // If this is true the selection change is ignored.
    3844         private boolean syncingSelection;
    3845         // Temporary cache of selection, in terms of model. This is only used
    3846         // if we don't need the full weight of modelSelection.
    3847         private int[] lastModelSelection;
    3848
    3849         // Heights of the rows in terms of the model.
    3850         private SizeSequence modelRowSizes;
    3851
    3852
    3853         SortManager(RowSorter<? extends TableModel> sorter) {
    3854             this.sorter = sorter;
    3855             sorter.addRowSorterListener(JTable.this);
    3856         }
    3857
    3858         /**
    3859          * Disposes any resources used by this SortManager.
    3860          */
    3861         public void dispose() {
    3862             if (sorter != null) {
    3863                 sorter.removeRowSorterListener(JTable.this);
    3864             }
    3865         }
    3866
    3867         /**
    3868          * Sets the height for a row at a specified index.
    3869          */
    3870         public void setViewRowHeight(int viewIndex, int rowHeight) {
    3871             if (modelRowSizes == null) {
    3872                 modelRowSizes = new SizeSequence(getModel().getRowCount(),
    3873                                                  getRowHeight());
    3874             }
    3875             modelRowSizes.setSize(convertRowIndexToModel(viewIndex),rowHeight);
    3876         }
    3877
    3878         /**
    3879          * Invoked when the underlying model has completely changed.
    3880          */
    3881         public void allChanged() {
    3882             modelLeadIndex = -1;
    3883             modelSelection = null;
    3884             modelRowSizes = null;
    3885         }
    3886
    3887         /**
    3888          * Invoked when the selection, on the view, has changed.
    3889          */
    3890         public void viewSelectionChanged(ListSelectionEvent e) {
    3891             if (!syncingSelection && modelSelection != null) {
    3892                 modelSelection = null;
    3893             }
    3894         }
    3895
    3896         /**
    3897          * Invoked when either the table model has changed, or the RowSorter
    3898          * has changed. This is invoked prior to notifying the sorter of the
    3899          * change.
    3900          */
    3901         public void prepareForChange(RowSorterEvent sortEvent,
    3902                                      ModelChange change) {
    3903             if (getUpdateSelectionOnSort()) {
    3904                 cacheSelection(sortEvent, change);
    3905             }
    3906         }
    3907
    3908         /**
    3909          * Updates the internal cache of the selection based on the change.
    3910          */
    3911         private void cacheSelection(RowSorterEvent sortEvent,
    3912                                     ModelChange change) {
    3913             if (sortEvent != null) {
    3914                 // sort order changed. If modelSelection is null and filtering
    3915                 // is enabled we need to cache the selection in terms of the
    3916                 // underlying model, this will allow us to correctly restore
    3917                 // the selection even if rows are filtered out.
    3918                 if (modelSelection == null &&
    3919                         sorter.getViewRowCount() != getModel().getRowCount()) {
    3920                     modelSelection = new DefaultListSelectionModel();
    3921                     ListSelectionModel viewSelection = getSelectionModel();
    3922                     int min = viewSelection.getMinSelectionIndex();
    3923                     int max = viewSelection.getMaxSelectionIndex();
    3924                     int modelIndex;
    3925                     for (int viewIndex = min; viewIndex <= max; viewIndex++) {
    3926                         if (viewSelection.isSelectedIndex(viewIndex)) {
    3927                             modelIndex = convertRowIndexToModel(
    3928                                     sortEvent, viewIndex);
    3929                             if (modelIndex != -1) {
    3930                                 modelSelection.addSelectionInterval(
    3931                                     modelIndex, modelIndex);
    3932                             }
    3933                         }
    3934                     }
    3935                     modelIndex = convertRowIndexToModel(sortEvent,
    3936                             viewSelection.getLeadSelectionIndex());
    3937                     SwingUtilities2.setLeadAnchorWithoutSelection(
    3938                             modelSelection, modelIndex, modelIndex);
    3939                 } else if (modelSelection == null) {
    3940                     // Sorting changed, haven't cached selection in terms
    3941                     // of model and no filtering. Temporarily cache selection.
    3942                     cacheModelSelection(sortEvent);
    3943                 }
    3944             } else if (change.allRowsChanged) {
    3945                 // All the rows have changed, chuck any cached selection.
    3946                 modelSelection = null;
    3947             } else if (modelSelection != null) {
    3948                 // Table changed, reflect changes in cached selection model.
    3949                 switch(change.type) {
    3950                 case TableModelEvent.DELETE:
    3951                     modelSelection.removeIndexInterval(change.startModelIndex,
    3952                                                        change.endModelIndex);
    3953                     break;
    3954                 case TableModelEvent.INSERT:
    3955                     modelSelection.insertIndexInterval(change.startModelIndex,
    3956                                                        change.length,
    3957                                                        true);
    3958                     break;
    3959                 default:
    3960                     break;
    3961                 }
    3962             } else {
    3963                 // table changed, but haven't cached rows, temporarily
    3964                 // cache them.
    3965                 cacheModelSelection(null);
    3966             }
    3967         }
    3968
    3969         private void cacheModelSelection(RowSorterEvent sortEvent) {
    3970             lastModelSelection = convertSelectionToModel(sortEvent);
    3971             modelLeadIndex = convertRowIndexToModel(sortEvent,
    3972                         selectionModel.getLeadSelectionIndex());
    3973         }
    3974
    3975         /**
    3976          * Inovked when either the table has changed or the sorter has changed
    3977          * and after the sorter has been notified. If necessary this will
    3978          * reapply the selection and variable row heights.
    3979          */
    3980         public void processChange(RowSorterEvent sortEvent,
    3981                                   ModelChange change,
    3982                                   boolean sorterChanged) {
    3983             if (change != null) {
    3984                 if (change.allRowsChanged) {
    3985                     modelRowSizes = null;
    3986                     rowModel = null;
    3987                 } else if (modelRowSizes != null) {
    3988                     if (change.type == TableModelEvent.INSERT) {
    3989                         modelRowSizes.insertEntries(change.startModelIndex,
    3990                                                     change.endModelIndex -
    3991                                                     change.startModelIndex + 1,
    3992                                                     getRowHeight());
    3993                     } else if (change.type == TableModelEvent.DELETE) {
    3994                         modelRowSizes.removeEntries(change.startModelIndex,
    3995                                                     change.endModelIndex -
    3996                                                     change.startModelIndex +1 );
    3997                     }
    3998                 }
    3999             }
    4000             if (sorterChanged) {
    4001                 setViewRowHeightsFromModel();
    4002                 restoreSelection(change);
    4003             }
    4004         }
    4005
    4006         /**
    4007          * Resets the variable row heights in terms of the view from
    4008          * that of the variable row heights in terms of the model.
    4009          */
    4010         private void setViewRowHeightsFromModel() {
    4011             if (modelRowSizes != null) {
    4012                 rowModel.setSizes(getRowCount(), getRowHeight());
    4013                 for (int viewIndex = getRowCount() - 1; viewIndex >= 0;
    4014                          viewIndex--) {
    4015                     int modelIndex = convertRowIndexToModel(viewIndex);
    4016                     rowModel.setSize(viewIndex,
    4017                                      modelRowSizes.getSize(modelIndex));
    4018                 }
    4019             }
    4020         }
    4021
    4022         /**
    4023          * Restores the selection from that in terms of the model.
    4024          */
    4025         private void restoreSelection(ModelChange change) {
    4026             syncingSelection = true;
    4027             if (lastModelSelection != null) {
    4028                 restoreSortingSelection(lastModelSelection,
    4029                                         modelLeadIndex, change);
    4030                 lastModelSelection = null;
    4031             } else if (modelSelection != null) {
    4032                 ListSelectionModel viewSelection = getSelectionModel();
    4033                 viewSelection.setValueIsAdjusting(true);
    4034                 viewSelection.clearSelection();
    4035                 int min = modelSelection.getMinSelectionIndex();
    4036                 int max = modelSelection.getMaxSelectionIndex();
    4037                 int viewIndex;
    4038                 for (int modelIndex = min; modelIndex <= max; modelIndex++) {
    4039                     if (modelSelection.isSelectedIndex(modelIndex)) {
    4040                         viewIndex = convertRowIndexToView(modelIndex);
    4041                         if (viewIndex != -1) {
    4042                             viewSelection.addSelectionInterval(viewIndex,
    4043                                                                viewIndex);
    4044                         }
    4045                     }
    4046                 }
    4047                 // Restore the lead
    4048                 int viewLeadIndex = modelSelection.getLeadSelectionIndex();
    4049                 if (viewLeadIndex != -1 && !modelSelection.isSelectionEmpty()) {
    4050                     viewLeadIndex = convertRowIndexToView(viewLeadIndex);
    4051                 }
    4052                 SwingUtilities2.setLeadAnchorWithoutSelection(
    4053                         viewSelection, viewLeadIndex, viewLeadIndex);
    4054                 viewSelection.setValueIsAdjusting(false);
    4055             }
    4056             syncingSelection = false;
    4057         }
    4058     }
    4059
    4060
    4061     /**
    4062      * ModelChange is used when sorting to restore state, it corresponds
    4063      * to data from a TableModelEvent.  The values are precalculated as
    4064      * they are used extensively.
    4065      */
    4066     private final class ModelChange {
    4067         // Starting index of the change, in terms of the model
    4068         int startModelIndex;
    4069
    4070         // Ending index of the change, in terms of the model
    4071         int endModelIndex;
    4072
    4073         // Type of change
    4074         int type;
    4075
    4076         // Number of rows in the model
    4077         int modelRowCount;
    4078
    4079         // The event that triggered this.
    4080         TableModelEvent event;
    4081
    4082         // Length of the change (end - start + 1)
    4083         int length;
    4084
    4085         // True if the event indicates all the contents have changed
    4086         boolean allRowsChanged;
    4087
    4088         ModelChange(TableModelEvent e) {
    4089             startModelIndex = Math.max(0, e.getFirstRow());
    4090             endModelIndex = e.getLastRow();
    4091             modelRowCount = getModel().getRowCount();
    4092             if (endModelIndex < 0) {
    4093                 endModelIndex = Math.max(0, modelRowCount - 1);
    4094             }
    4095             length = endModelIndex - startModelIndex + 1;
    4096             type = e.getType();
    4097             event = e;
    4098             allRowsChanged = (e.getLastRow() == Integer.MAX_VALUE);
    4099         }
    4100     }
    4101
    4102     /**
    4103      * Invoked when <code>sorterChanged</code> is invoked, or
    4104      * when <code>tableChanged</code> is invoked and sorting is enabled.
    4105      */
    4106     private void sortedTableChanged(RowSorterEvent sortedEvent,
    4107                                     TableModelEvent e) {
    4108         int editingModelIndex = -1;
    4109         ModelChange change = (e != null) ? new ModelChange(e) : null;
    4110
    4111         if ((change == null || !change.allRowsChanged) &&
    4112                 this.editingRow != -1) {
    4113             editingModelIndex = convertRowIndexToModel(sortedEvent,
    4114                                                        this.editingRow);
    4115         }
    4116
    4117         sortManager.prepareForChange(sortedEvent, change);
    4118
    4119         if (e != null) {
    4120             if (change.type == TableModelEvent.UPDATE) {
    4121                 repaintSortedRows(change);
    4122             }
    4123             notifySorter(change);
    4124             if (change.type != TableModelEvent.UPDATE) {
    4125                 // If the Sorter is unsorted we will not have received
    4126                 // notification, force treating insert/delete as a change.
    4127                 sorterChanged = true;
    4128             }
    4129         }
    4130         else {
    4131             sorterChanged = true;
    4132         }
    4133
    4134         sortManager.processChange(sortedEvent, change, sorterChanged);
    4135
    4136         if (sorterChanged) {
    4137             // Update the editing row
    4138             if (this.editingRow != -1) {
    4139                 int newIndex = (editingModelIndex == -1) ? -1 :
    4140                         convertRowIndexToView(editingModelIndex,change);
    4141                 restoreSortingEditingRow(newIndex);
    4142             }
    4143
    4144             // And handle the appropriate repainting.
    4145             if (e == null || change.type != TableModelEvent.UPDATE) {
    4146                 resizeAndRepaint();
    4147             }
    4148         }
    4149
    4150         // Check if lead/anchor need to be reset.
    4151         if (change != null && change.allRowsChanged) {
    4152             clearSelectionAndLeadAnchor();
    4153             resizeAndRepaint();
    4154         }
    4155     }
    4156
    4157     /**
    4158      * Repaints the sort of sorted rows in response to a TableModelEvent.
    4159      */
    4160     private void repaintSortedRows(ModelChange change) {
    4161         if (change.startModelIndex > change.endModelIndex ||
    4162                 change.startModelIndex + 10 < change.endModelIndex) {
    4163             // Too much has changed, punt
    4164             repaint();
    4165             return;
    4166         }
    4167         int eventColumn = change.event.getColumn();
    4168         int columnViewIndex = eventColumn;
    4169         if (columnViewIndex == TableModelEvent.ALL_COLUMNS) {
    4170             columnViewIndex = 0;
    4171         }
    4172         else {
    4173             columnViewIndex = convertColumnIndexToView(columnViewIndex);
    4174             if (columnViewIndex == -1) {
    4175                 return;
    4176             }
    4177         }
    4178         int modelIndex = change.startModelIndex;
    4179         while (modelIndex <= change.endModelIndex) {
    4180             int viewIndex = convertRowIndexToView(modelIndex++);
    4181             if (viewIndex != -1) {
    4182                 Rectangle dirty = getCellRect(viewIndex, columnViewIndex,
    4183                                               false);
    4184                 int x = dirty.x;
    4185                 int w = dirty.width;
    4186                 if (eventColumn == TableModelEvent.ALL_COLUMNS) {
    4187                     x = 0;
    4188                     w = getWidth();
    4189                 }
    4190                 repaint(x, dirty.y, w, dirty.height);
    4191             }
    4192         }
    4193     }
    4194
    4195     /**
    4196      * Restores the selection after a model event/sort order changes.
    4197      * All coordinates are in terms of the model.
    4198      */
    4199     private void restoreSortingSelection(int[] selection, int lead,
    4200             ModelChange change) {
    4201         // Convert the selection from model to view
    4202         for (int i = selection.length - 1; i >= 0; i--) {
    4203             selection[i] = convertRowIndexToView(selection[i], change);
    4204         }
    4205         lead = convertRowIndexToView(lead, change);
    4206
    4207         // Check for the common case of no change in selection for 1 row
    4208         if (selection.length == 0 ||
    4209             (selection.length == 1 && selection[0] == getSelectedRow())) {
    4210             return;
    4211         }
    4212
    4213         // And apply the new selection
    4214         selectionModel.setValueIsAdjusting(true);
    4215         selectionModel.clearSelection();
    4216         for (int i = selection.length - 1; i >= 0; i--) {
    4217             if (selection[i] != -1) {
    4218                 selectionModel.addSelectionInterval(selection[i],
    4219                                                     selection[i]);
    4220             }
    4221         }
    4222         SwingUtilities2.setLeadAnchorWithoutSelection(
    4223                 selectionModel, lead, lead);
    4224         selectionModel.setValueIsAdjusting(false);
    4225     }
    4226
    4227     /**
    4228      * Restores the editing row after a model event/sort order change.
    4229      *
    4230      * @param editingRow new index of the editingRow, in terms of the view
    4231      */
    4232     private void restoreSortingEditingRow(int editingRow) {
    4233         if (editingRow == -1) {
    4234             // Editing row no longer being shown, cancel editing
    4235             TableCellEditor editor = getCellEditor();
    4236             if (editor != null) {
    4237                 // First try and cancel
    4238                 editor.cancelCellEditing();
    4239                 if (getCellEditor() != null) {
    4240                     // CellEditor didn't cede control, forcefully
    4241                     // remove it
    4242                     removeEditor();
    4243                 }
    4244             }
    4245         }
    4246         else {
    4247             // Repositioning handled in BasicTableUI
    4248             this.editingRow = editingRow;
    4249             repaint();
    4250         }
    4251     }
    4252
    4253     /**
    4254      * Notifies the sorter of a change in the underlying model.
    4255      */
    4256     private void notifySorter(ModelChange change) {
    4257         try {
    4258             ignoreSortChange = true;
    4259             sorterChanged = false;
    4260             switch(change.type) {
    4261             case TableModelEvent.UPDATE:
    4262                 if (change.event.getLastRow() == Integer.MAX_VALUE) {
    4263                     sortManager.sorter.allRowsChanged();
    4264                 } else if (change.event.getColumn() ==
    4265                            TableModelEvent.ALL_COLUMNS) {
    4266                     sortManager.sorter.rowsUpdated(change.startModelIndex,
    4267                                        change.endModelIndex);
    4268                 } else {
    4269                     sortManager.sorter.rowsUpdated(change.startModelIndex,
    4270                                        change.endModelIndex,
    4271                                        change.event.getColumn());
    4272                 }
    4273                 break;
    4274             case TableModelEvent.INSERT:
    4275                 sortManager.sorter.rowsInserted(change.startModelIndex,
    4276                                     change.endModelIndex);
    4277                 break;
    4278             case TableModelEvent.DELETE:
    4279                 sortManager.sorter.rowsDeleted(change.startModelIndex,
    4280                                    change.endModelIndex);
    4281                 break;
    4282             }
    4283         } finally {
    4284             ignoreSortChange = false;
    4285         }
    4286     }
    4287
    4288     /**
    4289      * Converts a model index to view index.  This is called when the
    4290      * sorter or model changes and sorting is enabled.
    4291      *
    4292      * @param change describes the TableModelEvent that initiated the change;
    4293      *        will be null if called as the result of a sort
    4294      */
    4295     private int convertRowIndexToView(int modelIndex, ModelChange change) {
    4296         if (modelIndex < 0) {
    4297             return -1;
    4298         }
    4299         if (change != null && modelIndex >= change.startModelIndex) {
    4300             if (change.type == TableModelEvent.INSERT) {
    4301                 if (modelIndex + change.length >= change.modelRowCount) {
    4302                     return -1;
    4303                 }
    4304                 return sortManager.sorter.convertRowIndexToView(
    4305                         modelIndex + change.length);
    4306             }
    4307             else if (change.type == TableModelEvent.DELETE) {
    4308                 if (modelIndex <= change.endModelIndex) {
    4309                     // deleted
    4310                     return -1;
    4311                 }
    4312                 else {
    4313                     if (modelIndex - change.length >= change.modelRowCount) {
    4314                         return -1;
    4315                     }
    4316                     return sortManager.sorter.convertRowIndexToView(
    4317                             modelIndex - change.length);
    4318                 }
    4319             }
    4320             // else, updated
    4321         }
    4322         if (modelIndex >= getModel().getRowCount()) {
    4323             return -1;
    4324         }
    4325         return sortManager.sorter.convertRowIndexToView(modelIndex);
    4326     }
    4327
    4328     /**
    4329      * Converts the selection to model coordinates.  This is used when
    4330      * the model changes or the sorter changes.
    4331      */
    4332     private int[] convertSelectionToModel(RowSorterEvent e) {
    4333         int[] selection = getSelectedRows();
    4334         for (int i = selection.length - 1; i >= 0; i--) {
    4335             selection[i] = convertRowIndexToModel(e, selection[i]);
    4336         }
    4337         return selection;
    4338     }
    4339
    4340     private int convertRowIndexToModel(RowSorterEvent e, int viewIndex) {
    4341         if (e != null) {
    4342             if (e.getPreviousRowCount() == 0) {
    4343                 return viewIndex;
    4344             }
    4345             // range checking handled by RowSorterEvent
    4346             return e.convertPreviousRowIndexToModel(viewIndex);
    4347         }
    4348         // Make sure the viewIndex is valid
    4349         if (viewIndex < 0 || viewIndex >= getRowCount()) {
    4350             return -1;
    4351         }
    4352         return convertRowIndexToModel(viewIndex);
    4353     }
    4354
    4355 //
    4356 // Implementing TableModelListener interface
    4357 //
    4358
    4359     /**
    4360      * Invoked when this table's <code>TableModel</code> generates
    4361      * a <code>TableModelEvent</code>.
    4362      * The <code>TableModelEvent</code> should be constructed in the
    4363      * coordinate system of the model; the appropriate mapping to the
    4364      * view coordinate system is performed by this <code>JTable</code>
    4365      * when it receives the event.
    4366      * <p>
    4367      * Application code will not use these methods explicitly, they
    4368      * are used internally by <code>JTable</code>.
    4369      * <p>
    4370      * Note that as of 1.3, this method clears the selection, if any.
    4371      */
    4372     public void tableChanged(TableModelEvent e) {
    4373         if (e == null || e.getFirstRow() == TableModelEvent.HEADER_ROW) {
    4374             // The whole thing changed
    4375             clearSelectionAndLeadAnchor();
    4376
    4377             rowModel = null;
    4378
    4379             if (sortManager != null) {
    4380                 try {
    4381                     ignoreSortChange = true;
    4382                     sortManager.sorter.modelStructureChanged();
    4383                 } finally {
    4384                     ignoreSortChange = false;
    4385                 }
    4386                 sortManager.allChanged();
    4387             }
    4388
    4389             if (getAutoCreateColumnsFromModel()) {
    4390                 // This will effect invalidation of the JTable and JTableHeader.
    4391                 createDefaultColumnsFromModel();
    4392                 return;
    4393             }
    4394
    4395             resizeAndRepaint();
    4396             return;
    4397         }
    4398
    4399         if (sortManager != null) {
    4400             sortedTableChanged(null, e);
    4401             return;
    4402         }
    4403
    4404         // The totalRowHeight calculated below will be incorrect if
    4405         // there are variable height rows. Repaint the visible region,
    4406         // but don't return as a revalidate may be necessary as well.
    4407         if (rowModel != null) {
    4408             repaint();
    4409         }
    4410
    4411         if (e.getType() == TableModelEvent.INSERT) {
    4412             tableRowsInserted(e);
    4413             return;
    4414         }
    4415
    4416         if (e.getType() == TableModelEvent.DELETE) {
    4417             tableRowsDeleted(e);
    4418             return;
    4419         }
    4420
    4421         int modelColumn = e.getColumn();
    4422         int start = e.getFirstRow();
    4423         int end = e.getLastRow();
    4424
    4425         Rectangle dirtyRegion;
    4426         if (modelColumn == TableModelEvent.ALL_COLUMNS) {
    4427             // 1 or more rows changed
    4428             dirtyRegion = new Rectangle(0, start * getRowHeight(),
    4429                                         getColumnModel().getTotalColumnWidth(), 0);
    4430         }
    4431         else {
    4432             // A cell or column of cells has changed.
    4433             // Unlike the rest of the methods in the JTable, the TableModelEvent
    4434             // uses the coordinate system of the model instead of the view.
    4435             // This is the only place in the JTable where this "reverse mapping"
    4436             // is used.
    4437             int column = convertColumnIndexToView(modelColumn);
    4438             dirtyRegion = getCellRect(start, column, false);
    4439         }
    4440
    4441         // Now adjust the height of the dirty region according to the value of "end".
    4442         // Check for Integer.MAX_VALUE as this will cause an overflow.
    4443         if (end != Integer.MAX_VALUE) {
    4444             dirtyRegion.height = (end-start+1)*getRowHeight();
    4445             repaint(dirtyRegion.x, dirtyRegion.y, dirtyRegion.width, dirtyRegion.height);
    4446         }
    4447         // In fact, if the end is Integer.MAX_VALUE we need to revalidate anyway
    4448         // because the scrollbar may need repainting.
    4449         else {
    4450             clearSelectionAndLeadAnchor();
    4451             resizeAndRepaint();
    4452             rowModel = null;
    4453         }
    4454     }
    4455
    4456     /*
    4457      * Invoked when rows have been inserted into the table.
    4458      * <p>
    4459      * Application code will not use these methods explicitly, they
    4460      * are used internally by JTable.
    4461      *
    4462      * @param e the TableModelEvent encapsulating the insertion
    4463      */
    4464     private void tableRowsInserted(TableModelEvent e) {
    4465         int start = e.getFirstRow();
    4466         int end = e.getLastRow();
    4467         if (start < 0) {
    4468             start = 0;
    4469         }
    4470         if (end < 0) {
    4471             end = getRowCount()-1;
    4472         }
    4473
    4474         // Adjust the selection to account for the new rows.
    4475         int length = end - start + 1;
    4476         selectionModel.insertIndexInterval(start, length, true);
    4477
    4478         // If we have variable height rows, adjust the row model.
    4479         if (rowModel != null) {
    4480             rowModel.insertEntries(start, length, getRowHeight());
    4481         }
    4482         int rh = getRowHeight() ;
    4483         Rectangle drawRect = new Rectangle(0, start * rh,
    4484                                         getColumnModel().getTotalColumnWidth(),
    4485                                            (getRowCount()-start) * rh);
    4486
    4487         revalidate();
    4488         // PENDING(milne) revalidate calls repaint() if parent is a ScrollPane
    4489         // repaint still required in the unusual case where there is no ScrollPane
    4490         repaint(drawRect);
    4491     }
    4492
    4493     /*
    4494      * Invoked when rows have been removed from the table.
    4495      * <p>
    4496      * Application code will not use these methods explicitly, they
    4497      * are used internally by JTable.
    4498      *
    4499      * @param e the TableModelEvent encapsulating the deletion
    4500      */
    4501     private void tableRowsDeleted(TableModelEvent e) {
    4502         int start = e.getFirstRow();
    4503         int end = e.getLastRow();
    4504         if (start < 0) {
    4505             start = 0;
    4506         }
    4507         if (end < 0) {
    4508             end = getRowCount()-1;
    4509         }
    4510
    4511         int deletedCount = end - start + 1;
    4512         int previousRowCount = getRowCount() + deletedCount;
    4513         // Adjust the selection to account for the new rows
    4514         selectionModel.removeIndexInterval(start, end);
    4515
    4516         // If we have variable height rows, adjust the row model.
    4517         if (rowModel != null) {
    4518             rowModel.removeEntries(start, deletedCount);
    4519         }
    4520
    4521         int rh = getRowHeight();
    4522         Rectangle drawRect = new Rectangle(0, start * rh,
    4523                                         getColumnModel().getTotalColumnWidth(),
    4524                                         (previousRowCount - start) * rh);
    4525
    4526         revalidate();
    4527         // PENDING(milne) revalidate calls repaint() if parent is a ScrollPane
    4528         // repaint still required in the unusual case where there is no ScrollPane
    4529         repaint(drawRect);
    4530     }
    4531
    4532 //
    4533 // Implementing TableColumnModelListener interface
    4534 //
    4535
    4536     /**
    4537      * Invoked when a column is added to the table column model.
    4538      * <p>
    4539      * Application code will not use these methods explicitly, they
    4540      * are used internally by JTable.
    4541      *
    4542      * @see TableColumnModelListener
    4543      */
    4544     public void columnAdded(TableColumnModelEvent e) {
    4545         // If I'm currently editing, then I should stop editing
    4546         if (isEditing()) {
    4547             removeEditor();
    4548         }
    4549         resizeAndRepaint();
    4550     }
    4551
    4552     /**
    4553      * Invoked when a column is removed from the table column model.
    4554      * <p>
    4555      * Application code will not use these methods explicitly, they
    4556      * are used internally by JTable.
    4557      *
    4558      * @see TableColumnModelListener
    4559      */
    4560     public void columnRemoved(TableColumnModelEvent e) {
    4561         // If I'm currently editing, then I should stop editing
    4562         if (isEditing()) {
    4563             removeEditor();
    4564         }
    4565         resizeAndRepaint();
    4566     }
    4567
    4568     /**
    4569      * Invoked when a column is repositioned. If a cell is being
    4570      * edited, then editing is stopped and the cell is redrawn.
    4571      * <p>
    4572      * Application code will not use these methods explicitly, they
    4573      * are used internally by JTable.
    4574      *
    4575      * @param e   the event received
    4576      * @see TableColumnModelListener
    4577      */
    4578     public void columnMoved(TableColumnModelEvent e) {
    4579         if (isEditing() && !getCellEditor().stopCellEditing()) {
    4580             getCellEditor().cancelCellEditing();
    4581         }
    4582         repaint();
    4583     }
    4584
    4585     /**
    4586      * Invoked when a column is moved due to a margin change.
    4587      * If a cell is being edited, then editing is stopped and the cell
    4588      * is redrawn.
    4589      * <p>
    4590      * Application code will not use these methods explicitly, they
    4591      * are used internally by JTable.
    4592      *
    4593      * @param  e    the event received
    4594      * @see TableColumnModelListener
    4595      */
    4596     public void columnMarginChanged(ChangeEvent e) {
    4597         if (isEditing() && !getCellEditor().stopCellEditing()) {
    4598             getCellEditor().cancelCellEditing();
    4599         }
    4600         TableColumn resizingColumn = getResizingColumn();
    4601         // Need to do this here, before the parent's
    4602         // layout manager calls getPreferredSize().
    4603         if (resizingColumn != null && autoResizeMode == AUTO_RESIZE_OFF) {
    4604             resizingColumn.setPreferredWidth(resizingColumn.getWidth());
    4605         }
    4606         resizeAndRepaint();
    4607     }
    4608
    4609     private int limit(int i, int a, int b) {
    4610         return Math.min(b, Math.max(i, a));
    4611     }
    4612
    4613     /**
    4614      * Invoked when the selection model of the <code>TableColumnModel</code>
    4615      * is changed.
    4616      * <p>
    4617      * Application code will not use these methods explicitly, they
    4618      * are used internally by JTable.
    4619      *
    4620      * @param  e  the event received
    4621      * @see TableColumnModelListener
    4622      */
    4623     public void columnSelectionChanged(ListSelectionEvent e) {
    4624         boolean isAdjusting = e.getValueIsAdjusting();
    4625         if (columnSelectionAdjusting && !isAdjusting) {
    4626             // The assumption is that when the model is no longer adjusting
    4627             // we will have already gotten all the changes, and therefore
    4628             // don't need to do an additional paint.
    4629             columnSelectionAdjusting = false;
    4630             return;
    4631         }
    4632         columnSelectionAdjusting = isAdjusting;
    4633         // The getCellRect() call will fail unless there is at least one row.
    4634         if (getRowCount() <= 0 || getColumnCount() <= 0) {
    4635             return;
    4636         }
    4637         int firstIndex = limit(e.getFirstIndex(), 0, getColumnCount()-1);
    4638         int lastIndex = limit(e.getLastIndex(), 0, getColumnCount()-1);
    4639         int minRow = 0;
    4640         int maxRow = getRowCount() - 1;
    4641         if (getRowSelectionAllowed()) {
    4642             minRow = selectionModel.getMinSelectionIndex();
    4643             maxRow = selectionModel.getMaxSelectionIndex();
    4644             int leadRow = getAdjustedIndex(selectionModel.getLeadSelectionIndex(), true);
    4645
    4646             if (minRow == -1 || maxRow == -1) {
    4647                 if (leadRow == -1) {
    4648                     // nothing to repaint, return
    4649                     return;
    4650                 }
    4651
    4652                 // only thing to repaint is the lead
    4653                 minRow = maxRow = leadRow;
    4654             } else {
    4655                 // We need to consider more than just the range between
    4656                 // the min and max selected index. The lead row, which could
    4657                 // be outside this range, should be considered also.
    4658                 if (leadRow != -1) {
    4659                     minRow = Math.min(minRow, leadRow);
    4660                     maxRow = Math.max(maxRow, leadRow);
    4661                 }
    4662             }
    4663         }
    4664         Rectangle firstColumnRect = getCellRect(minRow, firstIndex, false);
    4665         Rectangle lastColumnRect = getCellRect(maxRow, lastIndex, false);
    4666         Rectangle dirtyRegion = firstColumnRect.union(lastColumnRect);
    4667         repaint(dirtyRegion);
    4668     }
    4669
    4670 //
    4671 // Implementing ListSelectionListener interface
    4672 //
    4673
    4674     /**
    4675      * Invoked when the row selection changes -- repaints to show the new
    4676      * selection.
    4677      * <p>
    4678      * Application code will not use these methods explicitly, they
    4679      * are used internally by JTable.
    4680      *
    4681      * @param e   the event received
    4682      * @see ListSelectionListener
    4683      */
    4684     public void valueChanged(ListSelectionEvent e) {
    4685         if (sortManager != null) {
    4686             sortManager.viewSelectionChanged(e);
    4687         }
    4688         boolean isAdjusting = e.getValueIsAdjusting();
    4689         if (rowSelectionAdjusting && !isAdjusting) {
    4690             // The assumption is that when the model is no longer adjusting
    4691             // we will have already gotten all the changes, and therefore
    4692             // don't need to do an additional paint.
    4693             rowSelectionAdjusting = false;
    4694             return;
    4695         }
    4696         rowSelectionAdjusting = isAdjusting;
    4697         // The getCellRect() calls will fail unless there is at least one column.
    4698         if (getRowCount() <= 0 || getColumnCount() <= 0) {
    4699             return;
    4700         }
    4701         int firstIndex = limit(e.getFirstIndex(), 0, getRowCount()-1);
    4702         int lastIndex = limit(e.getLastIndex(), 0, getRowCount()-1);
    4703         Rectangle firstRowRect = getCellRect(firstIndex, 0, false);
    4704         Rectangle lastRowRect = getCellRect(lastIndex, getColumnCount()-1, false);
    4705         Rectangle dirtyRegion = firstRowRect.union(lastRowRect);
    4706         repaint(dirtyRegion);
    4707     }
    4708
    4709 //
    4710 // Implementing the CellEditorListener interface
    4711 //
    4712
    4713     /**
    4714      * Invoked when editing is finished. The changes are saved and the
    4715      * editor is discarded.
    4716      * <p>
    4717      * Application code will not use these methods explicitly, they
    4718      * are used internally by JTable.
    4719      *
    4720      * @param  e  the event received
    4721      * @see CellEditorListener
    4722      */
    4723     public void editingStopped(ChangeEvent e) {
    4724         // Take in the new value
    4725         TableCellEditor editor = getCellEditor();
    4726         if (editor != null) {
    4727             Object value = editor.getCellEditorValue();
    4728             setValueAt(value, editingRow, editingColumn);
    4729             removeEditor();
    4730         }
    4731     }
    4732
    4733     /**
    4734      * Invoked when editing is canceled. The editor object is discarded
    4735      * and the cell is rendered once again.
    4736      * <p>
    4737      * Application code will not use these methods explicitly, they
    4738      * are used internally by JTable.
    4739      *
    4740      * @param  e  the event received
    4741      * @see CellEditorListener
    4742      */
    4743     public void editingCanceled(ChangeEvent e) {
    4744         removeEditor();
    4745     }
    4746
    4747 //
    4748 // Implementing the Scrollable interface
    4749 //
    4750
    4751     /**
    4752      * Sets the preferred size of the viewport for this table.
    4753      *
    4754      * @param size  a <code>Dimension</code> object specifying the <code>preferredSize</code> of a
    4755      *              <code>JViewport</code> whose view is this table
    4756      * @see Scrollable#getPreferredScrollableViewportSize
    4757      */
    4758     @BeanProperty(bound = false, description
    4759             = "The preferred size of the viewport.")
    4760     public void setPreferredScrollableViewportSize(Dimension size) {
    4761         preferredViewportSize = size;
    4762     }
    4763
    4764     /**
    4765      * Returns the preferred size of the viewport for this table.
    4766      *
    4767      * @return a <code>Dimension</code> object containing the <code>preferredSize</code> of the <code>JViewport</code>
    4768      *         which displays this table
    4769      * @see Scrollable#getPreferredScrollableViewportSize
    4770      */
    4771     public Dimension getPreferredScrollableViewportSize() {
    4772         return preferredViewportSize;
    4773     }
    4774
    4775     /**
    4776      * Returns the scroll increment (in pixels) that completely exposes one new
    4777      * row or column (depending on the orientation).
    4778      * <p>
    4779      * This method is called each time the user requests a unit scroll.
    4780      *
    4781      * @param visibleRect the view area visible within the viewport
    4782      * @param orientation either <code>SwingConstants.VERTICAL</code>
    4783      *                  or <code>SwingConstants.HORIZONTAL</code>
    4784      * @param direction less than zero to scroll up/left,
    4785      *                  greater than zero for down/right
    4786      * @return the "unit" increment for scrolling in the specified direction
    4787      * @see Scrollable#getScrollableUnitIncrement
    4788      */
    4789     public int getScrollableUnitIncrement(Rectangle visibleRect,
    4790                                           int orientation,
    4791                                           int direction) {
    4792         int leadingRow;
    4793         int leadingCol;
    4794         Rectangle leadingCellRect;
    4795
    4796         int leadingVisibleEdge;
    4797         int leadingCellEdge;
    4798         int leadingCellSize;
    4799
    4800         leadingRow = getLeadingRow(visibleRect);
    4801         leadingCol = getLeadingCol(visibleRect);
    4802         if (orientation == SwingConstants.VERTICAL && leadingRow < 0) {
    4803             // Couldn't find leading row - return some default value
    4804             return getRowHeight();
    4805         }
    4806         else if (orientation == SwingConstants.HORIZONTAL && leadingCol < 0) {
    4807             // Couldn't find leading col - return some default value
    4808             return 100;
    4809         }
    4810
    4811         // Note that it's possible for one of leadingCol or leadingRow to be
    4812         // -1, depending on the orientation.  This is okay, as getCellRect()
    4813         // still provides enough information to calculate the unit increment.
    4814         leadingCellRect = getCellRect(leadingRow, leadingCol, true);
    4815         leadingVisibleEdge = leadingEdge(visibleRect, orientation);
    4816         leadingCellEdge = leadingEdge(leadingCellRect, orientation);
    4817
    4818         if (orientation == SwingConstants.VERTICAL) {
    4819             leadingCellSize = leadingCellRect.height;
    4820
    4821         }
    4822         else {
    4823             leadingCellSize = leadingCellRect.width;
    4824         }
    4825
    4826         // 4 cases:
    4827         // #1: Leading cell fully visible, reveal next cell
    4828         // #2: Leading cell fully visible, hide leading cell
    4829         // #3: Leading cell partially visible, hide rest of leading cell
    4830         // #4: Leading cell partially visible, reveal rest of leading cell
    4831
    4832         if (leadingVisibleEdge == leadingCellEdge) { // Leading cell is fully
    4833                                                      // visible
    4834             // Case #1: Reveal previous cell
    4835             if (direction < 0) {
    4836                 int retVal = 0;
    4837
    4838                 if (orientation == SwingConstants.VERTICAL) {
    4839                     // Loop past any zero-height rows
    4840                     while (--leadingRow >= 0) {
    4841                         retVal = getRowHeight(leadingRow);
    4842                         if (retVal != 0) {
    4843                             break;
    4844                         }
    4845                     }
    4846                 }
    4847                 else { // HORIZONTAL
    4848                     // Loop past any zero-width cols
    4849                     while (--leadingCol >= 0) {
    4850                         retVal = getCellRect(leadingRow, leadingCol, true).width;
    4851                         if (retVal != 0) {
    4852                             break;
    4853                         }
    4854                     }
    4855                 }
    4856                 return retVal;
    4857             }
    4858             else { // Case #2: hide leading cell
    4859                 return leadingCellSize;
    4860             }
    4861         }
    4862         else { // Leading cell is partially hidden
    4863             // Compute visible, hidden portions
    4864             int hiddenAmt = Math.abs(leadingVisibleEdge - leadingCellEdge);
    4865             int visibleAmt = leadingCellSize - hiddenAmt;
    4866
    4867             if (direction > 0) {
    4868                 // Case #3: hide showing portion of leading cell
    4869                 return visibleAmt;
    4870             }
    4871             else { // Case #4: reveal hidden portion of leading cell
    4872                 return hiddenAmt;
    4873             }
    4874         }
    4875     }
    4876
    4877     /**
    4878      * Returns <code>visibleRect.height</code> or
    4879      * <code>visibleRect.width</code>,
    4880      * depending on this table's orientation.  Note that as of Swing 1.1.1
    4881      * (Java 2 v 1.2.2) the value
    4882      * returned will ensure that the viewport is cleanly aligned on
    4883      * a row boundary.
    4884      *
    4885      * @return <code>visibleRect.height</code> or
    4886      *                                  <code>visibleRect.width</code>
    4887      *                                  per the orientation
    4888      * @see Scrollable#getScrollableBlockIncrement
    4889      */
    4890     public int getScrollableBlockIncrement(Rectangle visibleRect,
    4891             int orientation, int direction) {
    4892
    4893         if (getRowCount() == 0) {
    4894             // Short-circuit empty table model
    4895             if (SwingConstants.VERTICAL == orientation) {
    4896                 int rh = getRowHeight();
    4897                 return (rh > 0) ? Math.max(rh, (visibleRect.height / rh) * rh) :
    4898                                   visibleRect.height;
    4899             }
    4900             else {
    4901                 return visibleRect.width;
    4902             }
    4903         }
    4904         // Shortcut for vertical scrolling of a table w/ uniform row height
    4905         if (null == rowModel && SwingConstants.VERTICAL == orientation) {
    4906             int row = rowAtPoint(visibleRect.getLocation());
    4907             assert row != -1;
    4908             int col = columnAtPoint(visibleRect.getLocation());
    4909             Rectangle cellRect = getCellRect(row, col, true);
    4910
    4911             if (cellRect.y == visibleRect.y) {
    4912                 int rh = getRowHeight();
    4913                 assert rh > 0;
    4914                 return Math.max(rh, (visibleRect.height / rh) * rh);
    4915             }
    4916         }
    4917         if (direction < 0) {
    4918             return getPreviousBlockIncrement(visibleRect, orientation);
    4919         }
    4920         else {
    4921             return getNextBlockIncrement(visibleRect, orientation);
    4922         }
    4923     }
    4924
    4925     /**
    4926      * Called to get the block increment for upward scrolling in cases of
    4927      * horizontal scrolling, or for vertical scrolling of a table with
    4928      * variable row heights.
    4929      */
    4930     private int getPreviousBlockIncrement(Rectangle visibleRect,
    4931                                           int orientation) {
    4932         // Measure back from visible leading edge
    4933         // If we hit the cell on its leading edge, it becomes the leading cell.
    4934         // Else, use following cell
    4935
    4936         int row;
    4937         int col;
    4938
    4939         int   newEdge;
    4940         Point newCellLoc;
    4941
    4942         int visibleLeadingEdge = leadingEdge(visibleRect, orientation);
    4943         boolean leftToRight = getComponentOrientation().isLeftToRight();
    4944         int newLeadingEdge;
    4945
    4946         // Roughly determine the new leading edge by measuring back from the
    4947         // leading visible edge by the size of the visible rect, and find the
    4948         // cell there.
    4949         if (orientation == SwingConstants.VERTICAL) {
    4950             newEdge = visibleLeadingEdge - visibleRect.height;
    4951             int x = visibleRect.x + (leftToRight ? 0 : visibleRect.width);
    4952             newCellLoc = new Point(x, newEdge);
    4953         }
    4954         else if (leftToRight) {
    4955             newEdge = visibleLeadingEdge - visibleRect.width;
    4956             newCellLoc = new Point(newEdge, visibleRect.y);
    4957         }
    4958         else { // Horizontal, right-to-left
    4959             newEdge = visibleLeadingEdge + visibleRect.width;
    4960             newCellLoc = new Point(newEdge - 1, visibleRect.y);
    4961         }
    4962         row = rowAtPoint(newCellLoc);
    4963         col = columnAtPoint(newCellLoc);
    4964
    4965         // If we're measuring past the beginning of the table, we get an invalid
    4966         // cell.  Just go to the beginning of the table in this case.
    4967         if (orientation == SwingConstants.VERTICAL & row < 0) {
    4968             newLeadingEdge = 0;
    4969         }
    4970         else if (orientation == SwingConstants.HORIZONTAL & col < 0) {
    4971             if (leftToRight) {
    4972                 newLeadingEdge = 0;
    4973             }
    4974             else {
    4975                 newLeadingEdge = getWidth();
    4976             }
    4977         }
    4978         else {
    4979             // Refine our measurement
    4980             Rectangle newCellRect = getCellRect(row, col, true);
    4981             int newCellLeadingEdge = leadingEdge(newCellRect, orientation);
    4982             int newCellTrailingEdge = trailingEdge(newCellRect, orientation);
    4983
    4984             // Usually, we hit in the middle of newCell, and want to scroll to
    4985             // the beginning of the cell after newCell.  But there are a
    4986             // couple corner cases where we want to scroll to the beginning of
    4987             // newCell itself.  These cases are:
    4988             // 1) newCell is so large that it ends at or extends into the
    4989             //    visibleRect (newCell is the leading cell, or is adjacent to
    4990             //    the leading cell)
    4991             // 2) newEdge happens to fall right on the beginning of a cell
    4992
    4993             // Case 1
    4994             if ((orientation == SwingConstants.VERTICAL || leftToRight) &&
    4995                 (newCellTrailingEdge >= visibleLeadingEdge)) {
    4996                 newLeadingEdge = newCellLeadingEdge;
    4997             }
    4998             else if (orientation == SwingConstants.HORIZONTAL &&
    4999                      !leftToRight &&
    5000                      newCellTrailingEdge <= visibleLeadingEdge) {
    5001                 newLeadingEdge = newCellLeadingEdge;
    5002             }
    5003             // Case 2:
    5004             else if (newEdge == newCellLeadingEdge) {
    5005                 newLeadingEdge = newCellLeadingEdge;
    5006             }
    5007             // Common case: scroll to cell after newCell
    5008             else {
    5009                 newLeadingEdge = newCellTrailingEdge;
    5010             }
    5011         }
    5012         return Math.abs(visibleLeadingEdge - newLeadingEdge);
    5013     }
    5014
    5015     /**
    5016      * Called to get the block increment for downward scrolling in cases of
    5017      * horizontal scrolling, or for vertical scrolling of a table with
    5018      * variable row heights.
    5019      */
    5020     private int getNextBlockIncrement(Rectangle visibleRect,
    5021                                       int orientation) {
    5022         // Find the cell at the trailing edge.  Return the distance to put
    5023         // that cell at the leading edge.
    5024         int trailingRow = getTrailingRow(visibleRect);
    5025         int trailingCol = getTrailingCol(visibleRect);
    5026
    5027         Rectangle cellRect;
    5028         boolean cellFillsVis;
    5029
    5030         int cellLeadingEdge;
    5031         int cellTrailingEdge;
    5032         int newLeadingEdge;
    5033         int visibleLeadingEdge = leadingEdge(visibleRect, orientation);
    5034
    5035         // If we couldn't find trailing cell, just return the size of the
    5036         // visibleRect.  Note that, for instance, we don't need the
    5037         // trailingCol to proceed if we're scrolling vertically, because
    5038         // cellRect will still fill in the required dimensions.  This would
    5039         // happen if we're scrolling vertically, and the table is not wide
    5040         // enough to fill the visibleRect.
    5041         if (orientation == SwingConstants.VERTICAL && trailingRow < 0) {
    5042             return visibleRect.height;
    5043         }
    5044         else if (orientation == SwingConstants.HORIZONTAL && trailingCol < 0) {
    5045             return visibleRect.width;
    5046         }
    5047         cellRect = getCellRect(trailingRow, trailingCol, true);
    5048         cellLeadingEdge = leadingEdge(cellRect, orientation);
    5049         cellTrailingEdge = trailingEdge(cellRect, orientation);
    5050
    5051         if (orientation == SwingConstants.VERTICAL ||
    5052             getComponentOrientation().isLeftToRight()) {
    5053             cellFillsVis = cellLeadingEdge <= visibleLeadingEdge;
    5054         }
    5055         else { // Horizontal, right-to-left
    5056             cellFillsVis = cellLeadingEdge >= visibleLeadingEdge;
    5057         }
    5058
    5059         if (cellFillsVis) {
    5060             // The visibleRect contains a single large cell.  Scroll to the end
    5061             // of this cell, so the following cell is the first cell.
    5062             newLeadingEdge = cellTrailingEdge;
    5063         }
    5064         else if (cellTrailingEdge == trailingEdge(visibleRect, orientation)) {
    5065             // The trailing cell happens to end right at the end of the
    5066             // visibleRect.  Again, scroll to the beginning of the next cell.
    5067             newLeadingEdge = cellTrailingEdge;
    5068         }
    5069         else {
    5070             // Common case: the trailing cell is partially visible, and isn't
    5071             // big enough to take up the entire visibleRect.  Scroll so it
    5072             // becomes the leading cell.
    5073             newLeadingEdge = cellLeadingEdge;
    5074         }
    5075         return Math.abs(newLeadingEdge - visibleLeadingEdge);
    5076     }
    5077
    5078     /*
    5079      * Return the row at the top of the visibleRect
    5080      *
    5081      * May return -1
    5082      */
    5083     private int getLeadingRow(Rectangle visibleRect) {
    5084         Point leadingPoint;
    5085
    5086         if (getComponentOrientation().isLeftToRight()) {
    5087             leadingPoint = new Point(visibleRect.x, visibleRect.y);
    5088         }
    5089         else {
    5090             leadingPoint = new Point(visibleRect.x + visibleRect.width - 1,
    5091                                      visibleRect.y);
    5092         }
    5093         return rowAtPoint(leadingPoint);
    5094     }
    5095
    5096     /*
    5097      * Return the column at the leading edge of the visibleRect.
    5098      *
    5099      * May return -1
    5100      */
    5101     private int getLeadingCol(Rectangle visibleRect) {
    5102         Point leadingPoint;
    5103
    5104         if (getComponentOrientation().isLeftToRight()) {
    5105             leadingPoint = new Point(visibleRect.x, visibleRect.y);
    5106         }
    5107         else {
    5108             leadingPoint = new Point(visibleRect.x + visibleRect.width - 1,
    5109                                      visibleRect.y);
    5110         }
    5111         return columnAtPoint(leadingPoint);
    5112     }
    5113
    5114     /*
    5115      * Return the row at the bottom of the visibleRect.
    5116      *
    5117      * May return -1
    5118      */
    5119     private int getTrailingRow(Rectangle visibleRect) {
    5120         Point trailingPoint;
    5121
    5122         if (getComponentOrientation().isLeftToRight()) {
    5123             trailingPoint = new Point(visibleRect.x,
    5124                                       visibleRect.y + visibleRect.height - 1);
    5125         }
    5126         else {
    5127             trailingPoint = new Point(visibleRect.x + visibleRect.width - 1,
    5128                                       visibleRect.y + visibleRect.height - 1);
    5129         }
    5130         return rowAtPoint(trailingPoint);
    5131     }
    5132
    5133     /*
    5134      * Return the column at the trailing edge of the visibleRect.
    5135      *
    5136      * May return -1
    5137      */
    5138     private int getTrailingCol(Rectangle visibleRect) {
    5139         Point trailingPoint;
    5140
    5141         if (getComponentOrientation().isLeftToRight()) {
    5142             trailingPoint = new Point(visibleRect.x + visibleRect.width - 1,
    5143                                       visibleRect.y);
    5144         }
    5145         else {
    5146             trailingPoint = new Point(visibleRect.x, visibleRect.y);
    5147         }
    5148         return columnAtPoint(trailingPoint);
    5149     }
    5150
    5151     /*
    5152      * Returns the leading edge ("beginning") of the given Rectangle.
    5153      * For VERTICAL, this is the top, for left-to-right, the left side, and for
    5154      * right-to-left, the right side.
    5155      */
    5156     private int leadingEdge(Rectangle rect, int orientation) {
    5157         if (orientation == SwingConstants.VERTICAL) {
    5158             return rect.y;
    5159         }
    5160         else if (getComponentOrientation().isLeftToRight()) {
    5161             return rect.x;
    5162         }
    5163         else { // Horizontal, right-to-left
    5164             return rect.x + rect.width;
    5165         }
    5166     }
    5167
    5168     /*
    5169      * Returns the trailing edge ("end") of the given Rectangle.
    5170      * For VERTICAL, this is the bottom, for left-to-right, the right side, and
    5171      * for right-to-left, the left side.
    5172      */
    5173     private int trailingEdge(Rectangle rect, int orientation) {
    5174         if (orientation == SwingConstants.VERTICAL) {
    5175             return rect.y + rect.height;
    5176         }
    5177         else if (getComponentOrientation().isLeftToRight()) {
    5178             return rect.x + rect.width;
    5179         }
    5180         else { // Horizontal, right-to-left
    5181             return rect.x;
    5182         }
    5183     }
    5184
    5185     /**
    5186      * Returns false if <code>autoResizeMode</code> is set to
    5187      * <code>AUTO_RESIZE_OFF</code>, which indicates that the
    5188      * width of the viewport does not determine the width
    5189      * of the table.  Otherwise returns true.
    5190      *
    5191      * @return false if <code>autoResizeMode</code> is set
    5192      *   to <code>AUTO_RESIZE_OFF</code>, otherwise returns true
    5193      * @see Scrollable#getScrollableTracksViewportWidth
    5194      */
    5195     @BeanProperty(bound = false)
    5196     public boolean getScrollableTracksViewportWidth() {
    5197         return !(autoResizeMode == AUTO_RESIZE_OFF);
    5198     }
    5199
    5200     /**
    5201      * Returns {@code false} to indicate that the height of the viewport does
    5202      * not determine the height of the table, unless
    5203      * {@code getFillsViewportHeight} is {@code true} and the preferred height
    5204      * of the table is smaller than the viewport's height.
    5205      *
    5206      * @return {@code false} unless {@code getFillsViewportHeight} is
    5207      *         {@code true} and the table needs to be stretched to fill
    5208      *         the viewport
    5209      * @see Scrollable#getScrollableTracksViewportHeight
    5210      * @see #setFillsViewportHeight
    5211      * @see #getFillsViewportHeight
    5212      */
    5213     @BeanProperty(bound = false)
    5214     public boolean getScrollableTracksViewportHeight() {
    5215         Container parent = SwingUtilities.getUnwrappedParent(this);
    5216         return getFillsViewportHeight()
    5217                && parent instanceof JViewport
    5218                && parent.getHeight() > getPreferredSize().height;
    5219     }
    5220
    5221     /**
    5222      * Sets whether or not this table is always made large enough
    5223      * to fill the height of an enclosing viewport. If the preferred
    5224      * height of the table is smaller than the viewport, then the table
    5225      * will be stretched to fill the viewport. In other words, this
    5226      * ensures the table is never smaller than the viewport.
    5227      * The default for this property is {@code false}.
    5228      *
    5229      * @param fillsViewportHeight whether or not this table is always
    5230      *        made large enough to fill the height of an enclosing
    5231      *        viewport
    5232      * @see #getFillsViewportHeight
    5233      * @see #getScrollableTracksViewportHeight
    5234      * @since 1.6
    5235      */
    5236     @BeanProperty(description
    5237             = "Whether or not this table is always made large enough to fill the height of an enclosing viewport")
    5238     public void setFillsViewportHeight(boolean fillsViewportHeight) {
    5239         boolean old = this.fillsViewportHeight;
    5240         this.fillsViewportHeight = fillsViewportHeight;
    5241         resizeAndRepaint();
    5242         firePropertyChange("fillsViewportHeight", old, fillsViewportHeight);
    5243     }
    5244
    5245     /**
    5246      * Returns whether or not this table is always made large enough
    5247      * to fill the height of an enclosing viewport.
    5248      *
    5249      * @return whether or not this table is always made large enough
    5250      *         to fill the height of an enclosing viewport
    5251      * @see #setFillsViewportHeight
    5252      * @since 1.6
    5253      */
    5254     public boolean getFillsViewportHeight() {
    5255         return fillsViewportHeight;
    5256     }
    5257
    5258 //
    5259 // Protected Methods
    5260 //
    5261
    5262     protected boolean processKeyBinding(KeyStroke ks, KeyEvent e,
    5263                                         int condition, boolean pressed) {
    5264         boolean retValue = super.processKeyBinding(ks, e, condition, pressed);
    5265
    5266         // Start editing when a key is typed. UI classes can disable this behavior
    5267         // by setting the client property JTable.autoStartsEdit to Boolean.FALSE.
    5268         if (!retValue && condition == WHEN_ANCESTOR_OF_FOCUSED_COMPONENT &&
    5269             isFocusOwner() &&
    5270             !Boolean.FALSE.equals(getClientProperty("JTable.autoStartsEdit"))) {
    5271             // We do not have a binding for the event.
    5272             Component editorComponent = getEditorComponent();
    5273             if (editorComponent == null) {
    5274                 // Only attempt to install the editor on a KEY_PRESSED,
    5275                 if (e == null || e.getID() != KeyEvent.KEY_PRESSED) {
    5276                     return false;
    5277                 }
    5278                 // Don't start when just a modifier is pressed
    5279                 int code = e.getKeyCode();
    5280                 if (code == KeyEvent.VK_SHIFT || code == KeyEvent.VK_CONTROL ||
    5281                     code == KeyEvent.VK_ALT) {
    5282                     return false;
    5283                 }
    5284                 // Try to install the editor
    5285                 int leadRow = getSelectionModel().getLeadSelectionIndex();
    5286                 int leadColumn = getColumnModel().getSelectionModel().
    5287                                    getLeadSelectionIndex();
    5288                 if (leadRow != -1 && leadColumn != -1 && !isEditing()) {
    5289                     if (!editCellAt(leadRow, leadColumn, e)) {
    5290                         return false;
    5291                     }
    5292                 }
    5293                 editorComponent = getEditorComponent();
    5294                 if (editorComponent == null) {
    5295                     return false;
    5296                 }
    5297             }
    5298             // If the editorComponent is a JComponent, pass the event to it.
    5299             if (editorComponent instanceof JComponent) {
    5300                 retValue = ((JComponent)editorComponent).processKeyBinding
    5301                                         (ks, e, WHEN_FOCUSED, pressed);
    5302                 // If we have started an editor as a result of the user
    5303                 // pressing a key and the surrendersFocusOnKeystroke property
    5304                 // is true, give the focus to the new editor.
    5305                 if (getSurrendersFocusOnKeystroke()) {
    5306                     editorComponent.requestFocus();
    5307                 }
    5308             }
    5309         }
    5310         return retValue;
    5311     }
    5312
    5313     /**
    5314      * Creates default cell renderers for objects, numbers, doubles, dates,
    5315      * booleans, and icons.
    5316      * @see javax.swing.table.DefaultTableCellRenderer
    5317      *
    5318      */
    5319     protected void createDefaultRenderers() {
    5320         defaultRenderersByColumnClass = new UIDefaults(8, 0.75f);
    5321
    5322         // Objects
    5323         defaultRenderersByColumnClass.put(Object.class, (UIDefaults.LazyValue)
    5324                 t -> new DefaultTableCellRenderer.UIResource());
    5325
    5326         // Numbers
    5327         defaultRenderersByColumnClass.put(Number.class, (UIDefaults.LazyValue)
    5328                 t -> new NumberRenderer());
    5329
    5330         // Doubles and Floats
    5331         defaultRenderersByColumnClass.put(Float.class, (UIDefaults.LazyValue)
    5332                 t -> new DoubleRenderer());
    5333         defaultRenderersByColumnClass.put(Double.class, (UIDefaults.LazyValue)
    5334                 t -> new DoubleRenderer());
    5335
    5336         // Dates
    5337         defaultRenderersByColumnClass.put(Date.class, (UIDefaults.LazyValue)
    5338                 t -> new DateRenderer());
    5339
    5340         // Icons and ImageIcons
    5341         defaultRenderersByColumnClass.put(Icon.class, (UIDefaults.LazyValue)
    5342                 t -> new IconRenderer());
    5343         defaultRenderersByColumnClass.put(ImageIcon.class, (UIDefaults.LazyValue)
    5344                 t -> new IconRenderer());
    5345
    5346         // Booleans
    5347         defaultRenderersByColumnClass.put(Boolean.class, (UIDefaults.LazyValue)
    5348                 t -> new BooleanRenderer());
    5349     }
    5350
    5351     /**
    5352      * Default Renderers
    5353      **/
    5354     static class NumberRenderer extends DefaultTableCellRenderer.UIResource {
    5355         public NumberRenderer() {
    5356             super();
    5357             setHorizontalAlignment(JLabel.RIGHT);
    5358         }
    5359     }
    5360
    5361     static class DoubleRenderer extends NumberRenderer {
    5362         NumberFormat formatter;
    5363         public DoubleRenderer() { super(); }
    5364
    5365         public void setValue(Object value) {
    5366             if (formatter == null) {
    5367                 formatter = NumberFormat.getInstance();
    5368             }
    5369             setText((value == null) ? "" : formatter.format(value));
    5370         }
    5371     }
    5372
    5373     static class DateRenderer extends DefaultTableCellRenderer.UIResource {
    5374         DateFormat formatter;
    5375         public DateRenderer() { super(); }
    5376
    5377         public void setValue(Object value) {
    5378             if (formatter==null) {
    5379                 formatter = DateFormat.getDateInstance();
    5380             }
    5381             setText((value == null) ? "" : formatter.format(value));
    5382         }
    5383     }
    5384
    5385     static class IconRenderer extends DefaultTableCellRenderer.UIResource {
    5386         public IconRenderer() {
    5387             super();
    5388             setHorizontalAlignment(JLabel.CENTER);
    5389         }
    5390         public void setValue(Object value) { setIcon((value instanceof Icon) ? (Icon)value : null); }
    5391     }
    5392
    5393
    5394     static class BooleanRenderer extends JCheckBox implements TableCellRenderer, UIResource
    5395     {
    5396         private static final Border noFocusBorder = new EmptyBorder(1, 1, 1, 1);
    5397
    5398         public BooleanRenderer() {
    5399             super();
    5400             setHorizontalAlignment(JLabel.CENTER);
    5401             setBorderPainted(true);
    5402         }
    5403
    5404         public Component getTableCellRendererComponent(JTable table, Object value,
    5405                                                        boolean isSelected, boolean hasFocus, int row, int column) {
    5406             if (isSelected) {
    5407                 setForeground(table.getSelectionForeground());
    5408                 super.setBackground(table.getSelectionBackground());
    5409             }
    5410             else {
    5411                 setForeground(table.getForeground());
    5412                 setBackground(table.getBackground());
    5413             }
    5414             setSelected((value != null && ((Boolean)value).booleanValue()));
    5415
    5416             if (hasFocus) {
    5417                 setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
    5418             } else {
    5419                 setBorder(noFocusBorder);
    5420             }
    5421
    5422             return this;
    5423         }
    5424     }
    5425
    5426     /**
    5427      * Creates default cell editors for objects, numbers, and boolean values.
    5428      * @see DefaultCellEditor
    5429      */
    5430     protected void createDefaultEditors() {
    5431         defaultEditorsByColumnClass = new UIDefaults(3, 0.75f);
    5432
    5433         // Objects
    5434         defaultEditorsByColumnClass.put(Object.class, (UIDefaults.LazyValue)
    5435                 t -> new GenericEditor());
    5436
    5437         // Numbers
    5438         defaultEditorsByColumnClass.put(Number.class, (UIDefaults.LazyValue)
    5439                 t -> new NumberEditor());
    5440
    5441         // Booleans
    5442         defaultEditorsByColumnClass.put(Boolean.class, (UIDefaults.LazyValue)
    5443                 t -> new BooleanEditor());
    5444     }
    5445
    5446     /**
    5447      * Default Editors
    5448      */
    5449     static class GenericEditor extends DefaultCellEditor {
    5450
    5451         Class<?>[] argTypes = new Class<?>[]{String.class};
    5452         java.lang.reflect.Constructor<?> constructor;
    5453         Object value;
    5454
    5455         public GenericEditor() {
    5456             super(new JTextField());
    5457             getComponent().setName("Table.editor");
    5458         }
    5459
    5460         public boolean stopCellEditing() {
    5461             String s = (String)super.getCellEditorValue();
    5462             // Here we are dealing with the case where a user
    5463             // has deleted the string value in a cell, possibly
    5464             // after a failed validation. Return null, so that
    5465             // they have the option to replace the value with
    5466             // null or use escape to restore the original.
    5467             // For Strings, return "" for backward compatibility.
    5468             try {
    5469                 if ("".equals(s)) {
    5470                     if (constructor.getDeclaringClass() == String.class) {
    5471                         value = s;
    5472                     }
    5473                     return super.stopCellEditing();
    5474                 }
    5475
    5476                 SwingUtilities2.checkAccess(constructor.getModifiers());
    5477                 value = constructor.newInstance(new Object[]{s});
    5478             }
    5479             catch (Exception e) {
    5480                 ((JComponent)getComponent()).setBorder(new LineBorder(Color.red));
    5481                 return false;
    5482             }
    5483             return super.stopCellEditing();
    5484         }
    5485
    5486         public Component getTableCellEditorComponent(JTable table, Object value,
    5487                                                  boolean isSelected,
    5488                                                  int row, int column) {
    5489             this.value = null;
    5490             ((JComponent)getComponent()).setBorder(new LineBorder(Color.black));
    5491             try {
    5492                 Class<?> type = table.getColumnClass(column);
    5493                 // Since our obligation is to produce a value which is
    5494                 // assignable for the required type it is OK to use the
    5495                 // String constructor for columns which are declared
    5496                 // to contain Objects. A String is an Object.
    5497                 if (type == Object.class) {
    5498                     type = String.class;
    5499                 }
    5500                 ReflectUtil.checkPackageAccess(type);
    5501                 SwingUtilities2.checkAccess(type.getModifiers());
    5502                 constructor = type.getConstructor(argTypes);
    5503             }
    5504             catch (Exception e) {
    5505                 return null;
    5506             }
    5507             return super.getTableCellEditorComponent(table, value, isSelected, row, column);
    5508         }
    5509
    5510         public Object getCellEditorValue() {
    5511             return value;
    5512         }
    5513     }
    5514
    5515     static class NumberEditor extends GenericEditor {
    5516
    5517         public NumberEditor() {
    5518             ((JTextField)getComponent()).setHorizontalAlignment(JTextField.RIGHT);
    5519         }
    5520     }
    5521
    5522     static class BooleanEditor extends DefaultCellEditor {
    5523         public BooleanEditor() {
    5524             super(new JCheckBox());
    5525             JCheckBox checkBox = (JCheckBox)getComponent();
    5526             checkBox.setHorizontalAlignment(JCheckBox.CENTER);
    5527         }
    5528     }
    5529
    5530     /**
    5531      * Initializes table properties to their default values.
    5532      */
    5533     protected void initializeLocalVars() {
    5534         updateSelectionOnSort = true;
    5535         setOpaque(true);
    5536         createDefaultRenderers();
    5537         createDefaultEditors();
    5538
    5539         setTableHeader(createDefaultTableHeader());
    5540
    5541         setShowGrid(true);
    5542         setAutoResizeMode(AUTO_RESIZE_SUBSEQUENT_COLUMNS);
    5543         setRowHeight(16);
    5544         isRowHeightSet = false;
    5545         setRowMargin(1);
    5546         setRowSelectionAllowed(true);
    5547         setCellEditor(null);
    5548         setEditingColumn(-1);
    5549         setEditingRow(-1);
    5550         setSurrendersFocusOnKeystroke(false);
    5551         setPreferredScrollableViewportSize(new Dimension(450, 400));
    5552
    5553         // I'm registered to do tool tips so we can draw tips for the renderers
    5554         ToolTipManager toolTipManager = ToolTipManager.sharedInstance();
    5555         toolTipManager.registerComponent(this);
    5556
    5557         setAutoscrolls(true);
    5558     }
    5559
    5560     /**
    5561      * Returns the default table model object, which is
    5562      * a <code>DefaultTableModel</code>.  A subclass can override this
    5563      * method to return a different table model object.
    5564      *
    5565      * @return the default table model object
    5566      * @see javax.swing.table.DefaultTableModel
    5567      */
    5568     protected TableModel createDefaultDataModel() {
    5569         return new DefaultTableModel();
    5570     }
    5571
    5572     /**
    5573      * Returns the default column model object, which is
    5574      * a <code>DefaultTableColumnModel</code>.  A subclass can override this
    5575      * method to return a different column model object.
    5576      *
    5577      * @return the default column model object
    5578      * @see javax.swing.table.DefaultTableColumnModel
    5579      */
    5580     protected TableColumnModel createDefaultColumnModel() {
    5581         return new DefaultTableColumnModel();
    5582     }
    5583
    5584     /**
    5585      * Returns the default selection model object, which is
    5586      * a <code>DefaultListSelectionModel</code>.  A subclass can override this
    5587      * method to return a different selection model object.
    5588      *
    5589      * @return the default selection model object
    5590      * @see javax.swing.DefaultListSelectionModel
    5591      */
    5592     protected ListSelectionModel createDefaultSelectionModel() {
    5593         return new DefaultListSelectionModel();
    5594     }
    5595
    5596     /**
    5597      * Returns the default table header object, which is
    5598      * a <code>JTableHeader</code>.  A subclass can override this
    5599      * method to return a different table header object.
    5600      *
    5601      * @return the default table header object
    5602      * @see javax.swing.table.JTableHeader
    5603      */
    5604     protected JTableHeader createDefaultTableHeader() {
    5605         return new JTableHeader(columnModel);
    5606     }
    5607
    5608     /**
    5609      * Equivalent to <code>revalidate</code> followed by <code>repaint</code>.
    5610      */
    5611     protected void resizeAndRepaint() {
    5612         revalidate();
    5613         repaint();
    5614     }
    5615
    5616     /**
    5617      * Returns the active cell editor, which is {@code null} if the table
    5618      * is not currently editing.
    5619      *
    5620      * @return the {@code TableCellEditor} that does the editing,
    5621      *         or {@code null} if the table is not currently editing.
    5622      * @see #cellEditor
    5623      * @see #getCellEditor(int, int)
    5624      */
    5625     public TableCellEditor getCellEditor() {
    5626         return cellEditor;
    5627     }
    5628
    5629     /**
    5630      * Sets the active cell editor.
    5631      *
    5632      * @param anEditor the active cell editor
    5633      * @see #cellEditor
    5634      */
    5635     @BeanProperty(description
    5636             = "The table's active cell editor.")
    5637     public void setCellEditor(TableCellEditor anEditor) {
    5638         TableCellEditor oldEditor = cellEditor;
    5639         cellEditor = anEditor;
    5640         firePropertyChange("tableCellEditor", oldEditor, anEditor);
    5641     }
    5642
    5643     /**
    5644      * Sets the <code>editingColumn</code> variable.
    5645      * @param aColumn  the column of the cell to be edited
    5646      *
    5647      * @see #editingColumn
    5648      */
    5649     public void setEditingColumn(int aColumn) {
    5650         editingColumn = aColumn;
    5651     }
    5652
    5653     /**
    5654      * Sets the <code>editingRow</code> variable.
    5655      * @param aRow  the row of the cell to be edited
    5656      *
    5657      * @see #editingRow
    5658      */
    5659     public void setEditingRow(int aRow) {
    5660         editingRow = aRow;
    5661     }
    5662
    5663     /**
    5664      * Returns an appropriate renderer for the cell specified by this row and
    5665      * column. If the <code>TableColumn</code> for this column has a non-null
    5666      * renderer, returns that.  If not, finds the class of the data in
    5667      * this column (using <code>getColumnClass</code>)
    5668      * and returns the default renderer for this type of data.
    5669      * <p>
    5670      * <b>Note:</b>
    5671      * Throughout the table package, the internal implementations always
    5672      * use this method to provide renderers so that this default behavior
    5673      * can be safely overridden by a subclass.
    5674      *
    5675      * @param row       the row of the cell to render, where 0 is the first row
    5676      * @param column    the column of the cell to render,
    5677      *                  where 0 is the first column
    5678      * @return the assigned renderer; if <code>null</code>
    5679      *                  returns the default renderer
    5680      *                  for this type of object
    5681      * @see javax.swing.table.DefaultTableCellRenderer
    5682      * @see javax.swing.table.TableColumn#setCellRenderer
    5683      * @see #setDefaultRenderer
    5684      */
    5685     public TableCellRenderer getCellRenderer(int row, int column) {
    5686         TableColumn tableColumn = getColumnModel().getColumn(column);
    5687         TableCellRenderer renderer = tableColumn.getCellRenderer();
    5688         if (renderer == null) {
    5689             renderer = getDefaultRenderer(getColumnClass(column));
    5690         }
    5691         return renderer;
    5692     }
    5693
    5694     /**
    5695      * Prepares the renderer by querying the data model for the
    5696      * value and selection state
    5697      * of the cell at <code>row</code>, <code>column</code>.
    5698      * Returns the component (may be a <code>Component</code>
    5699      * or a <code>JComponent</code>) under the event location.
    5700      * <p>
    5701      * During a printing operation, this method will configure the
    5702      * renderer without indicating selection or focus, to prevent
    5703      * them from appearing in the printed output. To do other
    5704      * customizations based on whether or not the table is being
    5705      * printed, you can check the value of
    5706      * {@link javax.swing.JComponent#isPaintingForPrint()}, either here
    5707      * or within custom renderers.
    5708      * <p>
    5709      * <b>Note:</b>
    5710      * Throughout the table package, the internal implementations always
    5711      * use this method to prepare renderers so that this default behavior
    5712      * can be safely overridden by a subclass.
    5713      *
    5714      * @param renderer  the <code>TableCellRenderer</code> to prepare
    5715      * @param row       the row of the cell to render, where 0 is the first row
    5716      * @param column    the column of the cell to render,
    5717      *                  where 0 is the first column
    5718      * @return          the <code>Component</code> under the event location
    5719      */
    5720     public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
    5721         Object value = getValueAt(row, column);
    5722
    5723         boolean isSelected = false;
    5724         boolean hasFocus = false;
    5725
    5726         // Only indicate the selection and focused cell if not printing
    5727         if (!isPaintingForPrint()) {
    5728             isSelected = isCellSelected(row, column);
    5729
    5730             boolean rowIsLead =
    5731                 (selectionModel.getLeadSelectionIndex() == row);
    5732             boolean colIsLead =
    5733                 (columnModel.getSelectionModel().getLeadSelectionIndex() == column);
    5734
    5735             hasFocus = (rowIsLead && colIsLead) && isFocusOwner();
    5736         }
    5737
    5738         return renderer.getTableCellRendererComponent(this, value,
    5739                                                       isSelected, hasFocus,
    5740                                                       row, column);
    5741     }
    5742
    5743     /**
    5744      * Returns an appropriate editor for the cell specified by
    5745      * <code>row</code> and <code>column</code>. If the
    5746      * <code>TableColumn</code> for this column has a non-null editor,
    5747      * returns that.  If not, finds the class of the data in this
    5748      * column (using <code>getColumnClass</code>)
    5749      * and returns the default editor for this type of data.
    5750      * <p>
    5751      * <b>Note:</b>
    5752      * Throughout the table package, the internal implementations always
    5753      * use this method to provide editors so that this default behavior
    5754      * can be safely overridden by a subclass.
    5755      *
    5756      * @param row       the row of the cell to edit, where 0 is the first row
    5757      * @param column    the column of the cell to edit,
    5758      *                  where 0 is the first column
    5759      * @return          the editor for this cell;
    5760      *                  if <code>null</code> return the default editor for
    5761      *                  this type of cell
    5762      * @see DefaultCellEditor
    5763      */
    5764     public TableCellEditor getCellEditor(int row, int column) {
    5765         TableColumn tableColumn = getColumnModel().getColumn(column);
    5766         TableCellEditor editor = tableColumn.getCellEditor();
    5767         if (editor == null) {
    5768             editor = getDefaultEditor(getColumnClass(column));
    5769         }
    5770         return editor;
    5771     }
    5772
    5773
    5774     /**
    5775      * Prepares the editor by querying the data model for the value and
    5776      * selection state of the cell at <code>row</code>, <code>column</code>.
    5777      * <p>
    5778      * <b>Note:</b>
    5779      * Throughout the table package, the internal implementations always
    5780      * use this method to prepare editors so that this default behavior
    5781      * can be safely overridden by a subclass.
    5782      *
    5783      * @param editor  the <code>TableCellEditor</code> to set up
    5784      * @param row     the row of the cell to edit,
    5785      *                where 0 is the first row
    5786      * @param column  the column of the cell to edit,
    5787      *                where 0 is the first column
    5788      * @return the <code>Component</code> being edited
    5789      */
    5790     @SuppressWarnings("deprecation")
    5791     public Component prepareEditor(TableCellEditor editor, int row, int column) {
    5792         Object value = getValueAt(row, column);
    5793         boolean isSelected = isCellSelected(row, column);
    5794         Component comp = editor.getTableCellEditorComponent(this, value, isSelected,
    5795                                                   row, column);
    5796         if (comp instanceof JComponent) {
    5797             JComponent jComp = (JComponent)comp;
    5798             if (jComp.getNextFocusableComponent() == null) {
    5799                 jComp.setNextFocusableComponent(this);
    5800             }
    5801         }
    5802         return comp;
    5803     }
    5804
    5805     /**
    5806      * Discards the editor object and frees the real estate it used for
    5807      * cell rendering.
    5808      */
    5809     public void removeEditor() {
    5810         KeyboardFocusManager.getCurrentKeyboardFocusManager().
    5811             removePropertyChangeListener("permanentFocusOwner", editorRemover);
    5812         editorRemover = null;
    5813
    5814         TableCellEditor editor = getCellEditor();
    5815         if(editor != null) {
    5816             editor.removeCellEditorListener(this);
    5817             if (editorComp != null) {
    5818                 Component focusOwner =
    5819                         KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
    5820                 boolean isFocusOwnerInTheTable = focusOwner != null?
    5821                         SwingUtilities.isDescendingFrom(focusOwner, this):false;
    5822                 remove(editorComp);
    5823                 if(isFocusOwnerInTheTable) {
    5824                     requestFocusInWindow();
    5825                 }
    5826             }
    5827
    5828             Rectangle cellRect = getCellRect(editingRow, editingColumn, false);
    5829
    5830             setCellEditor(null);
    5831             setEditingColumn(-1);
    5832             setEditingRow(-1);
    5833             editorComp = null;
    5834
    5835             repaint(cellRect);
    5836         }
    5837     }
    5838
    5839 //
    5840 // Serialization
    5841 //
    5842
    5843     /**
    5844      * See readObject() and writeObject() in JComponent for more
    5845      * information about serialization in Swing.
    5846      */
    5847     private void writeObject(ObjectOutputStream s) throws IOException {
    5848         s.defaultWriteObject();
    5849         if (getUIClassID().equals(uiClassID)) {
    5850             byte count = JComponent.getWriteObjCounter(this);
    5851             JComponent.setWriteObjCounter(this, --count);
    5852             if (count == 0 && ui != null) {
    5853                 ui.installUI(this);
    5854             }
    5855         }
    5856     }
    5857
    5858     private void readObject(ObjectInputStream s)
    5859         throws IOException, ClassNotFoundException
    5860     {
    5861         ObjectInputStream.GetField f = s.readFields();
    5862
    5863         TableModel newDataModel = (TableModel) f.get("dataModel", null);
    5864         if (newDataModel == null) {
    5865             throw new InvalidObjectException("Null dataModel");
    5866         }
    5867         dataModel = newDataModel;
    5868
    5869         TableColumnModel newColumnModel = (TableColumnModel) f.get("columnModel", null);
    5870         if (newColumnModel == null) {
    5871             throw new InvalidObjectException("Null columnModel");
    5872         }
    5873         columnModel = newColumnModel;
    5874
    5875         ListSelectionModel newSelectionModel = (ListSelectionModel) f.get("selectionModel", null);
    5876         if (newSelectionModel == null) {
    5877             throw new InvalidObjectException("Null selectionModel");
    5878         }
    5879         selectionModel = newSelectionModel;
    5880
    5881         tableHeader = (JTableHeader) f.get("tableHeader", null);
    5882         int newRowHeight = f.get("rowHeight", 0);
    5883         if (newRowHeight <= 0) {
    5884             throw new InvalidObjectException("Row height less than 1");
    5885         }
    5886         rowHeight = newRowHeight;
    5887
    5888         rowMargin = f.get("rowMargin", 0);
    5889         Color newGridColor = (Color) f.get("gridColor", null);
    5890         if (newGridColor == null) {
    5891             throw new InvalidObjectException("Null gridColor");
    5892         }
    5893         gridColor = newGridColor;
    5894
    5895         showHorizontalLines = f.get("showHorizontalLines", false);
    5896         showVerticalLines = f.get("showVerticalLines", false);
    5897         int newAutoResizeMode = f.get("autoResizeMode", 0);
    5898         if (!isValidAutoResizeMode(newAutoResizeMode)) {
    5899             throw new InvalidObjectException("autoResizeMode is not valid");
    5900         }
    5901         autoResizeMode = newAutoResizeMode;
    5902         autoCreateColumnsFromModel = f.get("autoCreateColumnsFromModel", false);
    5903         preferredViewportSize = (Dimension) f.get("preferredViewportSize", null);
    5904         rowSelectionAllowed = f.get("rowSelectionAllowed", false);
    5905         cellSelectionEnabled = f.get("cellSelectionEnabled", false);
    5906         selectionForeground = (Color) f.get("selectionForeground", null);
    5907         selectionBackground = (Color) f.get("selectionBackground", null);
    5908         rowModel = (SizeSequence) f.get("rowModel", null);
    5909
    5910         boolean newDragEnabled = f.get("dragEnabled", false);
    5911         checkDragEnabled(newDragEnabled);
    5912         dragEnabled = newDragEnabled;
    5913
    5914         surrendersFocusOnKeystroke = f.get("surrendersFocusOnKeystroke", false);
    5915         editorRemover = (PropertyChangeListener) f.get("editorRemover", null);
    5916         columnSelectionAdjusting = f.get("columnSelectionAdjusting", false);
    5917         rowSelectionAdjusting = f.get("rowSelectionAdjusting", false);
    5918         printError = (Throwable) f.get("printError", null);
    5919         isRowHeightSet = f.get("isRowHeightSet", false);
    5920         updateSelectionOnSort = f.get("updateSelectionOnSort", false);
    5921         ignoreSortChange = f.get("ignoreSortChange", false);
    5922         sorterChanged = f.get("sorterChanged", false);
    5923         autoCreateRowSorter = f.get("autoCreateRowSorter", false);
    5924         fillsViewportHeight = f.get("fillsViewportHeight", false);
    5925         DropMode newDropMode = (DropMode) f.get("dropMode",
    5926                 DropMode.USE_SELECTION);
    5927         checkDropMode(newDropMode);
    5928         dropMode = newDropMode;
    5929
    5930         if ((ui != null) && (getUIClassID().equals(uiClassID))) {
    5931             ui.installUI(this);
    5932         }
    5933         createDefaultRenderers();
    5934         createDefaultEditors();
    5935
    5936         // If ToolTipText != null, then the tooltip has already been
    5937         // registered by JComponent.readObject() and we don't want
    5938         // to re-register here
    5939         if (getToolTipText() == null) {
    5940             ToolTipManager.sharedInstance().registerComponent(this);
    5941          }
    5942     }
    5943
    5944     /* Called from the JComponent's EnableSerializationFocusListener to
    5945      * do any Swing-specific pre-serialization configuration.
    5946      */
    5947     void compWriteObjectNotify() {
    5948         super.compWriteObjectNotify();
    5949         // If ToolTipText != null, then the tooltip has already been
    5950         // unregistered by JComponent.compWriteObjectNotify()
    5951         if (getToolTipText() == null) {
    5952             ToolTipManager.sharedInstance().unregisterComponent(this);
    5953         }
    5954     }
    5955
    5956     /**
    5957      * Returns a string representation of this table. This method
    5958      * is intended to be used only for debugging purposes, and the
    5959      * content and format of the returned string may vary between
    5960      * implementations. The returned string may be empty but may not
    5961      * be <code>null</code>.
    5962      *
    5963      * @return  a string representation of this table
    5964      */
    5965     protected String paramString() {
    5966         String gridColorString = (gridColor != null ?
    5967                                   gridColor.toString() : "");
    5968         String showHorizontalLinesString = (showHorizontalLines ?
    5969                                             "true" : "false");
    5970         String showVerticalLinesString = (showVerticalLines ?
    5971                                           "true" : "false");
    5972         String autoResizeModeString;
    5973         if (autoResizeMode == AUTO_RESIZE_OFF) {
    5974             autoResizeModeString = "AUTO_RESIZE_OFF";
    5975         } else if (autoResizeMode == AUTO_RESIZE_NEXT_COLUMN) {
    5976             autoResizeModeString = "AUTO_RESIZE_NEXT_COLUMN";
    5977         } else if (autoResizeMode == AUTO_RESIZE_SUBSEQUENT_COLUMNS) {
    5978             autoResizeModeString = "AUTO_RESIZE_SUBSEQUENT_COLUMNS";
    5979         } else if (autoResizeMode == AUTO_RESIZE_LAST_COLUMN) {
    5980             autoResizeModeString = "AUTO_RESIZE_LAST_COLUMN";
    5981         } else if (autoResizeMode == AUTO_RESIZE_ALL_COLUMNS)  {
    5982             autoResizeModeString = "AUTO_RESIZE_ALL_COLUMNS";
    5983         } else autoResizeModeString = "";
    5984         String autoCreateColumnsFromModelString = (autoCreateColumnsFromModel ?
    5985                                                    "true" : "false");
    5986         String preferredViewportSizeString = (preferredViewportSize != null ?
    5987                                               preferredViewportSize.toString()
    5988                                               : "");
    5989         String rowSelectionAllowedString = (rowSelectionAllowed ?
    5990                                             "true" : "false");
    5991         String cellSelectionEnabledString = (cellSelectionEnabled ?
    5992                                             "true" : "false");
    5993         String selectionForegroundString = (selectionForeground != null ?
    5994                                             selectionForeground.toString() :
    5995                                             "");
    5996         String selectionBackgroundString = (selectionBackground != null ?
    5997                                             selectionBackground.toString() :
    5998                                             "");
    5999
    6000         return super.paramString() +
    6001         ",autoCreateColumnsFromModel=" + autoCreateColumnsFromModelString +
    6002         ",autoResizeMode=" + autoResizeModeString +
    6003         ",cellSelectionEnabled=" + cellSelectionEnabledString +
    6004         ",editingColumn=" + editingColumn +
    6005         ",editingRow=" + editingRow +
    6006         ",gridColor=" + gridColorString +
    6007         ",preferredViewportSize=" + preferredViewportSizeString +
    6008         ",rowHeight=" + rowHeight +
    6009         ",rowMargin=" + rowMargin +
    6010         ",rowSelectionAllowed=" + rowSelectionAllowedString +
    6011         ",selectionBackground=" + selectionBackgroundString +
    6012         ",selectionForeground=" + selectionForegroundString +
    6013         ",showHorizontalLines=" + showHorizontalLinesString +
    6014         ",showVerticalLines=" + showVerticalLinesString;
    6015     }
    6016
    6017     // This class tracks changes in the keyboard focus state. It is used
    6018     // when the JTable is editing to determine when to cancel the edit.
    6019     // If focus switches to a component outside of the jtable, but in the
    6020     // same window, this will cancel editing.
    6021     class CellEditorRemover implements PropertyChangeListener {
    6022         KeyboardFocusManager focusManager;
    6023
    6024         public CellEditorRemover(KeyboardFocusManager fm) {
    6025             this.focusManager = fm;
    6026         }
    6027
    6028         @SuppressWarnings("deprecation")
    6029         public void propertyChange(PropertyChangeEvent ev) {
    6030             if (!isEditing() || getClientProperty("terminateEditOnFocusLost") != Boolean.TRUE) {
    6031                 return;
    6032             }
    6033
    6034             Component c = focusManager.getPermanentFocusOwner();
    6035             while (c != null) {
    6036                 if (c == JTable.this) {
    6037                     // focus remains inside the table
    6038                     return;
    6039                 } else if ((c instanceof Window) ||
    6040                            (c instanceof Applet && c.getParent() == null)) {
    6041                     if (c == SwingUtilities.getRoot(JTable.this)) {
    6042                         if (!getCellEditor().stopCellEditing()) {
    6043                             getCellEditor().cancelCellEditing();
    6044                         }
    6045                     }
    6046                     break;
    6047                 }
    6048                 c = c.getParent();
    6049             }
    6050         }
    6051     }
    6052
    6053 /////////////////
    6054 // Printing Support
    6055 /////////////////
    6056
    6057     /**
    6058      * A convenience method that displays a printing dialog, and then prints
    6059      * this <code>JTable</code> in mode <code>PrintMode.FIT_WIDTH</code>,
    6060      * with no header or footer text. A modal progress dialog, with an abort
    6061      * option, will be shown for the duration of printing.
    6062      * <p>
    6063      * Note: In headless mode, no dialogs are shown and printing
    6064      * occurs on the default printer.
    6065      *
    6066      * @return true, unless printing is cancelled by the user
    6067      * @throws SecurityException if this thread is not allowed to
    6068      *                           initiate a print job request
    6069      * @throws PrinterException if an error in the print system causes the job
    6070      *                          to be aborted
    6071      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
    6072      *             boolean, PrintRequestAttributeSet, boolean, PrintService)
    6073      * @see #getPrintable
    6074      *
    6075      * @since 1.5
    6076      */
    6077     public boolean print() throws PrinterException {
    6078
    6079         return print(PrintMode.FIT_WIDTH);
    6080     }
    6081
    6082     /**
    6083      * A convenience method that displays a printing dialog, and then prints
    6084      * this <code>JTable</code> in the given printing mode,
    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      * @param  printMode        the printing mode that the printable should use
    6092      * @return true, unless printing is cancelled by the user
    6093      * @throws SecurityException if this thread is not allowed to
    6094      *                           initiate a print job request
    6095      * @throws PrinterException if an error in the print system causes the job
    6096      *                          to be aborted
    6097      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
    6098      *             boolean, PrintRequestAttributeSet, boolean, PrintService)
    6099      * @see #getPrintable
    6100      *
    6101      * @since 1.5
    6102      */
    6103     public boolean print(PrintMode printMode) throws PrinterException {
    6104
    6105         return print(printMode, null, null);
    6106     }
    6107
    6108     /**
    6109      * A convenience method that displays a printing dialog, and then prints
    6110      * this <code>JTable</code> in the given printing mode,
    6111      * with the specified header and footer text. A modal progress dialog,
    6112      * with an abort option, will be shown for the duration of printing.
    6113      * <p>
    6114      * Note: In headless mode, no dialogs are shown and printing
    6115      * occurs on the default printer.
    6116      *
    6117      * @param  printMode        the printing mode that the printable should use
    6118      * @param  headerFormat     a <code>MessageFormat</code> specifying the text
    6119      *                          to be used in printing a header,
    6120      *                          or null for none
    6121      * @param  footerFormat     a <code>MessageFormat</code> specifying the text
    6122      *                          to be used in printing a footer,
    6123      *                          or null for none
    6124      * @return true, unless printing is cancelled by the user
    6125      * @throws SecurityException if this thread is not allowed to
    6126      *                           initiate a print job request
    6127      * @throws PrinterException if an error in the print system causes the job
    6128      *                          to be aborted
    6129      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
    6130      *             boolean, PrintRequestAttributeSet, boolean, PrintService)
    6131      * @see #getPrintable
    6132      *
    6133      * @since 1.5
    6134      */
    6135     public boolean print(PrintMode printMode,
    6136                          MessageFormat headerFormat,
    6137                          MessageFormat footerFormat) throws PrinterException {
    6138
    6139         boolean showDialogs = !GraphicsEnvironment.isHeadless();
    6140         return print(printMode, headerFormat, footerFormat,
    6141                      showDialogs, null, showDialogs);
    6142     }
    6143
    6144     /**
    6145      * Prints this table, as specified by the fully featured
    6146      * {@link #print(JTable.PrintMode, MessageFormat, MessageFormat,
    6147      * boolean, PrintRequestAttributeSet, boolean, PrintService) print}
    6148      * method, with the default printer specified as the print service.
    6149      *
    6150      * @param  printMode        the printing mode that the printable should use
    6151      * @param  headerFormat     a <code>MessageFormat</code> specifying the text
    6152      *                          to be used in printing a header,
    6153      *                          or <code>null</code> for none
    6154      * @param  footerFormat     a <code>MessageFormat</code> specifying the text
    6155      *                          to be used in printing a footer,
    6156      *                          or <code>null</code> for none
    6157      * @param  showPrintDialog  whether or not to display a print dialog
    6158      * @param  attr             a <code>PrintRequestAttributeSet</code>
    6159      *                          specifying any printing attributes,
    6160      *                          or <code>null</code> for none
    6161      * @param  interactive      whether or not to print in an interactive mode
    6162      * @return true, unless printing is cancelled by the user
    6163      * @throws HeadlessException if the method is asked to show a printing
    6164      *                           dialog or run interactively, and
    6165      *                           <code>GraphicsEnvironment.isHeadless</code>
    6166      *                           returns <code>true</code>
    6167      * @throws SecurityException if this thread is not allowed to
    6168      *                           initiate a print job request
    6169      * @throws PrinterException if an error in the print system causes the job
    6170      *                          to be aborted
    6171      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
    6172      *             boolean, PrintRequestAttributeSet, boolean, PrintService)
    6173      * @see #getPrintable
    6174      *
    6175      * @since 1.5
    6176      */
    6177     public boolean print(PrintMode printMode,
    6178                          MessageFormat headerFormat,
    6179                          MessageFormat footerFormat,
    6180                          boolean showPrintDialog,
    6181                          PrintRequestAttributeSet attr,
    6182                          boolean interactive) throws PrinterException,
    6183                                                      HeadlessException {
    6184
    6185         return print(printMode,
    6186                      headerFormat,
    6187                      footerFormat,
    6188                      showPrintDialog,
    6189                      attr,
    6190                      interactive,
    6191                      null);
    6192     }
    6193
    6194     /**
    6195      * Prints this <code>JTable</code>. Takes steps that the majority of
    6196      * developers would take in order to print a <code>JTable</code>.
    6197      * In short, it prepares the table, calls <code>getPrintable</code> to
    6198      * fetch an appropriate <code>Printable</code>, and then sends it to the
    6199      * printer.
    6200      * <p>
    6201      * A <code>boolean</code> parameter allows you to specify whether or not
    6202      * a printing dialog is displayed to the user. When it is, the user may
    6203      * use the dialog to change the destination printer or printing attributes,
    6204      * or even to cancel the print. Another two parameters allow for a
    6205      * <code>PrintService</code> and printing attributes to be specified.
    6206      * These parameters can be used either to provide initial values for the
    6207      * print dialog, or to specify values when the dialog is not shown.
    6208      * <p>
    6209      * A second <code>boolean</code> parameter allows you to specify whether
    6210      * or not to perform printing in an interactive mode. If <code>true</code>,
    6211      * a modal progress dialog, with an abort option, is displayed for the
    6212      * duration of printing . This dialog also prevents any user action which
    6213      * may affect the table. However, it can not prevent the table from being
    6214      * modified by code (for example, another thread that posts updates using
    6215      * <code>SwingUtilities.invokeLater</code>). It is therefore the
    6216      * responsibility of the developer to ensure that no other code modifies
    6217      * the table in any way during printing (invalid modifications include
    6218      * changes in: size, renderers, or underlying data). Printing behavior is
    6219      * undefined when the table is changed during printing.
    6220      * <p>
    6221      * If <code>false</code> is specified for this parameter, no dialog will
    6222      * be displayed and printing will begin immediately on the event-dispatch
    6223      * thread. This blocks any other events, including repaints, from being
    6224      * processed until printing is complete. Although this effectively prevents
    6225      * the table from being changed, it doesn't provide a good user experience.
    6226      * For this reason, specifying <code>false</code> is only recommended when
    6227      * printing from an application with no visible GUI.
    6228      * <p>
    6229      * Note: Attempting to show the printing dialog or run interactively, while
    6230      * in headless mode, will result in a <code>HeadlessException</code>.
    6231      * <p>
    6232      * Before fetching the printable, this method will gracefully terminate
    6233      * editing, if necessary, to prevent an editor from showing in the printed
    6234      * result. Additionally, <code>JTable</code> will prepare its renderers
    6235      * during printing such that selection and focus are not indicated.
    6236      * As far as customizing further how the table looks in the printout,
    6237      * developers can provide custom renderers or paint code that conditionalize
    6238      * on the value of {@link javax.swing.JComponent#isPaintingForPrint()}.
    6239      * <p>
    6240      * See {@link #getPrintable} for more description on how the table is
    6241      * printed.
    6242      *
    6243      * @param  printMode        the printing mode that the printable should use
    6244      * @param  headerFormat     a <code>MessageFormat</code> specifying the text
    6245      *                          to be used in printing a header,
    6246      *                          or <code>null</code> for none
    6247      * @param  footerFormat     a <code>MessageFormat</code> specifying the text
    6248      *                          to be used in printing a footer,
    6249      *                          or <code>null</code> for none
    6250      * @param  showPrintDialog  whether or not to display a print dialog
    6251      * @param  attr             a <code>PrintRequestAttributeSet</code>
    6252      *                          specifying any printing attributes,
    6253      *                          or <code>null</code> for none
    6254      * @param  interactive      whether or not to print in an interactive mode
    6255      * @param  service          the destination <code>PrintService</code>,
    6256      *                          or <code>null</code> to use the default printer
    6257      * @return true, unless printing is cancelled by the user
    6258      * @throws HeadlessException if the method is asked to show a printing
    6259      *                           dialog or run interactively, and
    6260      *                           <code>GraphicsEnvironment.isHeadless</code>
    6261      *                           returns <code>true</code>
    6262      * @throws  SecurityException if a security manager exists and its
    6263      *          {@link java.lang.SecurityManager#checkPrintJobAccess}
    6264      *          method disallows this thread from creating a print job request
    6265      * @throws PrinterException if an error in the print system causes the job
    6266      *                          to be aborted
    6267      * @see #getPrintable
    6268      * @see java.awt.GraphicsEnvironment#isHeadless
    6269      *
    6270      * @since 1.6
    6271      */
    6272     public boolean print(PrintMode printMode,
    6273                          MessageFormat headerFormat,
    6274                          MessageFormat footerFormat,
    6275                          boolean showPrintDialog,
    6276                          PrintRequestAttributeSet attr,
    6277                          boolean interactive,
    6278                          PrintService service) throws PrinterException,
    6279                                                       HeadlessException {
    6280
    6281         // complain early if an invalid parameter is specified for headless mode
    6282         boolean isHeadless = GraphicsEnvironment.isHeadless();
    6283         if (isHeadless) {
    6284             if (showPrintDialog) {
    6285                 throw new HeadlessException("Can't show print dialog.");
    6286             }
    6287
    6288             if (interactive) {
    6289                 throw new HeadlessException("Can't run interactively.");
    6290             }
    6291         }
    6292
    6293         // Get a PrinterJob.
    6294         // Do this before anything with side-effects since it may throw a
    6295         // security exception - in which case we don't want to do anything else.
    6296         final PrinterJob job = PrinterJob.getPrinterJob();
    6297
    6298         if (isEditing()) {
    6299             // try to stop cell editing, and failing that, cancel it
    6300             if (!getCellEditor().stopCellEditing()) {
    6301                 getCellEditor().cancelCellEditing();
    6302             }
    6303         }
    6304
    6305         if (attr == null) {
    6306             attr = new HashPrintRequestAttributeSet();
    6307         }
    6308
    6309         final PrintingStatus printingStatus;
    6310
    6311          // fetch the Printable
    6312         Printable printable =
    6313              getPrintable(printMode, headerFormat, footerFormat);
    6314
    6315         if (interactive) {
    6316             // wrap the Printable so that we can print on another thread
    6317             printable = new ThreadSafePrintable(printable);
    6318             printingStatus = PrintingStatus.createPrintingStatus(this, job);
    6319             printable = printingStatus.createNotificationPrintable(printable);
    6320         } else {
    6321             // to please compiler
    6322             printingStatus = null;
    6323         }
    6324
    6325         // set the printable on the PrinterJob
    6326         job.setPrintable(printable);
    6327
    6328         // if specified, set the PrintService on the PrinterJob
    6329         if (service != null) {
    6330             job.setPrintService(service);
    6331         }
    6332
    6333         // if requested, show the print dialog
    6334         if (showPrintDialog && !job.printDialog(attr)) {
    6335             // the user cancelled the print dialog
    6336             return false;
    6337         }
    6338
    6339         // if not interactive, just print on this thread (no dialog)
    6340         if (!interactive) {
    6341             // do the printing
    6342             job.print(attr);
    6343
    6344             // we're done
    6345             return true;
    6346         }
    6347
    6348         // make sure this is clear since we'll check it after
    6349         printError = null;
    6350
    6351         // to synchronize on
    6352         final Object lock = new Object();
    6353
    6354         // copied so we can access from the inner class
    6355         final PrintRequestAttributeSet copyAttr = attr;
    6356
    6357         // this runnable will be used to do the printing
    6358         // (and save any throwables) on another thread
    6359         Runnable runnable = () -> {
    6360             try {
    6361                 // do the printing
    6362                 job.print(copyAttr);
    6363             } catch (Throwable t) {
    6364                 // save any Throwable to be rethrown
    6365                 synchronized(lock) {
    6366                     printError = t;
    6367                 }
    6368             } finally {
    6369                 // we're finished - hide the dialog
    6370                 printingStatus.dispose();
    6371             }
    6372         };
    6373
    6374         // start printing on another thread
    6375         Thread th = new Thread(null, runnable, "JTablePrint", 0, false);
    6376         th.start();
    6377
    6378         printingStatus.showModal(true);
    6379
    6380         // look for any error that the printing may have generated
    6381         Throwable pe;
    6382         synchronized(lock) {
    6383             pe = printError;
    6384             printError = null;
    6385         }
    6386
    6387         // check the type of error and handle it
    6388         if (pe != null) {
    6389             // a subclass of PrinterException meaning the job was aborted,
    6390             // in this case, by the user
    6391             if (pe instanceof PrinterAbortException) {
    6392                 return false;
    6393             } else if (pe instanceof PrinterException) {
    6394                 throw (PrinterException)pe;
    6395             } else if (pe instanceof RuntimeException) {
    6396                 throw (RuntimeException)pe;
    6397             } else if (pe instanceof Error) {
    6398                 throw (Error)pe;
    6399             }
    6400
    6401             // can not happen
    6402             throw new AssertionError(pe);
    6403         }
    6404
    6405         return true;
    6406     }
    6407
    6408     /**
    6409      * Return a <code>Printable</code> for use in printing this JTable.
    6410      * <p>
    6411      * This method is meant for those wishing to customize the default
    6412      * <code>Printable</code> implementation used by <code>JTable</code>'s
    6413      * <code>print</code> methods. Developers wanting simply to print the table
    6414      * should use one of those methods directly.
    6415      * <p>
    6416      * The <code>Printable</code> can be requested in one of two printing modes.
    6417      * In both modes, it spreads table rows naturally in sequence across
    6418      * multiple pages, fitting as many rows as possible per page.
    6419      * <code>PrintMode.NORMAL</code> specifies that the table be
    6420      * printed at its current size. In this mode, there may be a need to spread
    6421      * columns across pages in a similar manner to that of the rows. When the
    6422      * need arises, columns are distributed in an order consistent with the
    6423      * table's <code>ComponentOrientation</code>.
    6424      * <code>PrintMode.FIT_WIDTH</code> specifies that the output be
    6425      * scaled smaller, if necessary, to fit the table's entire width
    6426      * (and thereby all columns) on each page. Width and height are scaled
    6427      * equally, maintaining the aspect ratio of the output.
    6428      * <p>
    6429      * The <code>Printable</code> heads the portion of table on each page
    6430      * with the appropriate section from the table's <code>JTableHeader</code>,
    6431      * if it has one.
    6432      * <p>
    6433      * Header and footer text can be added to the output by providing
    6434      * <code>MessageFormat</code> arguments. The printing code requests
    6435      * Strings from the formats, providing a single item which may be included
    6436      * in the formatted string: an <code>Integer</code> representing the current
    6437      * page number.
    6438      * <p>
    6439      * You are encouraged to read the documentation for
    6440      * <code>MessageFormat</code> as some characters, such as single-quote,
    6441      * are special and need to be escaped.
    6442      * <p>
    6443      * Here's an example of creating a <code>MessageFormat</code> that can be
    6444      * used to print "Duke's Table: Page - " and the current page number:
    6445      *
    6446      * <pre>
    6447      *     // notice the escaping of the single quote
    6448      *     // notice how the page number is included with "{0}"
    6449      *     MessageFormat format = new MessageFormat("Duke''s Table: Page - {0}");
    6450      * </pre>
    6451      * <p>
    6452      * The <code>Printable</code> constrains what it draws to the printable
    6453      * area of each page that it prints. Under certain circumstances, it may
    6454      * find it impossible to fit all of a page's content into that area. In
    6455      * these cases the output may be clipped, but the implementation
    6456      * makes an effort to do something reasonable. Here are a few situations
    6457      * where this is known to occur, and how they may be handled by this
    6458      * particular implementation:
    6459      * <ul>
    6460      *   <li>In any mode, when the header or footer text is too wide to fit
    6461      *       completely in the printable area -- print as much of the text as
    6462      *       possible starting from the beginning, as determined by the table's
    6463      *       <code>ComponentOrientation</code>.
    6464      *   <li>In any mode, when a row is too tall to fit in the
    6465      *       printable area -- print the upper-most portion of the row
    6466      *       and paint no lower border on the table.
    6467      *   <li>In <code>PrintMode.NORMAL</code> when a column
    6468      *       is too wide to fit in the printable area -- print the center
    6469      *       portion of the column and leave the left and right borders
    6470      *       off the table.
    6471      * </ul>
    6472      * <p>
    6473      * It is entirely valid for this <code>Printable</code> to be wrapped
    6474      * inside another in order to create complex reports and documents. You may
    6475      * even request that different pages be rendered into different sized
    6476      * printable areas. The implementation must be prepared to handle this
    6477      * (possibly by doing its layout calculations on the fly). However,
    6478      * providing different heights to each page will likely not work well
    6479      * with <code>PrintMode.NORMAL</code> when it has to spread columns
    6480      * across pages.
    6481      * <p>
    6482      * As far as customizing how the table looks in the printed result,
    6483      * <code>JTable</code> itself will take care of hiding the selection
    6484      * and focus during printing. For additional customizations, your
    6485      * renderers or painting code can customize the look based on the value
    6486      * of {@link javax.swing.JComponent#isPaintingForPrint()}
    6487      * <p>
    6488      * Also, <i>before</i> calling this method you may wish to <i>first</i>
    6489      * modify the state of the table, such as to cancel cell editing or
    6490      * have the user size the table appropriately. However, you must not
    6491      * modify the state of the table <i>after</i> this <code>Printable</code>
    6492      * has been fetched (invalid modifications include changes in size or
    6493      * underlying data). The behavior of the returned <code>Printable</code>
    6494      * is undefined once the table has been changed.
    6495      *
    6496      * @param  printMode     the printing mode that the printable should use
    6497      * @param  headerFormat  a <code>MessageFormat</code> specifying the text to
    6498      *                       be used in printing a header, or null for none
    6499      * @param  footerFormat  a <code>MessageFormat</code> specifying the text to
    6500      *                       be used in printing a footer, or null for none
    6501      * @return a <code>Printable</code> for printing this JTable
    6502      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
    6503      *             boolean, PrintRequestAttributeSet, boolean)
    6504      * @see Printable
    6505      * @see PrinterJob
    6506      *
    6507      * @since 1.5
    6508      */
    6509     public Printable getPrintable(PrintMode printMode,
    6510                                   MessageFormat headerFormat,
    6511                                   MessageFormat footerFormat) {
    6512
    6513         return new TablePrintable(this, printMode, headerFormat, footerFormat);
    6514     }
    6515
    6516
    6517     /**
    6518      * A <code>Printable</code> implementation that wraps another
    6519      * <code>Printable</code>, making it safe for printing on another thread.
    6520      */
    6521     private class ThreadSafePrintable implements Printable {
    6522
    6523         /** The delegate <code>Printable</code>. */
    6524         private Printable printDelegate;
    6525
    6526         /**
    6527          * To communicate any return value when delegating.
    6528          */
    6529         private int retVal;
    6530
    6531         /**
    6532          * To communicate any <code>Throwable</code> when delegating.
    6533          */
    6534         private Throwable retThrowable;
    6535
    6536         /**
    6537          * Construct a <code>ThreadSafePrintable</code> around the given
    6538          * delegate.
    6539          *
    6540          * @param printDelegate the <code>Printable</code> to delegate to
    6541          */
    6542         public ThreadSafePrintable(Printable printDelegate) {
    6543             this.printDelegate = printDelegate;
    6544         }
    6545
    6546         /**
    6547          * Prints the specified page into the given {@link Graphics}
    6548          * context, in the specified format.
    6549          * <p>
    6550          * Regardless of what thread this method is called on, all calls into
    6551          * the delegate will be done on the event-dispatch thread.
    6552          *
    6553          * @param   graphics    the context into which the page is drawn
    6554          * @param   pageFormat  the size and orientation of the page being drawn
    6555          * @param   pageIndex   the zero based index of the page to be drawn
    6556          * @return  PAGE_EXISTS if the page is rendered successfully, or
    6557          *          NO_SUCH_PAGE if a non-existent page index is specified
    6558          * @throws  PrinterException if an error causes printing to be aborted
    6559          */
    6560         public int print(final Graphics graphics,
    6561                          final PageFormat pageFormat,
    6562                          final int pageIndex) throws PrinterException {
    6563
    6564             // We'll use this Runnable
    6565             Runnable runnable = new Runnable() {
    6566                 public synchronized void run() {
    6567                     try {
    6568                         // call into the delegate and save the return value
    6569                         retVal = printDelegate.print(graphics, pageFormat, pageIndex);
    6570                     } catch (Throwable throwable) {
    6571                         // save any Throwable to be rethrown
    6572                         retThrowable = throwable;
    6573                     } finally {
    6574                         // notify the caller that we're done
    6575                         notifyAll();
    6576                     }
    6577                 }
    6578             };
    6579
    6580             synchronized(runnable) {
    6581                 // make sure these are initialized
    6582                 retVal = -1;
    6583                 retThrowable = null;
    6584
    6585                 // call into the EDT
    6586                 SwingUtilities.invokeLater(runnable);
    6587
    6588                 // wait for the runnable to finish
    6589                 while (retVal == -1 && retThrowable == null) {
    6590                     try {
    6591                         runnable.wait();
    6592                     } catch (InterruptedException ie) {
    6593                         // short process, safe to ignore interrupts
    6594                     }
    6595                 }
    6596
    6597                 // if the delegate threw a throwable, rethrow it here
    6598                 if (retThrowable != null) {
    6599                     if (retThrowable instanceof PrinterException) {
    6600                         throw (PrinterException)retThrowable;
    6601                     } else if (retThrowable instanceof RuntimeException) {
    6602                         throw (RuntimeException)retThrowable;
    6603                     } else if (retThrowable instanceof Error) {
    6604                         throw (Error)retThrowable;
    6605                     }
    6606
    6607                     // can not happen
    6608                     throw new AssertionError(retThrowable);
    6609                 }
    6610
    6611                 return retVal;
    6612             }
    6613         }
    6614     }
    6615
    6616 /////////////////
    6617 // Accessibility support
    6618 ////////////////
    6619
    6620     /**
    6621      * Gets the AccessibleContext associated with this JTable.
    6622      * For tables, the AccessibleContext takes the form of an
    6623      * AccessibleJTable.
    6624      * A new AccessibleJTable instance is created if necessary.
    6625      *
    6626      * @return an AccessibleJTable that serves as the
    6627      *         AccessibleContext of this JTable
    6628      */
    6629     @BeanProperty(bound = false)
    6630     public AccessibleContext getAccessibleContext() {
    6631         if (accessibleContext == null) {
    6632             accessibleContext = new AccessibleJTable();
    6633         }
    6634         return accessibleContext;
    6635     }
    6636
    6637     //
    6638     // *** should also implement AccessibleSelection?
    6639     // *** and what's up with keyboard navigation/manipulation?
    6640     //
    6641     /**
    6642      * This class implements accessibility support for the
    6643      * <code>JTable</code> class.  It provides an implementation of the
    6644      * Java Accessibility API appropriate to table user-interface elements.
    6645      * <p>
    6646      * <strong>Warning:</strong>
    6647      * Serialized objects of this class will not be compatible with
    6648      * future Swing releases. The current serialization support is
    6649      * appropriate for short term storage or RMI between applications running
    6650      * the same version of Swing.  As of 1.4, support for long term storage
    6651      * of all JavaBeans&trade;
    6652      * has been added to the <code>java.beans</code> package.
    6653      * Please see {@link java.beans.XMLEncoder}.
    6654      */
    6655     @SuppressWarnings("serial") // Same-version serialization only
    6656     protected class AccessibleJTable extends AccessibleJComponent
    6657     implements AccessibleSelection, ListSelectionListener, TableModelListener,
    6658     TableColumnModelListener, CellEditorListener, PropertyChangeListener,
    6659     AccessibleExtendedTable {
    6660
    6661         int previousFocusedRow;
    6662         int previousFocusedCol;
    6663
    6664         /**
    6665          * AccessibleJTable constructor
    6666          *
    6667          * @since 1.5
    6668          */
    6669         protected AccessibleJTable() {
    6670             super();
    6671             JTable.this.addPropertyChangeListener(this);
    6672             JTable.this.getSelectionModel().addListSelectionListener(this);
    6673             TableColumnModel tcm = JTable.this.getColumnModel();
    6674             tcm.addColumnModelListener(this);
    6675             tcm.getSelectionModel().addListSelectionListener(this);
    6676             JTable.this.getModel().addTableModelListener(this);
    6677             previousFocusedRow = JTable.this.getSelectionModel().
    6678                                         getLeadSelectionIndex();
    6679             previousFocusedCol = JTable.this.getColumnModel().
    6680                                         getSelectionModel().getLeadSelectionIndex();
    6681         }
    6682
    6683     // Listeners to track model, etc. changes to as to re-place the other
    6684     // listeners
    6685
    6686         /**
    6687          * Track changes to selection model, column model, etc. so as to
    6688          * be able to re-place listeners on those in order to pass on
    6689          * information to the Accessibility PropertyChange mechanism
    6690          */
    6691         public void propertyChange(PropertyChangeEvent e) {
    6692             String name = e.getPropertyName();
    6693             Object oldValue = e.getOldValue();
    6694             Object newValue = e.getNewValue();
    6695
    6696                 // re-set tableModel listeners
    6697             if (name.compareTo("model") == 0) {
    6698
    6699                 if (oldValue != null && oldValue instanceof TableModel) {
    6700                     ((TableModel) oldValue).removeTableModelListener(this);
    6701                 }
    6702                 if (newValue != null && newValue instanceof TableModel) {
    6703                     ((TableModel) newValue).addTableModelListener(this);
    6704                 }
    6705
    6706                 // re-set selectionModel listeners
    6707             } else if (name.compareTo("selectionModel") == 0) {
    6708
    6709                 Object source = e.getSource();
    6710                 if (source == JTable.this) {    // row selection model
    6711
    6712                     if (oldValue != null &&
    6713                         oldValue instanceof ListSelectionModel) {
    6714                         ((ListSelectionModel) oldValue).removeListSelectionListener(this);
    6715                     }
    6716                     if (newValue != null &&
    6717                         newValue instanceof ListSelectionModel) {
    6718                         ((ListSelectionModel) newValue).addListSelectionListener(this);
    6719                     }
    6720
    6721                 } else if (source == JTable.this.getColumnModel()) {
    6722
    6723                     if (oldValue != null &&
    6724                         oldValue instanceof ListSelectionModel) {
    6725                         ((ListSelectionModel) oldValue).removeListSelectionListener(this);
    6726                     }
    6727                     if (newValue != null &&
    6728                         newValue instanceof ListSelectionModel) {
    6729                         ((ListSelectionModel) newValue).addListSelectionListener(this);
    6730                     }
    6731
    6732                 } else {
    6733                   //        System.out.println("!!! Bug in source of selectionModel propertyChangeEvent");
    6734                 }
    6735
    6736                 // re-set columnModel listeners
    6737                 // and column's selection property listener as well
    6738             } else if (name.compareTo("columnModel") == 0) {
    6739
    6740                 if (oldValue != null && oldValue instanceof TableColumnModel) {
    6741                     TableColumnModel tcm = (TableColumnModel) oldValue;
    6742                     tcm.removeColumnModelListener(this);
    6743                     tcm.getSelectionModel().removeListSelectionListener(this);
    6744                 }
    6745                 if (newValue != null && newValue instanceof TableColumnModel) {
    6746                     TableColumnModel tcm = (TableColumnModel) newValue;
    6747                     tcm.addColumnModelListener(this);
    6748                     tcm.getSelectionModel().addListSelectionListener(this);
    6749                 }
    6750
    6751                 // re-se cellEditor listeners
    6752             } else if (name.compareTo("tableCellEditor") == 0) {
    6753
    6754                 if (oldValue != null && oldValue instanceof TableCellEditor) {
    6755                     ((TableCellEditor) oldValue).removeCellEditorListener(this);
    6756                 }
    6757                 if (newValue != null && newValue instanceof TableCellEditor) {
    6758                     ((TableCellEditor) newValue).addCellEditorListener(this);
    6759                 }
    6760             }
    6761         }
    6762
    6763
    6764     // Listeners to echo changes to the AccessiblePropertyChange mechanism
    6765
    6766         /**
    6767          * Describes a change in the accessible table model.
    6768          */
    6769         protected class AccessibleJTableModelChange
    6770             implements AccessibleTableModelChange {
    6771
    6772             /** The type */
    6773             protected int type;
    6774             /** The first row */
    6775             protected int firstRow;
    6776             /** The last row */
    6777             protected int lastRow;
    6778             /** The first column */
    6779             protected int firstColumn;
    6780             /** The last column */
    6781             protected int lastColumn;
    6782
    6783             /**
    6784              * Constructs an {@code AccessibleJTableModelChange}.
    6785              * @param type the type
    6786              * @param firstRow the first row
    6787              * @param lastRow the last row
    6788              * @param firstColumn the first column
    6789              * @param lastColumn the last column
    6790              */
    6791             protected AccessibleJTableModelChange(int type, int firstRow,
    6792                                                   int lastRow, int firstColumn,
    6793                                                   int lastColumn) {
    6794                 this.type = type;
    6795                 this.firstRow = firstRow;
    6796                 this.lastRow = lastRow;
    6797                 this.firstColumn = firstColumn;
    6798                 this.lastColumn = lastColumn;
    6799             }
    6800
    6801             /**
    6802              * Returns the type.
    6803              * @return the type
    6804              */
    6805             public int getType() {
    6806                 return type;
    6807             }
    6808
    6809             /**
    6810              * Returns the first row.
    6811              * @return the first row
    6812              */
    6813             public int getFirstRow() {
    6814                 return firstRow;
    6815             }
    6816
    6817             /**
    6818              * Returns the last row.
    6819              * @return the last row
    6820              */
    6821             public int getLastRow() {
    6822                 return lastRow;
    6823             }
    6824
    6825             /**
    6826              * Returns the first column.
    6827              * @return the first column
    6828              */
    6829             public int getFirstColumn() {
    6830                 return firstColumn;
    6831             }
    6832
    6833             /**
    6834              * Returns the last column.
    6835              * @return the last column
    6836              */
    6837             public int getLastColumn() {
    6838                 return lastColumn;
    6839             }
    6840         }
    6841
    6842         /**
    6843          * Track changes to the table contents
    6844          *
    6845          * @param e a {@code TableModelEvent} describing the event
    6846          */
    6847         public void tableChanged(TableModelEvent e) {
    6848            firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
    6849                               null, null);
    6850            if (e != null) {
    6851                int firstColumn = e.getColumn();
    6852                int lastColumn = e.getColumn();
    6853                if (firstColumn == TableModelEvent.ALL_COLUMNS) {
    6854                    firstColumn = 0;
    6855                    lastColumn = getColumnCount() - 1;
    6856                }
    6857
    6858                // Fire a property change event indicating the table model
    6859                // has changed.
    6860                AccessibleJTableModelChange change =
    6861                    new AccessibleJTableModelChange(e.getType(),
    6862                                                    e.getFirstRow(),
    6863                                                    e.getLastRow(),
    6864                                                    firstColumn,
    6865                                                    lastColumn);
    6866                firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
    6867                                   null, change);
    6868             }
    6869         }
    6870
    6871         /**
    6872          * Track changes to the table contents (row insertions)
    6873          *
    6874          * @param e a {@code TableModelEvent} describing the event
    6875          */
    6876         public void tableRowsInserted(TableModelEvent e) {
    6877            firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
    6878                               null, null);
    6879
    6880            // Fire a property change event indicating the table model
    6881            // has changed.
    6882            int firstColumn = e.getColumn();
    6883            int lastColumn = e.getColumn();
    6884            if (firstColumn == TableModelEvent.ALL_COLUMNS) {
    6885                firstColumn = 0;
    6886                lastColumn = getColumnCount() - 1;
    6887            }
    6888            AccessibleJTableModelChange change =
    6889                new AccessibleJTableModelChange(e.getType(),
    6890                                                e.getFirstRow(),
    6891                                                e.getLastRow(),
    6892                                                firstColumn,
    6893                                                lastColumn);
    6894            firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
    6895                               null, change);
    6896         }
    6897
    6898         /**
    6899          * Track changes to the table contents (row deletions)
    6900          *
    6901          * @param e a {@code TableModelEvent} describing the event
    6902          */
    6903         public void tableRowsDeleted(TableModelEvent e) {
    6904            firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
    6905                               null, null);
    6906
    6907            // Fire a property change event indicating the table model
    6908            // has changed.
    6909            int firstColumn = e.getColumn();
    6910            int lastColumn = e.getColumn();
    6911            if (firstColumn == TableModelEvent.ALL_COLUMNS) {
    6912                firstColumn = 0;
    6913                lastColumn = getColumnCount() - 1;
    6914            }
    6915            AccessibleJTableModelChange change =
    6916                new AccessibleJTableModelChange(e.getType(),
    6917                                                e.getFirstRow(),
    6918                                                e.getLastRow(),
    6919                                                firstColumn,
    6920                                                lastColumn);
    6921            firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
    6922                               null, change);
    6923         }
    6924
    6925         /**
    6926          * Track changes to the table contents (column insertions)
    6927          */
    6928         public void columnAdded(TableColumnModelEvent 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 type = AccessibleTableModelChange.INSERT;
    6935            AccessibleJTableModelChange change =
    6936                new AccessibleJTableModelChange(type,
    6937                                                0,
    6938                                                0,
    6939                                                e.getFromIndex(),
    6940                                                e.getToIndex());
    6941            firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
    6942                               null, change);
    6943         }
    6944
    6945         /**
    6946          * Track changes to the table contents (column deletions)
    6947          */
    6948         public void columnRemoved(TableColumnModelEvent e) {
    6949            firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
    6950                               null, null);
    6951            // Fire a property change event indicating the table model
    6952            // has changed.
    6953            int type = AccessibleTableModelChange.DELETE;
    6954            AccessibleJTableModelChange change =
    6955                new AccessibleJTableModelChange(type,
    6956                                                0,
    6957                                                0,
    6958                                                e.getFromIndex(),
    6959                                                e.getToIndex());
    6960            firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
    6961                               null, change);
    6962         }
    6963
    6964         /**
    6965          * Track changes of a column repositioning.
    6966          *
    6967          * @see TableColumnModelListener
    6968          */
    6969         public void columnMoved(TableColumnModelEvent e) {
    6970            firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
    6971                               null, null);
    6972
    6973            // Fire property change events indicating the table model
    6974            // has changed.
    6975            int type = AccessibleTableModelChange.DELETE;
    6976            AccessibleJTableModelChange change =
    6977                new AccessibleJTableModelChange(type,
    6978                                                0,
    6979                                                0,
    6980                                                e.getFromIndex(),
    6981                                                e.getFromIndex());
    6982            firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
    6983                               null, change);
    6984
    6985            int type2 = AccessibleTableModelChange.INSERT;
    6986            AccessibleJTableModelChange change2 =
    6987                new AccessibleJTableModelChange(type2,
    6988                                                0,
    6989                                                0,
    6990                                                e.getToIndex(),
    6991                                                e.getToIndex());
    6992            firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_MODEL_CHANGED,
    6993                               null, change2);
    6994         }
    6995
    6996         /**
    6997          * Track changes of a column moving due to margin changes.
    6998          *
    6999          * @see TableColumnModelListener
    7000          */
    7001         public void columnMarginChanged(ChangeEvent e) {
    7002            firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
    7003                               null, null);
    7004         }
    7005
    7006         /**
    7007          * Track that the selection model of the TableColumnModel changed.
    7008          *
    7009          * @see TableColumnModelListener
    7010          */
    7011         public void columnSelectionChanged(ListSelectionEvent e) {
    7012             // we should now re-place our TableColumn listener
    7013         }
    7014
    7015         /**
    7016          * Track changes to a cell's contents.
    7017          *
    7018          * Invoked when editing is finished. The changes are saved, the
    7019          * editor object is discarded, and the cell is rendered once again.
    7020          *
    7021          * @see CellEditorListener
    7022          */
    7023         public void editingStopped(ChangeEvent e) {
    7024            // it'd be great if we could figure out which cell, and pass that
    7025            // somehow as a parameter
    7026            firePropertyChange(AccessibleContext.ACCESSIBLE_VISIBLE_DATA_PROPERTY,
    7027                               null, null);
    7028         }
    7029
    7030         /**
    7031          * Invoked when editing is canceled. The editor object is discarded
    7032          * and the cell is rendered once again.
    7033          *
    7034          * @see CellEditorListener
    7035          */
    7036         public void editingCanceled(ChangeEvent e) {
    7037             // nothing to report, 'cause nothing changed
    7038         }
    7039
    7040         /**
    7041          * Track changes to table cell selections
    7042          */
    7043         public void valueChanged(ListSelectionEvent e) {
    7044             firePropertyChange(AccessibleContext.ACCESSIBLE_SELECTION_PROPERTY,
    7045                             Boolean.valueOf(false), Boolean.valueOf(true));
    7046
    7047             // Using lead selection index to cover both cases: node selected and node
    7048             // is focused but not selected (Ctrl+up/down)
    7049             int focusedRow = JTable.this.getSelectionModel().getLeadSelectionIndex();
    7050             int focusedCol = JTable.this.getColumnModel().getSelectionModel().
    7051                                                     getLeadSelectionIndex();
    7052
    7053             if (focusedRow != previousFocusedRow ||
    7054                 focusedCol != previousFocusedCol) {
    7055                 Accessible oldA = getAccessibleAt(previousFocusedRow, previousFocusedCol);
    7056                 Accessible newA = getAccessibleAt(focusedRow, focusedCol);
    7057                 firePropertyChange(AccessibleContext.ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY,
    7058                                     oldA, newA);
    7059                 previousFocusedRow = focusedRow;
    7060                 previousFocusedCol = focusedCol;
    7061             }
    7062         }
    7063
    7064
    7065
    7066
    7067     // AccessibleContext support
    7068
    7069         /**
    7070          * Get the AccessibleSelection associated with this object.  In the
    7071          * implementation of the Java Accessibility API for this class,
    7072          * return this object, which is responsible for implementing the
    7073          * AccessibleSelection interface on behalf of itself.
    7074          *
    7075          * @return this object
    7076          */
    7077         public AccessibleSelection getAccessibleSelection() {
    7078             return this;
    7079         }
    7080
    7081         /**
    7082          * Gets the role of this object.
    7083          *
    7084          * @return an instance of AccessibleRole describing the role of the
    7085          * object
    7086          * @see AccessibleRole
    7087          */
    7088         public AccessibleRole getAccessibleRole() {
    7089             return AccessibleRole.TABLE;
    7090         }
    7091
    7092         /**
    7093          * Returns the <code>Accessible</code> child, if one exists,
    7094          * contained at the local coordinate <code>Point</code>.
    7095          *
    7096          * @param p the point defining the top-left corner of the
    7097          *    <code>Accessible</code>, given in the coordinate space
    7098          *    of the object's parent
    7099          * @return the <code>Accessible</code>, if it exists,
    7100          *    at the specified location; else <code>null</code>
    7101          */
    7102         public Accessible getAccessibleAt(Point p) {
    7103             int column = columnAtPoint(p);
    7104             int row = rowAtPoint(p);
    7105
    7106             if ((column != -1) && (row != -1)) {
    7107                 TableColumn aColumn = getColumnModel().getColumn(column);
    7108                 TableCellRenderer renderer = aColumn.getCellRenderer();
    7109                 if (renderer == null) {
    7110                     Class<?> columnClass = getColumnClass(column);
    7111                     renderer = getDefaultRenderer(columnClass);
    7112                 }
    7113                 Component component = renderer.getTableCellRendererComponent(
    7114                                   JTable.this, null, false, false,
    7115                                   row, column);
    7116                 return new AccessibleJTableCell(JTable.this, row, column,
    7117                       getAccessibleIndexAt(row, column));
    7118             }
    7119             return null;
    7120         }
    7121
    7122         /**
    7123          * Returns the number of accessible children in the object.  If all
    7124          * of the children of this object implement <code>Accessible</code>,
    7125          * then this method should return the number of children of this object.
    7126          *
    7127          * @return the number of accessible children in the object
    7128          */
    7129         public int getAccessibleChildrenCount() {
    7130             return (JTable.this.getColumnCount() * JTable.this.getRowCount());
    7131         }
    7132
    7133         /**
    7134          * Returns the nth <code>Accessible</code> child of the object.
    7135          *
    7136          * @param i zero-based index of child
    7137          * @return the nth Accessible child of the object
    7138          */
    7139         public Accessible getAccessibleChild(int i) {
    7140             if (i < 0 || i >= getAccessibleChildrenCount()) {
    7141                 return null;
    7142             } else {
    7143                 // children increase across, and then down, for tables
    7144                 // (arbitrary decision)
    7145                 int column = getAccessibleColumnAtIndex(i);
    7146                 int row = getAccessibleRowAtIndex(i);
    7147
    7148                 TableColumn aColumn = getColumnModel().getColumn(column);
    7149                 TableCellRenderer renderer = aColumn.getCellRenderer();
    7150                 if (renderer == null) {
    7151                     Class<?> columnClass = getColumnClass(column);
    7152                     renderer = getDefaultRenderer(columnClass);
    7153                 }
    7154                 Component component = renderer.getTableCellRendererComponent(
    7155                                   JTable.this, null, false, false,
    7156                                   row, column);
    7157                 return new AccessibleJTableCell(JTable.this, row, column,
    7158                       getAccessibleIndexAt(row, column));
    7159             }
    7160         }
    7161
    7162     // AccessibleSelection support
    7163
    7164         /**
    7165          * Returns the number of <code>Accessible</code> children
    7166          * currently selected.
    7167          * If no children are selected, the return value will be 0.
    7168          *
    7169          * @return the number of items currently selected
    7170          */
    7171         public int getAccessibleSelectionCount() {
    7172             int rowsSel = JTable.this.getSelectedRowCount();
    7173             int colsSel = JTable.this.getSelectedColumnCount();
    7174
    7175             if (JTable.this.cellSelectionEnabled) { // a contiguous block
    7176                 return rowsSel * colsSel;
    7177
    7178             } else {
    7179                 // a column swath and a row swath, with a shared block
    7180                 if (JTable.this.getRowSelectionAllowed() &&
    7181                     JTable.this.getColumnSelectionAllowed()) {
    7182                     return rowsSel * JTable.this.getColumnCount() +
    7183                            colsSel * JTable.this.getRowCount() -
    7184                            rowsSel * colsSel;
    7185
    7186                 // just one or more rows in selection
    7187                 } else if (JTable.this.getRowSelectionAllowed()) {
    7188                     return rowsSel * JTable.this.getColumnCount();
    7189
    7190                 // just one or more rows in selection
    7191                 } else if (JTable.this.getColumnSelectionAllowed()) {
    7192                     return colsSel * JTable.this.getRowCount();
    7193
    7194                 } else {
    7195                     return 0;    // JTable doesn't allow selections
    7196                 }
    7197             }
    7198         }
    7199
    7200         /**
    7201          * Returns an <code>Accessible</code> representing the
    7202          * specified selected child in the object.  If there
    7203          * isn't a selection, or there are fewer children selected
    7204          * than the integer passed in, the return
    7205          * value will be <code>null</code>.
    7206          * <p>Note that the index represents the i-th selected child, which
    7207          * is different from the i-th child.
    7208          *
    7209          * @param i the zero-based index of selected children
    7210          * @return the i-th selected child
    7211          * @see #getAccessibleSelectionCount
    7212          */
    7213         public Accessible getAccessibleSelection(int i) {
    7214             if (i < 0 || i > getAccessibleSelectionCount()) {
    7215                 return null;
    7216             }
    7217
    7218             int rowsSel = JTable.this.getSelectedRowCount();
    7219             int colsSel = JTable.this.getSelectedColumnCount();
    7220             int rowIndicies[] = getSelectedRows();
    7221             int colIndicies[] = getSelectedColumns();
    7222             int ttlCols = JTable.this.getColumnCount();
    7223             int ttlRows = JTable.this.getRowCount();
    7224             int r;
    7225             int c;
    7226
    7227             if (JTable.this.cellSelectionEnabled) { // a contiguous block
    7228                 r = rowIndicies[i / colsSel];
    7229                 c = colIndicies[i % colsSel];
    7230                 return getAccessibleChild((r * ttlCols) + c);
    7231             } else {
    7232
    7233                 // a column swath and a row swath, with a shared block
    7234                 if (JTable.this.getRowSelectionAllowed() &&
    7235                     JTable.this.getColumnSelectionAllowed()) {
    7236
    7237                     // Situation:
    7238                     //   We have a table, like the 6x3 table below,
    7239                     //   wherein three colums and one row selected
    7240                     //   (selected cells marked with "*", unselected "0"):
    7241                     //
    7242                     //            0 * 0 * * 0
    7243                     //            * * * * * *
    7244                     //            0 * 0 * * 0
    7245                     //
    7246
    7247                     // State machine below walks through the array of
    7248                     // selected rows in two states: in a selected row,
    7249                     // and not in one; continuing until we are in a row
    7250                     // in which the ith selection exists.  Then we return
    7251                     // the appropriate cell.  In the state machine, we
    7252                     // always do rows above the "current" selected row first,
    7253                     // then the cells in the selected row.  If we're done
    7254                     // with the state machine before finding the requested
    7255                     // selected child, we handle the rows below the last
    7256                     // selected row at the end.
    7257                     //
    7258                     int curIndex = i;
    7259                     final int IN_ROW = 0;
    7260                     final int NOT_IN_ROW = 1;
    7261                     int state = (rowIndicies[0] == 0 ? IN_ROW : NOT_IN_ROW);
    7262                     int j = 0;
    7263                     int prevRow = -1;
    7264                     while (j < rowIndicies.length) {
    7265                         switch (state) {
    7266
    7267                         case IN_ROW:   // on individual row full of selections
    7268                             if (curIndex < ttlCols) { // it's here!
    7269                                 c = curIndex % ttlCols;
    7270                                 r = rowIndicies[j];
    7271                                 return getAccessibleChild((r * ttlCols) + c);
    7272                             } else {                               // not here
    7273                                 curIndex -= ttlCols;
    7274                             }
    7275                             // is the next row in table selected or not?
    7276                             if (j + 1 == rowIndicies.length ||
    7277                                 rowIndicies[j] != rowIndicies[j+1] - 1) {
    7278                                 state = NOT_IN_ROW;
    7279                                 prevRow = rowIndicies[j];
    7280                             }
    7281                             j++;  // we didn't return earlier, so go to next row
    7282                             break;
    7283
    7284                         case NOT_IN_ROW:  // sparse bunch of rows of selections
    7285                             if (curIndex <
    7286                                 (colsSel * (rowIndicies[j] -
    7287                                 (prevRow == -1 ? 0 : (prevRow + 1))))) {
    7288
    7289                                 // it's here!
    7290                                 c = colIndicies[curIndex % colsSel];
    7291                                 r = (j > 0 ? rowIndicies[j-1] + 1 : 0)
    7292                                     + curIndex / colsSel;
    7293                                 return getAccessibleChild((r * ttlCols) + c);
    7294                             } else {                               // not here
    7295                                 curIndex -= colsSel * (rowIndicies[j] -
    7296                                 (prevRow == -1 ? 0 : (prevRow + 1)));
    7297                             }
    7298                             state = IN_ROW;
    7299                             break;
    7300                         }
    7301                     }
    7302                     // we got here, so we didn't find it yet; find it in
    7303                     // the last sparse bunch of rows
    7304                     if (curIndex <
    7305                         (colsSel * (ttlRows -
    7306                         (prevRow == -1 ? 0 : (prevRow + 1))))) { // it's here!
    7307                         c = colIndicies[curIndex % colsSel];
    7308                         r = rowIndicies[j-1] + curIndex / colsSel + 1;
    7309                         return getAccessibleChild((r * ttlCols) + c);
    7310                     } else {                               // not here
    7311                         // we shouldn't get to this spot in the code!
    7312 //                      System.out.println("Bug in AccessibleJTable.getAccessibleSelection()");
    7313                     }
    7314
    7315                 // one or more rows selected
    7316                 } else if (JTable.this.getRowSelectionAllowed()) {
    7317                     c = i % ttlCols;
    7318                     r = rowIndicies[i / ttlCols];
    7319                     return getAccessibleChild((r * ttlCols) + c);
    7320
    7321                 // one or more columns selected
    7322                 } else if (JTable.this.getColumnSelectionAllowed()) {
    7323                     c = colIndicies[i % colsSel];
    7324                     r = i / colsSel;
    7325                     return getAccessibleChild((r * ttlCols) + c);
    7326                 }
    7327             }
    7328             return null;
    7329         }
    7330
    7331         /**
    7332          * Determines if the current child of this object is selected.
    7333          *
    7334          * @param i the zero-based index of the child in this
    7335          *    <code>Accessible</code> object
    7336          * @return true if the current child of this object is selected
    7337          * @see AccessibleContext#getAccessibleChild
    7338          */
    7339         public boolean isAccessibleChildSelected(int i) {
    7340             int column = getAccessibleColumnAtIndex(i);
    7341             int row = getAccessibleRowAtIndex(i);
    7342             return JTable.this.isCellSelected(row, column);
    7343         }
    7344
    7345         /**
    7346          * Adds the specified <code>Accessible</code> child of the
    7347          * object to the object's selection.  If the object supports
    7348          * multiple selections, the specified child is added to
    7349          * any existing selection, otherwise
    7350          * it replaces any existing selection in the object.  If the
    7351          * specified child is already selected, this method has no effect.
    7352          * <p>
    7353          * This method only works on <code>JTable</code>s which have
    7354          * individual cell selection enabled.
    7355          *
    7356          * @param i the zero-based index of the child
    7357          * @see AccessibleContext#getAccessibleChild
    7358          */
    7359         public void addAccessibleSelection(int i) {
    7360             // TIGER - 4495286
    7361             int column = getAccessibleColumnAtIndex(i);
    7362             int row = getAccessibleRowAtIndex(i);
    7363             JTable.this.changeSelection(row, column, true, false);
    7364         }
    7365
    7366         /**
    7367          * Removes the specified child of the object from the object's
    7368          * selection.  If the specified item isn't currently selected, this
    7369          * method has no effect.
    7370          * <p>
    7371          * This method only works on <code>JTables</code> which have
    7372          * individual cell selection enabled.
    7373          *
    7374          * @param i the zero-based index of the child
    7375          * @see AccessibleContext#getAccessibleChild
    7376          */
    7377         public void removeAccessibleSelection(int i) {
    7378             if (JTable.this.cellSelectionEnabled) {
    7379                 int column = getAccessibleColumnAtIndex(i);
    7380                 int row = getAccessibleRowAtIndex(i);
    7381                 JTable.this.removeRowSelectionInterval(row, row);
    7382                 JTable.this.removeColumnSelectionInterval(column, column);
    7383             }
    7384         }
    7385
    7386         /**
    7387          * Clears the selection in the object, so that no children in the
    7388          * object are selected.
    7389          */
    7390         public void clearAccessibleSelection() {
    7391             JTable.this.clearSelection();
    7392         }
    7393
    7394         /**
    7395          * Causes every child of the object to be selected, but only
    7396          * if the <code>JTable</code> supports multiple selections,
    7397          * and if individual cell selection is enabled.
    7398          */
    7399         public void selectAllAccessibleSelection() {
    7400             if (JTable.this.cellSelectionEnabled) {
    7401                 JTable.this.selectAll();
    7402             }
    7403         }
    7404
    7405         // begin AccessibleExtendedTable implementation -------------
    7406
    7407         /**
    7408          * Returns the row number of an index in the table.
    7409          *
    7410          * @param index the zero-based index in the table
    7411          * @return the zero-based row of the table if one exists;
    7412          * otherwise -1.
    7413          * @since 1.4
    7414          */
    7415         public int getAccessibleRow(int index) {
    7416             return getAccessibleRowAtIndex(index);
    7417         }
    7418
    7419         /**
    7420          * Returns the column number of an index in the table.
    7421          *
    7422          * @param index the zero-based index in the table
    7423          * @return the zero-based column of the table if one exists;
    7424          * otherwise -1.
    7425          * @since 1.4
    7426          */
    7427         public int getAccessibleColumn(int index) {
    7428             return getAccessibleColumnAtIndex(index);
    7429         }
    7430
    7431         /**
    7432          * Returns the index at a row and column in the table.
    7433          *
    7434          * @param r zero-based row of the table
    7435          * @param c zero-based column of the table
    7436          * @return the zero-based index in the table if one exists;
    7437          * otherwise -1.
    7438          * @since 1.4
    7439          */
    7440         public int getAccessibleIndex(int r, int c) {
    7441             return getAccessibleIndexAt(r, c);
    7442         }
    7443
    7444         // end of AccessibleExtendedTable implementation ------------
    7445
    7446         // start of AccessibleTable implementation ------------------
    7447
    7448         private Accessible caption;
    7449         private Accessible summary;
    7450         private Accessible [] rowDescription;
    7451         private Accessible [] columnDescription;
    7452
    7453         /**
    7454          * Gets the <code>AccessibleTable</code> associated with this
    7455          * object.  In the implementation of the Java Accessibility
    7456          * API for this class, return this object, which is responsible
    7457          * for implementing the <code>AccessibleTables</code> interface
    7458          * on behalf of itself.
    7459          *
    7460          * @return this object
    7461          * @since 1.3
    7462          */
    7463         public AccessibleTable getAccessibleTable() {
    7464             return this;
    7465         }
    7466
    7467         /**
    7468          * Returns the caption for the table.
    7469          *
    7470          * @return the caption for the table
    7471          * @since 1.3
    7472          */
    7473         public Accessible getAccessibleCaption() {
    7474             return this.caption;
    7475         }
    7476
    7477         /**
    7478          * Sets the caption for the table.
    7479          *
    7480          * @param a the caption for the table
    7481          * @since 1.3
    7482          */
    7483         public void setAccessibleCaption(Accessible a) {
    7484             Accessible oldCaption = caption;
    7485             this.caption = a;
    7486             firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_CAPTION_CHANGED,
    7487                                oldCaption, this.caption);
    7488         }
    7489
    7490         /**
    7491          * Returns the summary description of the table.
    7492          *
    7493          * @return the summary description of the table
    7494          * @since 1.3
    7495          */
    7496         public Accessible getAccessibleSummary() {
    7497             return this.summary;
    7498         }
    7499
    7500         /**
    7501          * Sets the summary description of the table.
    7502          *
    7503          * @param a the summary description of the table
    7504          * @since 1.3
    7505          */
    7506         public void setAccessibleSummary(Accessible a) {
    7507             Accessible oldSummary = summary;
    7508             this.summary = a;
    7509             firePropertyChange(AccessibleContext.ACCESSIBLE_TABLE_SUMMARY_CHANGED,
    7510                                oldSummary, this.summary);
    7511         }
    7512
    7513         /*
    7514          * Returns the total number of rows in this table.
    7515          *
    7516          * @return the total number of rows in this table
    7517          */
    7518         public int getAccessibleRowCount() {
    7519             return JTable.this.getRowCount();
    7520         }
    7521
    7522         /*
    7523          * Returns the total number of columns in the table.
    7524          *
    7525          * @return the total number of columns in the table
    7526          */
    7527         public int getAccessibleColumnCount() {
    7528             return JTable.this.getColumnCount();
    7529         }
    7530
    7531         /*
    7532          * Returns the <code>Accessible</code> at a specified row
    7533          * and column in the table.
    7534          *
    7535          * @param r zero-based row of the table
    7536          * @param c zero-based column of the table
    7537          * @return the <code>Accessible</code> at the specified row and column
    7538          * in the table
    7539          */
    7540         public Accessible getAccessibleAt(int r, int c) {
    7541             return getAccessibleChild((r * getAccessibleColumnCount()) + c);
    7542         }
    7543
    7544         /**
    7545          * Returns the number of rows occupied by the <code>Accessible</code>
    7546          * at a specified row and column in the table.
    7547          *
    7548          * @return the number of rows occupied by the <code>Accessible</code>
    7549          *     at a specified row and column in the table
    7550          * @since 1.3
    7551          */
    7552         public int getAccessibleRowExtentAt(int r, int c) {
    7553             return 1;
    7554         }
    7555
    7556         /**
    7557          * Returns the number of columns occupied by the
    7558          * <code>Accessible</code> at a given (row, column).
    7559          *
    7560          * @return the number of columns occupied by the <code>Accessible</code>
    7561          *     at a specified row and column in the table
    7562          * @since 1.3
    7563          */
    7564         public int getAccessibleColumnExtentAt(int r, int c) {
    7565             return 1;
    7566         }
    7567
    7568         /**
    7569          * Returns the row headers as an <code>AccessibleTable</code>.
    7570          *
    7571          * @return an <code>AccessibleTable</code> representing the row
    7572          * headers
    7573          * @since 1.3
    7574          */
    7575         public AccessibleTable getAccessibleRowHeader() {
    7576             // row headers are not supported
    7577             return null;
    7578         }
    7579
    7580         /**
    7581          * Sets the row headers as an <code>AccessibleTable</code>.
    7582          *
    7583          * @param a an <code>AccessibleTable</code> representing the row
    7584          *  headers
    7585          * @since 1.3
    7586          */
    7587         public void setAccessibleRowHeader(AccessibleTable a) {
    7588             // row headers are not supported
    7589         }
    7590
    7591         /**
    7592          * Returns the column headers as an <code>AccessibleTable</code>.
    7593          *
    7594          *  @return an <code>AccessibleTable</code> representing the column
    7595          *          headers, or <code>null</code> if the table header is
    7596          *          <code>null</code>
    7597          * @since 1.3
    7598          */
    7599         public AccessibleTable getAccessibleColumnHeader() {
    7600             JTableHeader header = JTable.this.getTableHeader();
    7601             return header == null ? null : new AccessibleTableHeader(header);
    7602         }
    7603
    7604         /*
    7605          * Private class representing a table column header
    7606          */
    7607         private class AccessibleTableHeader implements AccessibleTable {
    7608             private JTableHeader header;
    7609             private TableColumnModel headerModel;
    7610
    7611             AccessibleTableHeader(JTableHeader header) {
    7612                 this.header = header;
    7613                 this.headerModel = header.getColumnModel();
    7614             }
    7615
    7616             /**
    7617              * Returns the caption for the table.
    7618              *
    7619              * @return the caption for the table
    7620              */
    7621             public Accessible getAccessibleCaption() { return null; }
    7622
    7623
    7624             /**
    7625              * Sets the caption for the table.
    7626              *
    7627              * @param a the caption for the table
    7628              */
    7629             public void setAccessibleCaption(Accessible a) {}
    7630
    7631             /**
    7632              * Returns the summary description of the table.
    7633              *
    7634              * @return the summary description of the table
    7635              */
    7636             public Accessible getAccessibleSummary() { return null; }
    7637
    7638             /**
    7639              * Sets the summary description of the table
    7640              *
    7641              * @param a the summary description of the table
    7642              */
    7643             public void setAccessibleSummary(Accessible a) {}
    7644
    7645             /**
    7646              * Returns the number of rows in the table.
    7647              *
    7648              * @return the number of rows in the table
    7649              */
    7650             public int getAccessibleRowCount() { return 1; }
    7651
    7652             /**
    7653              * Returns the number of columns in the table.
    7654              *
    7655              * @return the number of columns in the table
    7656              */
    7657             public int getAccessibleColumnCount() {
    7658                 return headerModel.getColumnCount();
    7659             }
    7660
    7661             /**
    7662              * Returns the Accessible at a specified row and column
    7663              * in the table.
    7664              *
    7665              * @param row zero-based row of the table
    7666              * @param column zero-based column of the table
    7667              * @return the Accessible at the specified row and column
    7668              */
    7669             public Accessible getAccessibleAt(int row, int column) {
    7670
    7671
    7672                 // TIGER - 4715503
    7673                 TableColumn aColumn = headerModel.getColumn(column);
    7674                 TableCellRenderer renderer = aColumn.getHeaderRenderer();
    7675                 if (renderer == null) {
    7676                     renderer = header.getDefaultRenderer();
    7677                 }
    7678                 Component component = renderer.getTableCellRendererComponent(
    7679                                   header.getTable(),
    7680                                   aColumn.getHeaderValue(), false, false,
    7681                                   -1, column);
    7682
    7683                 return new AccessibleJTableHeaderCell(row, column,
    7684                                                       JTable.this.getTableHeader(),
    7685                                                       component);
    7686             }
    7687
    7688             /**
    7689              * Returns the number of rows occupied by the Accessible at
    7690              * a specified row and column in the table.
    7691              *
    7692              * @return the number of rows occupied by the Accessible at a
    7693              * given specified (row, column)
    7694              */
    7695             public int getAccessibleRowExtentAt(int r, int c) { return 1; }
    7696
    7697             /**
    7698              * Returns the number of columns occupied by the Accessible at
    7699              * a specified row and column in the table.
    7700              *
    7701              * @return the number of columns occupied by the Accessible at a
    7702              * given specified row and column
    7703              */
    7704             public int getAccessibleColumnExtentAt(int r, int c) { return 1; }
    7705
    7706             /**
    7707              * Returns the row headers as an AccessibleTable.
    7708              *
    7709              * @return an AccessibleTable representing the row
    7710              * headers
    7711              */
    7712             public AccessibleTable getAccessibleRowHeader() { return null; }
    7713
    7714             /**
    7715              * Sets the row headers.
    7716              *
    7717              * @param table an AccessibleTable representing the
    7718              * row headers
    7719              */
    7720             public void setAccessibleRowHeader(AccessibleTable table) {}
    7721
    7722             /**
    7723              * Returns the column headers as an AccessibleTable.
    7724              *
    7725              * @return an AccessibleTable representing the column
    7726              * headers
    7727              */
    7728             public AccessibleTable getAccessibleColumnHeader() { return null; }
    7729
    7730             /**
    7731              * Sets the column headers.
    7732              *
    7733              * @param table an AccessibleTable representing the
    7734              * column headers
    7735              * @since 1.3
    7736              */
    7737             public void setAccessibleColumnHeader(AccessibleTable table) {}
    7738
    7739             /**
    7740              * Returns the description of the specified row in the table.
    7741              *
    7742              * @param r zero-based row of the table
    7743              * @return the description of the row
    7744              * @since 1.3
    7745              */
    7746             public Accessible getAccessibleRowDescription(int r) { return null; }
    7747
    7748             /**
    7749              * Sets the description text of the specified row of the table.
    7750              *
    7751              * @param r zero-based row of the table
    7752              * @param a the description of the row
    7753              * @since 1.3
    7754              */
    7755             public void setAccessibleRowDescription(int r, Accessible a) {}
    7756
    7757             /**
    7758              * Returns the description text of the specified column in the table.
    7759              *
    7760              * @param c zero-based column of the table
    7761              * @return the text description of the column
    7762              * @since 1.3
    7763              */
    7764             public Accessible getAccessibleColumnDescription(int c) { return null; }
    7765
    7766             /**
    7767              * Sets the description text of the specified column in the table.
    7768              *
    7769              * @param c zero-based column of the table
    7770              * @param a the text description of the column
    7771              * @since 1.3
    7772              */
    7773             public void setAccessibleColumnDescription(int c, Accessible a) {}
    7774
    7775             /**
    7776              * Returns a boolean value indicating whether the accessible at
    7777              * a specified row and column is selected.
    7778              *
    7779              * @param r zero-based row of the table
    7780              * @param c zero-based column of the table
    7781              * @return the boolean value true if the accessible at the
    7782              * row and column is selected. Otherwise, the boolean value
    7783              * false
    7784              * @since 1.3
    7785              */
    7786             public boolean isAccessibleSelected(int r, int c) { return false; }
    7787
    7788             /**
    7789              * Returns a boolean value indicating whether the specified row
    7790              * is selected.
    7791              *
    7792              * @param r zero-based row of the table
    7793              * @return the boolean value true if the specified row is selected.
    7794              * Otherwise, false.
    7795              * @since 1.3
    7796              */
    7797             public boolean isAccessibleRowSelected(int r) { return false; }
    7798
    7799             /**
    7800              * Returns a boolean value indicating whether the specified column
    7801              * is selected.
    7802              *
    7803              * @param c zero-based column of the table
    7804              * @return the boolean value true if the specified column is selected.
    7805              * Otherwise, false.
    7806              * @since 1.3
    7807              */
    7808             public boolean isAccessibleColumnSelected(int c) { return false; }
    7809
    7810             /**
    7811              * Returns the selected rows in a table.
    7812              *
    7813              * @return an array of selected rows where each element is a
    7814              * zero-based row of the table
    7815              * @since 1.3
    7816              */
    7817             public int [] getSelectedAccessibleRows() { return new int[0]; }
    7818
    7819             /**
    7820              * Returns the selected columns in a table.
    7821              *
    7822              * @return an array of selected columns where each element is a
    7823              * zero-based column of the table
    7824              * @since 1.3
    7825              */
    7826             public int [] getSelectedAccessibleColumns() { return new int[0]; }
    7827         }
    7828
    7829
    7830         /**
    7831          * Sets the column headers as an <code>AccessibleTable</code>.
    7832          *
    7833          * @param a an <code>AccessibleTable</code> representing the
    7834          * column headers
    7835          * @since 1.3
    7836          */
    7837         public void setAccessibleColumnHeader(AccessibleTable a) {
    7838             // XXX not implemented
    7839         }
    7840
    7841         /**
    7842          * Returns the description of the specified row in the table.
    7843          *
    7844          * @param r zero-based row of the table
    7845          * @return the description of the row
    7846          * @since 1.3
    7847          */
    7848         public Accessible getAccessibleRowDescription(int r) {
    7849             if (r < 0 || r >= getAccessibleRowCount()) {
    7850                 throw new IllegalArgumentException(Integer.toString(r));
    7851             }
    7852             if (rowDescription == null) {
    7853                 return null;
    7854             } else {
    7855                 return rowDescription[r];
    7856             }
    7857         }
    7858
    7859         /**
    7860          * Sets the description text of the specified row of the table.
    7861          *
    7862          * @param r zero-based row of the table
    7863          * @param a the description of the row
    7864          * @since 1.3
    7865          */
    7866         public void setAccessibleRowDescription(int r, Accessible a) {
    7867             if (r < 0 || r >= getAccessibleRowCount()) {
    7868                 throw new IllegalArgumentException(Integer.toString(r));
    7869             }
    7870             if (rowDescription == null) {
    7871                 int numRows = getAccessibleRowCount();
    7872                 rowDescription = new Accessible[numRows];
    7873             }
    7874             rowDescription[r] = a;
    7875         }
    7876
    7877         /**
    7878          * Returns the description of the specified column in the table.
    7879          *
    7880          * @param c zero-based column of the table
    7881          * @return the description of the column
    7882          * @since 1.3
    7883          */
    7884         public Accessible getAccessibleColumnDescription(int c) {
    7885             if (c < 0 || c >= getAccessibleColumnCount()) {
    7886                 throw new IllegalArgumentException(Integer.toString(c));
    7887             }
    7888             if (columnDescription == null) {
    7889                 return null;
    7890             } else {
    7891                 return columnDescription[c];
    7892             }
    7893         }
    7894
    7895         /**
    7896          * Sets the description text of the specified column of the table.
    7897          *
    7898          * @param c zero-based column of the table
    7899          * @param a the description of the column
    7900          * @since 1.3
    7901          */
    7902         public void setAccessibleColumnDescription(int c, Accessible a) {
    7903             if (c < 0 || c >= getAccessibleColumnCount()) {
    7904                 throw new IllegalArgumentException(Integer.toString(c));
    7905             }
    7906             if (columnDescription == null) {
    7907                 int numColumns = getAccessibleColumnCount();
    7908                 columnDescription = new Accessible[numColumns];
    7909             }
    7910             columnDescription[c] = a;
    7911         }
    7912
    7913         /**
    7914          * Returns a boolean value indicating whether the accessible at a
    7915          * given (row, column) is selected.
    7916          *
    7917          * @param r zero-based row of the table
    7918          * @param c zero-based column of the table
    7919          * @return the boolean value true if the accessible at (row, column)
    7920          *     is selected; otherwise, the boolean value false
    7921          * @since 1.3
    7922          */
    7923         public boolean isAccessibleSelected(int r, int c) {
    7924             return JTable.this.isCellSelected(r, c);
    7925         }
    7926
    7927         /**
    7928          * Returns a boolean value indicating whether the specified row
    7929          * is selected.
    7930          *
    7931          * @param r zero-based row of the table
    7932          * @return the boolean value true if the specified row is selected;
    7933          *     otherwise, false
    7934          * @since 1.3
    7935          */
    7936         public boolean isAccessibleRowSelected(int r) {
    7937             return JTable.this.isRowSelected(r);
    7938         }
    7939
    7940         /**
    7941          * Returns a boolean value indicating whether the specified column
    7942          * is selected.
    7943          *
    7944          * @param c zero-based column of the table
    7945          * @return the boolean value true if the specified column is selected;
    7946          *     otherwise, false
    7947          * @since 1.3
    7948          */
    7949         public boolean isAccessibleColumnSelected(int c) {
    7950             return JTable.this.isColumnSelected(c);
    7951         }
    7952
    7953         /**
    7954          * Returns the selected rows in a table.
    7955          *
    7956          * @return an array of selected rows where each element is a
    7957          *     zero-based row of the table
    7958          * @since 1.3
    7959          */
    7960         public int [] getSelectedAccessibleRows() {
    7961             return JTable.this.getSelectedRows();
    7962         }
    7963
    7964         /**
    7965          * Returns the selected columns in a table.
    7966          *
    7967          * @return an array of selected columns where each element is a
    7968          *     zero-based column of the table
    7969          * @since 1.3
    7970          */
    7971         public int [] getSelectedAccessibleColumns() {
    7972             return JTable.this.getSelectedColumns();
    7973         }
    7974
    7975         /**
    7976          * Returns the row at a given index into the table.
    7977          *
    7978          * @param i zero-based index into the table
    7979          * @return the row at a given index
    7980          * @since 1.3
    7981          */
    7982         public int getAccessibleRowAtIndex(int i) {
    7983             int columnCount = getAccessibleColumnCount();
    7984             if (columnCount == 0) {
    7985                 return -1;
    7986             } else {
    7987                 return (i / columnCount);
    7988             }
    7989         }
    7990
    7991         /**
    7992          * Returns the column at a given index into the table.
    7993          *
    7994          * @param i zero-based index into the table
    7995          * @return the column at a given index
    7996          * @since 1.3
    7997          */
    7998         public int getAccessibleColumnAtIndex(int i) {
    7999             int columnCount = getAccessibleColumnCount();
    8000             if (columnCount == 0) {
    8001                 return -1;
    8002             } else {
    8003                 return (i % columnCount);
    8004             }
    8005         }
    8006
    8007         /**
    8008          * Returns the index at a given (row, column) in the table.
    8009          *
    8010          * @param r zero-based row of the table
    8011          * @param c zero-based column of the table
    8012          * @return the index into the table
    8013          * @since 1.3
    8014          */
    8015         public int getAccessibleIndexAt(int r, int c) {
    8016             return ((r * getAccessibleColumnCount()) + c);
    8017         }
    8018
    8019         // end of AccessibleTable implementation --------------------
    8020
    8021         /**
    8022          * The class provides an implementation of the Java Accessibility
    8023          * API appropriate to table cells.
    8024          */
    8025         protected class AccessibleJTableCell extends AccessibleContext
    8026             implements Accessible, AccessibleComponent {
    8027
    8028             private JTable parent;
    8029             private int row;
    8030             private int column;
    8031             private int index;
    8032
    8033             /**
    8034              *  Constructs an <code>AccessibleJTableHeaderEntry</code>.
    8035              *
    8036              * @param t a {@code JTable}
    8037              * @param r an {@code int} specifying a row
    8038              * @param c an {@code int} specifying a column
    8039              * @param i an {@code int} specifying the index to this cell
    8040              * @since 1.4
    8041              */
    8042             public AccessibleJTableCell(JTable t, int r, int c, int i) {
    8043                 parent = t;
    8044                 row = r;
    8045                 column = c;
    8046                 index = i;
    8047                 this.setAccessibleParent(parent);
    8048             }
    8049
    8050             /**
    8051              * Gets the <code>AccessibleContext</code> associated with this
    8052              * component. In the implementation of the Java Accessibility
    8053              * API for this class, return this object, which is its own
    8054              * <code>AccessibleContext</code>.
    8055              *
    8056              * @return this object
    8057              */
    8058             public AccessibleContext getAccessibleContext() {
    8059                 return this;
    8060             }
    8061
    8062             /**
    8063              * Gets the AccessibleContext for the table cell renderer.
    8064              *
    8065              * @return the <code>AccessibleContext</code> for the table
    8066              * cell renderer if one exists;
    8067              * otherwise, returns <code>null</code>.
    8068              * @since 1.6
    8069              */
    8070             protected AccessibleContext getCurrentAccessibleContext() {
    8071                 TableColumn aColumn = getColumnModel().getColumn(column);
    8072                 TableCellRenderer renderer = aColumn.getCellRenderer();
    8073                 if (renderer == null) {
    8074                     Class<?> columnClass = getColumnClass(column);
    8075                     renderer = getDefaultRenderer(columnClass);
    8076                 }
    8077                 Component component = renderer.getTableCellRendererComponent(
    8078                                   JTable.this, getValueAt(row, column),
    8079                                   false, false, row, column);
    8080                 if (component instanceof Accessible) {
    8081                     return component.getAccessibleContext();
    8082                 } else {
    8083                     return null;
    8084                 }
    8085             }
    8086
    8087             /**
    8088              * Gets the table cell renderer component.
    8089              *
    8090              * @return the table cell renderer component if one exists;
    8091              * otherwise, returns <code>null</code>.
    8092              * @since 1.6
    8093              */
    8094             protected Component getCurrentComponent() {
    8095                 TableColumn aColumn = getColumnModel().getColumn(column);
    8096                 TableCellRenderer renderer = aColumn.getCellRenderer();
    8097                 if (renderer == null) {
    8098                     Class<?> columnClass = getColumnClass(column);
    8099                     renderer = getDefaultRenderer(columnClass);
    8100                 }
    8101                 return renderer.getTableCellRendererComponent(
    8102                                   JTable.this, null, false, false,
    8103                                   row, column);
    8104             }
    8105
    8106         // AccessibleContext methods
    8107
    8108             /**
    8109              * Gets the accessible name of this object.
    8110              *
    8111              * @return the localized name of the object; <code>null</code>
    8112              *     if this object does not have a name
    8113              */
    8114             public String getAccessibleName() {
    8115                 AccessibleContext ac = getCurrentAccessibleContext();
    8116                 if (ac != null) {
    8117                     String name = ac.getAccessibleName();
    8118                     if ((name != null) && (name != "")) {
    8119                         // return the cell renderer's AccessibleName
    8120                         return name;
    8121                     }
    8122                 }
    8123                 if ((accessibleName != null) && (accessibleName != "")) {
    8124                     return accessibleName;
    8125                 } else {
    8126                     // fall back to the client property
    8127                     return (String)getClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY);
    8128                 }
    8129             }
    8130
    8131             /**
    8132              * Sets the localized accessible name of this object.
    8133              *
    8134              * @param s the new localized name of the object
    8135              */
    8136             public void setAccessibleName(String s) {
    8137                 AccessibleContext ac = getCurrentAccessibleContext();
    8138                 if (ac != null) {
    8139                     ac.setAccessibleName(s);
    8140                 } else {
    8141                     super.setAccessibleName(s);
    8142                 }
    8143             }
    8144
    8145             //
    8146             // *** should check toolTip text for desc. (needs MouseEvent)
    8147             //
    8148             /**
    8149              * Gets the accessible description of this object.
    8150              *
    8151              * @return the localized description of the object;
    8152              *     <code>null</code> if this object does not have
    8153              *     a description
    8154              */
    8155             public String getAccessibleDescription() {
    8156                 AccessibleContext ac = getCurrentAccessibleContext();
    8157                 if (ac != null) {
    8158                     return ac.getAccessibleDescription();
    8159                 } else {
    8160                     return super.getAccessibleDescription();
    8161                 }
    8162             }
    8163
    8164             /**
    8165              * Sets the accessible description of this object.
    8166              *
    8167              * @param s the new localized description of the object
    8168              */
    8169             public void setAccessibleDescription(String s) {
    8170                 AccessibleContext ac = getCurrentAccessibleContext();
    8171                 if (ac != null) {
    8172                     ac.setAccessibleDescription(s);
    8173                 } else {
    8174                     super.setAccessibleDescription(s);
    8175                 }
    8176             }
    8177
    8178             /**
    8179              * Gets the role of this object.
    8180              *
    8181              * @return an instance of <code>AccessibleRole</code>
    8182              *      describing the role of the object
    8183              * @see AccessibleRole
    8184              */
    8185             public AccessibleRole getAccessibleRole() {
    8186                 AccessibleContext ac = getCurrentAccessibleContext();
    8187                 if (ac != null) {
    8188                     return ac.getAccessibleRole();
    8189                 } else {
    8190                     return AccessibleRole.UNKNOWN;
    8191                 }
    8192             }
    8193
    8194             /**
    8195              * Gets the state set of this object.
    8196              *
    8197              * @return an instance of <code>AccessibleStateSet</code>
    8198              *     containing the current state set of the object
    8199              * @see AccessibleState
    8200              */
    8201             public AccessibleStateSet getAccessibleStateSet() {
    8202                 AccessibleContext ac = getCurrentAccessibleContext();
    8203                 AccessibleStateSet as = null;
    8204
    8205                 if (ac != null) {
    8206                     as = ac.getAccessibleStateSet();
    8207                 }
    8208                 if (as == null) {
    8209                     as = new AccessibleStateSet();
    8210                 }
    8211                 Rectangle rjt = JTable.this.getVisibleRect();
    8212                 Rectangle rcell = JTable.this.getCellRect(row, column, false);
    8213                 if (rjt.intersects(rcell)) {
    8214                     as.add(AccessibleState.SHOWING);
    8215                 } else {
    8216                     if (as.contains(AccessibleState.SHOWING)) {
    8217                          as.remove(AccessibleState.SHOWING);
    8218                     }
    8219                 }
    8220                 if (parent.isCellSelected(row, column)) {
    8221                     as.add(AccessibleState.SELECTED);
    8222                 } else if (as.contains(AccessibleState.SELECTED)) {
    8223                     as.remove(AccessibleState.SELECTED);
    8224                 }
    8225                 if ((row == getSelectedRow()) && (column == getSelectedColumn())) {
    8226                     as.add(AccessibleState.ACTIVE);
    8227                 }
    8228                 as.add(AccessibleState.TRANSIENT);
    8229                 return as;
    8230             }
    8231
    8232             /**
    8233              * Gets the <code>Accessible</code> parent of this object.
    8234              *
    8235              * @return the Accessible parent of this object;
    8236              *     <code>null</code> if this object does not
    8237              *     have an <code>Accessible</code> parent
    8238              */
    8239             public Accessible getAccessibleParent() {
    8240                 return parent;
    8241             }
    8242
    8243             /**
    8244              * Gets the index of this object in its accessible parent.
    8245              *
    8246              * @return the index of this object in its parent; -1 if this
    8247              *     object does not have an accessible parent
    8248              * @see #getAccessibleParent
    8249              */
    8250             public int getAccessibleIndexInParent() {
    8251                 return index;
    8252             }
    8253
    8254             /**
    8255              * Returns the number of accessible children in the object.
    8256              *
    8257              * @return the number of accessible children in the object
    8258              */
    8259             public int getAccessibleChildrenCount() {
    8260                 AccessibleContext ac = getCurrentAccessibleContext();
    8261                 if (ac != null) {
    8262                     return ac.getAccessibleChildrenCount();
    8263                 } else {
    8264                     return 0;
    8265                 }
    8266             }
    8267
    8268             /**
    8269              * Returns the specified <code>Accessible</code> child of the
    8270              * object.
    8271              *
    8272              * @param i zero-based index of child
    8273              * @return the <code>Accessible</code> child of the object
    8274              */
    8275             public Accessible getAccessibleChild(int i) {
    8276                 AccessibleContext ac = getCurrentAccessibleContext();
    8277                 if (ac != null) {
    8278                     Accessible accessibleChild = ac.getAccessibleChild(i);
    8279                     ac.setAccessibleParent(this);
    8280                     return accessibleChild;
    8281                 } else {
    8282                     return null;
    8283                 }
    8284             }
    8285
    8286             /**
    8287              * Gets the locale of the component. If the component
    8288              * does not have a locale, then the locale of its parent
    8289              * is returned.
    8290              *
    8291              * @return this component's locale; if this component does
    8292              *    not have a locale, the locale of its parent is returned
    8293              * @exception IllegalComponentStateException if the
    8294              *    <code>Component</code> does not have its own locale
    8295              *    and has not yet been added to a containment hierarchy
    8296              *    such that the locale can be determined from the
    8297              *    containing parent
    8298              * @see #setLocale
    8299              */
    8300             public Locale getLocale() {
    8301                 AccessibleContext ac = getCurrentAccessibleContext();
    8302                 if (ac != null) {
    8303                     return ac.getLocale();
    8304                 } else {
    8305                     return null;
    8306                 }
    8307             }
    8308
    8309             /**
    8310              * Adds a <code>PropertyChangeListener</code> to the listener list.
    8311              * The listener is registered for all properties.
    8312              *
    8313              * @param l  the <code>PropertyChangeListener</code>
    8314              *     to be added
    8315              */
    8316             public void addPropertyChangeListener(PropertyChangeListener l) {
    8317                 AccessibleContext ac = getCurrentAccessibleContext();
    8318                 if (ac != null) {
    8319                     ac.addPropertyChangeListener(l);
    8320                 } else {
    8321                     super.addPropertyChangeListener(l);
    8322                 }
    8323             }
    8324
    8325             /**
    8326              * Removes a <code>PropertyChangeListener</code> from the
    8327              * listener list. This removes a <code>PropertyChangeListener</code>
    8328              * that was registered for all properties.
    8329              *
    8330              * @param l  the <code>PropertyChangeListener</code>
    8331              *    to be removed
    8332              */
    8333             public void removePropertyChangeListener(PropertyChangeListener l) {
    8334                 AccessibleContext ac = getCurrentAccessibleContext();
    8335                 if (ac != null) {
    8336                     ac.removePropertyChangeListener(l);
    8337                 } else {
    8338                     super.removePropertyChangeListener(l);
    8339                 }
    8340             }
    8341
    8342             /**
    8343              * Gets the <code>AccessibleAction</code> associated with this
    8344              * object if one exists.  Otherwise returns <code>null</code>.
    8345              *
    8346              * @return the <code>AccessibleAction</code>, or <code>null</code>
    8347              */
    8348             public AccessibleAction getAccessibleAction() {
    8349                 return getCurrentAccessibleContext().getAccessibleAction();
    8350             }
    8351
    8352             /**
    8353              * Gets the <code>AccessibleComponent</code> associated with
    8354              * this object if one exists.  Otherwise returns <code>null</code>.
    8355              *
    8356              * @return the <code>AccessibleComponent</code>, or
    8357              *    <code>null</code>
    8358              */
    8359             public AccessibleComponent getAccessibleComponent() {
    8360                 return this; // to override getBounds()
    8361             }
    8362
    8363             /**
    8364              * Gets the <code>AccessibleSelection</code> associated with
    8365              * this object if one exists.  Otherwise returns <code>null</code>.
    8366              *
    8367              * @return the <code>AccessibleSelection</code>, or
    8368              *    <code>null</code>
    8369              */
    8370             public AccessibleSelection getAccessibleSelection() {
    8371                 return getCurrentAccessibleContext().getAccessibleSelection();
    8372             }
    8373
    8374             /**
    8375              * Gets the <code>AccessibleText</code> associated with this
    8376              * object if one exists.  Otherwise returns <code>null</code>.
    8377              *
    8378              * @return the <code>AccessibleText</code>, or <code>null</code>
    8379              */
    8380             public AccessibleText getAccessibleText() {
    8381                 return getCurrentAccessibleContext().getAccessibleText();
    8382             }
    8383
    8384             /**
    8385              * Gets the <code>AccessibleValue</code> associated with
    8386              * this object if one exists.  Otherwise returns <code>null</code>.
    8387              *
    8388              * @return the <code>AccessibleValue</code>, or <code>null</code>
    8389              */
    8390             public AccessibleValue getAccessibleValue() {
    8391                 return getCurrentAccessibleContext().getAccessibleValue();
    8392             }
    8393
    8394
    8395         // AccessibleComponent methods
    8396
    8397             /**
    8398              * Gets the background color of this object.
    8399              *
    8400              * @return the background color, if supported, of the object;
    8401              *     otherwise, <code>null</code>
    8402              */
    8403             public Color getBackground() {
    8404                 AccessibleContext ac = getCurrentAccessibleContext();
    8405                 if (ac instanceof AccessibleComponent) {
    8406                     return ((AccessibleComponent) ac).getBackground();
    8407                 } else {
    8408                     Component c = getCurrentComponent();
    8409                     if (c != null) {
    8410                         return c.getBackground();
    8411                     } else {
    8412                         return null;
    8413                     }
    8414                 }
    8415             }
    8416
    8417             /**
    8418              * Sets the background color of this object.
    8419              *
    8420              * @param c the new <code>Color</code> for the background
    8421              */
    8422             public void setBackground(Color c) {
    8423                 AccessibleContext ac = getCurrentAccessibleContext();
    8424                 if (ac instanceof AccessibleComponent) {
    8425                     ((AccessibleComponent) ac).setBackground(c);
    8426                 } else {
    8427                     Component cp = getCurrentComponent();
    8428                     if (cp != null) {
    8429                         cp.setBackground(c);
    8430                     }
    8431                 }
    8432             }
    8433
    8434             /**
    8435              * Gets the foreground color of this object.
    8436              *
    8437              * @return the foreground color, if supported, of the object;
    8438              *     otherwise, <code>null</code>
    8439              */
    8440             public Color getForeground() {
    8441                 AccessibleContext ac = getCurrentAccessibleContext();
    8442                 if (ac instanceof AccessibleComponent) {
    8443                     return ((AccessibleComponent) ac).getForeground();
    8444                 } else {
    8445                     Component c = getCurrentComponent();
    8446                     if (c != null) {
    8447                         return c.getForeground();
    8448                     } else {
    8449                         return null;
    8450                     }
    8451                 }
    8452             }
    8453
    8454             /**
    8455              * Sets the foreground color of this object.
    8456              *
    8457              * @param c the new <code>Color</code> for the foreground
    8458              */
    8459             public void setForeground(Color c) {
    8460                 AccessibleContext ac = getCurrentAccessibleContext();
    8461                 if (ac instanceof AccessibleComponent) {
    8462                     ((AccessibleComponent) ac).setForeground(c);
    8463                 } else {
    8464                     Component cp = getCurrentComponent();
    8465                     if (cp != null) {
    8466                         cp.setForeground(c);
    8467                     }
    8468                 }
    8469             }
    8470
    8471             /**
    8472              * Gets the <code>Cursor</code> of this object.
    8473              *
    8474              * @return the <code>Cursor</code>, if supported,
    8475              *    of the object; otherwise, <code>null</code>
    8476              */
    8477             public Cursor getCursor() {
    8478                 AccessibleContext ac = getCurrentAccessibleContext();
    8479                 if (ac instanceof AccessibleComponent) {
    8480                     return ((AccessibleComponent) ac).getCursor();
    8481                 } else {
    8482                     Component c = getCurrentComponent();
    8483                     if (c != null) {
    8484                         return c.getCursor();
    8485                     } else {
    8486                         Accessible ap = getAccessibleParent();
    8487                         if (ap instanceof AccessibleComponent) {
    8488                             return ((AccessibleComponent) ap).getCursor();
    8489                         } else {
    8490                             return null;
    8491                         }
    8492                     }
    8493                 }
    8494             }
    8495
    8496             /**
    8497              * Sets the <code>Cursor</code> of this object.
    8498              *
    8499              * @param c the new <code>Cursor</code> for the object
    8500              */
    8501             public void setCursor(Cursor c) {
    8502                 AccessibleContext ac = getCurrentAccessibleContext();
    8503                 if (ac instanceof AccessibleComponent) {
    8504                     ((AccessibleComponent) ac).setCursor(c);
    8505                 } else {
    8506                     Component cp = getCurrentComponent();
    8507                     if (cp != null) {
    8508                         cp.setCursor(c);
    8509                     }
    8510                 }
    8511             }
    8512
    8513             /**
    8514              * Gets the <code>Font</code> of this object.
    8515              *
    8516              * @return the <code>Font</code>,if supported,
    8517              *   for the object; otherwise, <code>null</code>
    8518              */
    8519             public Font getFont() {
    8520                 AccessibleContext ac = getCurrentAccessibleContext();
    8521                 if (ac instanceof AccessibleComponent) {
    8522                     return ((AccessibleComponent) ac).getFont();
    8523                 } else {
    8524                     Component c = getCurrentComponent();
    8525                     if (c != null) {
    8526                         return c.getFont();
    8527                     } else {
    8528                         return null;
    8529                     }
    8530                 }
    8531             }
    8532
    8533             /**
    8534              * Sets the <code>Font</code> of this object.
    8535              *
    8536              * @param f the new <code>Font</code> for the object
    8537              */
    8538             public void setFont(Font f) {
    8539                 AccessibleContext ac = getCurrentAccessibleContext();
    8540                 if (ac instanceof AccessibleComponent) {
    8541                     ((AccessibleComponent) ac).setFont(f);
    8542                 } else {
    8543                     Component c = getCurrentComponent();
    8544                     if (c != null) {
    8545                         c.setFont(f);
    8546                     }
    8547                 }
    8548             }
    8549
    8550             /**
    8551              * Gets the <code>FontMetrics</code> of this object.
    8552              *
    8553              * @param f the <code>Font</code>
    8554              * @return the <code>FontMetrics</code> object, if supported;
    8555              *    otherwise <code>null</code>
    8556              * @see #getFont
    8557              */
    8558             public FontMetrics getFontMetrics(Font f) {
    8559                 AccessibleContext ac = getCurrentAccessibleContext();
    8560                 if (ac instanceof AccessibleComponent) {
    8561                     return ((AccessibleComponent) ac).getFontMetrics(f);
    8562                 } else {
    8563                     Component c = getCurrentComponent();
    8564                     if (c != null) {
    8565                         return c.getFontMetrics(f);
    8566                     } else {
    8567                         return null;
    8568                     }
    8569                 }
    8570             }
    8571
    8572             /**
    8573              * Determines if the object is enabled.
    8574              *
    8575              * @return true if object is enabled; otherwise, false
    8576              */
    8577             public boolean isEnabled() {
    8578                 AccessibleContext ac = getCurrentAccessibleContext();
    8579                 if (ac instanceof AccessibleComponent) {
    8580                     return ((AccessibleComponent) ac).isEnabled();
    8581                 } else {
    8582                     Component c = getCurrentComponent();
    8583                     if (c != null) {
    8584                         return c.isEnabled();
    8585                     } else {
    8586                         return false;
    8587                     }
    8588                 }
    8589             }
    8590
    8591             /**
    8592              * Sets the enabled state of the object.
    8593              *
    8594              * @param b if true, enables this object; otherwise, disables it
    8595              */
    8596             public void setEnabled(boolean b) {
    8597                 AccessibleContext ac = getCurrentAccessibleContext();
    8598                 if (ac instanceof AccessibleComponent) {
    8599                     ((AccessibleComponent) ac).setEnabled(b);
    8600                 } else {
    8601                     Component c = getCurrentComponent();
    8602                     if (c != null) {
    8603                         c.setEnabled(b);
    8604                     }
    8605                 }
    8606             }
    8607
    8608             /**
    8609              * Determines if this object is visible.  Note: this means that the
    8610              * object intends to be visible; however, it may not in fact be
    8611              * showing on the screen because one of the objects that this object
    8612              * is contained by is not visible.  To determine if an object is
    8613              * showing on the screen, use <code>isShowing</code>.
    8614              *
    8615              * @return true if object is visible; otherwise, false
    8616              */
    8617             public boolean isVisible() {
    8618                 AccessibleContext ac = getCurrentAccessibleContext();
    8619                 if (ac instanceof AccessibleComponent) {
    8620                     return ((AccessibleComponent) ac).isVisible();
    8621                 } else {
    8622                     Component c = getCurrentComponent();
    8623                     if (c != null) {
    8624                         return c.isVisible();
    8625                     } else {
    8626                         return false;
    8627                     }
    8628                 }
    8629             }
    8630
    8631             /**
    8632              * Sets the visible state of the object.
    8633              *
    8634              * @param b if true, shows this object; otherwise, hides it
    8635              */
    8636             public void setVisible(boolean b) {
    8637                 AccessibleContext ac = getCurrentAccessibleContext();
    8638                 if (ac instanceof AccessibleComponent) {
    8639                     ((AccessibleComponent) ac).setVisible(b);
    8640                 } else {
    8641                     Component c = getCurrentComponent();
    8642                     if (c != null) {
    8643                         c.setVisible(b);
    8644                     }
    8645                 }
    8646             }
    8647
    8648             /**
    8649              * Determines if the object is showing.  This is determined
    8650              * by checking the visibility of the object and ancestors
    8651              * of the object.  Note: this will return true even if the
    8652              * object is obscured by another (for example,
    8653              * it happens to be underneath a menu that was pulled down).
    8654              *
    8655              * @return true if the object is showing; otherwise, false
    8656              */
    8657             public boolean isShowing() {
    8658                 AccessibleContext ac = getCurrentAccessibleContext();
    8659                 if (ac instanceof AccessibleComponent) {
    8660                     if (ac.getAccessibleParent() != null) {
    8661                         return ((AccessibleComponent) ac).isShowing();
    8662                     } else {
    8663                         // Fixes 4529616 - AccessibleJTableCell.isShowing()
    8664                         // returns false when the cell on the screen
    8665                         // if no parent
    8666                         return isVisible();
    8667                     }
    8668                 } else {
    8669                     Component c = getCurrentComponent();
    8670                     if (c != null) {
    8671                         return c.isShowing();
    8672                     } else {
    8673                         return false;
    8674                     }
    8675                 }
    8676             }
    8677
    8678             /**
    8679              * Checks whether the specified point is within this
    8680              * object's bounds, where the point's x and y coordinates
    8681              * are defined to be relative to the coordinate system of
    8682              * the object.
    8683              *
    8684              * @param p the <code>Point</code> relative to the
    8685              *    coordinate system of the object
    8686              * @return true if object contains <code>Point</code>;
    8687              *    otherwise false
    8688              */
    8689             public boolean contains(Point p) {
    8690                 AccessibleContext ac = getCurrentAccessibleContext();
    8691                 if (ac instanceof AccessibleComponent) {
    8692                     Rectangle r = ((AccessibleComponent) ac).getBounds();
    8693                     return r.contains(p);
    8694                 } else {
    8695                     Component c = getCurrentComponent();
    8696                     if (c != null) {
    8697                         Rectangle r = c.getBounds();
    8698                         return r.contains(p);
    8699                     } else {
    8700                         return getBounds().contains(p);
    8701                     }
    8702                 }
    8703             }
    8704
    8705             /**
    8706              * Returns the location of the object on the screen.
    8707              *
    8708              * @return location of object on screen -- can be
    8709              *    <code>null</code> if this object is not on the screen
    8710              */
    8711             public Point getLocationOnScreen() {
    8712                 if (parent != null && parent.isShowing()) {
    8713                     Point parentLocation = parent.getLocationOnScreen();
    8714                     Point componentLocation = getLocation();
    8715                     componentLocation.translate(parentLocation.x, parentLocation.y);
    8716                     return componentLocation;
    8717                 } else {
    8718                     return null;
    8719                 }
    8720             }
    8721
    8722             /**
    8723              * Gets the location of the object relative to the parent
    8724              * in the form of a point specifying the object's
    8725              * top-left corner in the screen's coordinate space.
    8726              *
    8727              * @return an instance of <code>Point</code> representing
    8728              *    the top-left corner of the object's bounds in the
    8729              *    coordinate space of the screen; <code>null</code> if
    8730              *    this object or its parent are not on the screen
    8731              */
    8732             public Point getLocation() {
    8733                 if (parent != null) {
    8734                     Rectangle r = parent.getCellRect(row, column, false);
    8735                     if (r != null) {
    8736                         return r.getLocation();
    8737                     }
    8738                 }
    8739                 return null;
    8740             }
    8741
    8742             /**
    8743              * Sets the location of the object relative to the parent.
    8744              */
    8745             public void setLocation(Point p) {
    8746 //              if ((parent != null)  && (parent.contains(p))) {
    8747 //                  ensureIndexIsVisible(indexInParent);
    8748 //              }
    8749             }
    8750
    8751             public Rectangle getBounds() {
    8752                 if (parent != null) {
    8753                     return parent.getCellRect(row, column, false);
    8754                 } else {
    8755                     return null;
    8756                 }
    8757             }
    8758
    8759             public void setBounds(Rectangle r) {
    8760                 AccessibleContext ac = getCurrentAccessibleContext();
    8761                 if (ac instanceof AccessibleComponent) {
    8762                     ((AccessibleComponent) ac).setBounds(r);
    8763                 } else {
    8764                     Component c = getCurrentComponent();
    8765                     if (c != null) {
    8766                         c.setBounds(r);
    8767                     }
    8768                 }
    8769             }
    8770
    8771             public Dimension getSize() {
    8772                 if (parent != null) {
    8773                     Rectangle r = parent.getCellRect(row, column, false);
    8774                     if (r != null) {
    8775                         return r.getSize();
    8776                     }
    8777                 }
    8778                 return null;
    8779             }
    8780
    8781             public void setSize (Dimension d) {
    8782                 AccessibleContext ac = getCurrentAccessibleContext();
    8783                 if (ac instanceof AccessibleComponent) {
    8784                     ((AccessibleComponent) ac).setSize(d);
    8785                 } else {
    8786                     Component c = getCurrentComponent();
    8787                     if (c != null) {
    8788                         c.setSize(d);
    8789                     }
    8790                 }
    8791             }
    8792
    8793             public Accessible getAccessibleAt(Point p) {
    8794                 AccessibleContext ac = getCurrentAccessibleContext();
    8795                 if (ac instanceof AccessibleComponent) {
    8796                     return ((AccessibleComponent) ac).getAccessibleAt(p);
    8797                 } else {
    8798                     return null;
    8799                 }
    8800             }
    8801
    8802             @SuppressWarnings("deprecation")
    8803             public boolean isFocusTraversable() {
    8804                 AccessibleContext ac = getCurrentAccessibleContext();
    8805                 if (ac instanceof AccessibleComponent) {
    8806                     return ((AccessibleComponent) ac).isFocusTraversable();
    8807                 } else {
    8808                     Component c = getCurrentComponent();
    8809                     if (c != null) {
    8810                         return c.isFocusTraversable();
    8811                     } else {
    8812                         return false;
    8813                     }
    8814                 }
    8815             }
    8816
    8817             public void requestFocus() {
    8818                 AccessibleContext ac = getCurrentAccessibleContext();
    8819                 if (ac instanceof AccessibleComponent) {
    8820                     ((AccessibleComponent) ac).requestFocus();
    8821                 } else {
    8822                     Component c = getCurrentComponent();
    8823                     if (c != null) {
    8824                         c.requestFocus();
    8825                     }
    8826                 }
    8827             }
    8828
    8829             public void addFocusListener(FocusListener l) {
    8830                 AccessibleContext ac = getCurrentAccessibleContext();
    8831                 if (ac instanceof AccessibleComponent) {
    8832                     ((AccessibleComponent) ac).addFocusListener(l);
    8833                 } else {
    8834                     Component c = getCurrentComponent();
    8835                     if (c != null) {
    8836                         c.addFocusListener(l);
    8837                     }
    8838                 }
    8839             }
    8840
    8841             public void removeFocusListener(FocusListener l) {
    8842                 AccessibleContext ac = getCurrentAccessibleContext();
    8843                 if (ac instanceof AccessibleComponent) {
    8844                     ((AccessibleComponent) ac).removeFocusListener(l);
    8845                 } else {
    8846                     Component c = getCurrentComponent();
    8847                     if (c != null) {
    8848                         c.removeFocusListener(l);
    8849                     }
    8850                 }
    8851             }
    8852
    8853         } // inner class AccessibleJTableCell
    8854
    8855         // Begin AccessibleJTableHeader ========== // TIGER - 4715503
    8856
    8857         /**
    8858          * This class implements accessibility for JTable header cells.
    8859          */
    8860         private class AccessibleJTableHeaderCell extends AccessibleContext
    8861             implements Accessible, AccessibleComponent {
    8862
    8863             private int row;
    8864             private int column;
    8865             private JTableHeader parent;
    8866             private Component rendererComponent;
    8867
    8868             /**
    8869              * Constructs an <code>AccessibleJTableHeaderEntry</code> instance.
    8870              *
    8871              * @param row header cell row index
    8872              * @param column header cell column index
    8873              * @param parent header cell parent
    8874              * @param rendererComponent component that renders the header cell
    8875              */
    8876             public AccessibleJTableHeaderCell(int row, int column,
    8877                                               JTableHeader parent,
    8878                                               Component rendererComponent) {
    8879                 this.row = row;
    8880                 this.column = column;
    8881                 this.parent = parent;
    8882                 this.rendererComponent = rendererComponent;
    8883                 this.setAccessibleParent(parent);
    8884             }
    8885
    8886             /**
    8887              * Gets the <code>AccessibleContext</code> associated with this
    8888              * component. In the implementation of the Java Accessibility
    8889              * API for this class, return this object, which is its own
    8890              * <code>AccessibleContext</code>.
    8891              *
    8892              * @return this object
    8893              */
    8894             public AccessibleContext getAccessibleContext() {
    8895                 return this;
    8896             }
    8897
    8898             /*
    8899              * Returns the AccessibleContext for the header cell
    8900              * renderer.
    8901              */
    8902             private AccessibleContext getCurrentAccessibleContext() {
    8903                 return rendererComponent.getAccessibleContext();
    8904             }
    8905
    8906             /*
    8907              * Returns the component that renders the header cell.
    8908              */
    8909             private Component getCurrentComponent() {
    8910                 return rendererComponent;
    8911             }
    8912
    8913             // AccessibleContext methods ==========
    8914
    8915             /**
    8916              * Gets the accessible name of this object.
    8917              *
    8918              * @return the localized name of the object; <code>null</code>
    8919              *     if this object does not have a name
    8920              */
    8921             public String getAccessibleName() {
    8922                 AccessibleContext ac = getCurrentAccessibleContext();
    8923                 if (ac != null) {
    8924                     String name = ac.getAccessibleName();
    8925                     if ((name != null) && (name != "")) {
    8926                         return ac.getAccessibleName();
    8927                     }
    8928                 }
    8929                 if ((accessibleName != null) && (accessibleName != "")) {
    8930                     return accessibleName;
    8931                 } else {
    8932                     return null;
    8933                 }
    8934             }
    8935
    8936             /**
    8937              * Sets the localized accessible name of this object.
    8938              *
    8939              * @param s the new localized name of the object
    8940              */
    8941             public void setAccessibleName(String s) {
    8942                 AccessibleContext ac = getCurrentAccessibleContext();
    8943                 if (ac != null) {
    8944                     ac.setAccessibleName(s);
    8945                 } else {
    8946                     super.setAccessibleName(s);
    8947                 }
    8948             }
    8949
    8950             /**
    8951              * Gets the accessible description of this object.
    8952              *
    8953              * @return the localized description of the object;
    8954              *     <code>null</code> if this object does not have
    8955              *     a description
    8956              */
    8957             public String getAccessibleDescription() {
    8958                 AccessibleContext ac = getCurrentAccessibleContext();
    8959                 if (ac != null) {
    8960                     return ac.getAccessibleDescription();
    8961                 } else {
    8962                     return super.getAccessibleDescription();
    8963                 }
    8964             }
    8965
    8966             /**
    8967              * Sets the accessible description of this object.
    8968              *
    8969              * @param s the new localized description of the object
    8970              */
    8971             public void setAccessibleDescription(String s) {
    8972                 AccessibleContext ac = getCurrentAccessibleContext();
    8973                 if (ac != null) {
    8974                     ac.setAccessibleDescription(s);
    8975                 } else {
    8976                     super.setAccessibleDescription(s);
    8977                 }
    8978             }
    8979
    8980             /**
    8981              * Gets the role of this object.
    8982              *
    8983              * @return an instance of <code>AccessibleRole</code>
    8984              *      describing the role of the object
    8985              * @see AccessibleRole
    8986              */
    8987             public AccessibleRole getAccessibleRole() {
    8988                 AccessibleContext ac = getCurrentAccessibleContext();
    8989                 if (ac != null) {
    8990                     return ac.getAccessibleRole();
    8991                 } else {
    8992                     return AccessibleRole.UNKNOWN;
    8993                 }
    8994             }
    8995
    8996             /**
    8997              * Gets the state set of this object.
    8998              *
    8999              * @return an instance of <code>AccessibleStateSet</code>
    9000              *     containing the current state set of the object
    9001              * @see AccessibleState
    9002              */
    9003             public AccessibleStateSet getAccessibleStateSet() {
    9004                 AccessibleContext ac = getCurrentAccessibleContext();
    9005                 AccessibleStateSet as = null;
    9006
    9007                 if (ac != null) {
    9008                     as = ac.getAccessibleStateSet();
    9009                 }
    9010                 if (as == null) {
    9011                     as = new AccessibleStateSet();
    9012                 }
    9013                 Rectangle rjt = JTable.this.getVisibleRect();
    9014                 Rectangle rcell = JTable.this.getCellRect(row, column, false);
    9015                 if (rjt.intersects(rcell)) {
    9016                     as.add(AccessibleState.SHOWING);
    9017                 } else {
    9018                     if (as.contains(AccessibleState.SHOWING)) {
    9019                          as.remove(AccessibleState.SHOWING);
    9020                     }
    9021                 }
    9022                 if (JTable.this.isCellSelected(row, column)) {
    9023                     as.add(AccessibleState.SELECTED);
    9024                 } else if (as.contains(AccessibleState.SELECTED)) {
    9025                     as.remove(AccessibleState.SELECTED);
    9026                 }
    9027                 if ((row == getSelectedRow()) && (column == getSelectedColumn())) {
    9028                     as.add(AccessibleState.ACTIVE);
    9029                 }
    9030                 as.add(AccessibleState.TRANSIENT);
    9031                 return as;
    9032             }
    9033
    9034             /**
    9035              * Gets the <code>Accessible</code> parent of this object.
    9036              *
    9037              * @return the Accessible parent of this object;
    9038              *     <code>null</code> if this object does not
    9039              *     have an <code>Accessible</code> parent
    9040              */
    9041             public Accessible getAccessibleParent() {
    9042                 return parent;
    9043             }
    9044
    9045             /**
    9046              * Gets the index of this object in its accessible parent.
    9047              *
    9048              * @return the index of this object in its parent; -1 if this
    9049              *     object does not have an accessible parent
    9050              * @see #getAccessibleParent
    9051              */
    9052             public int getAccessibleIndexInParent() {
    9053                 return column;
    9054             }
    9055
    9056             /**
    9057              * Returns the number of accessible children in the object.
    9058              *
    9059              * @return the number of accessible children in the object
    9060              */
    9061             public int getAccessibleChildrenCount() {
    9062                 AccessibleContext ac = getCurrentAccessibleContext();
    9063                 if (ac != null) {
    9064                     return ac.getAccessibleChildrenCount();
    9065                 } else {
    9066                     return 0;
    9067                 }
    9068             }
    9069
    9070             /**
    9071              * Returns the specified <code>Accessible</code> child of the
    9072              * object.
    9073              *
    9074              * @param i zero-based index of child
    9075              * @return the <code>Accessible</code> child of the object
    9076              */
    9077             public Accessible getAccessibleChild(int i) {
    9078                 AccessibleContext ac = getCurrentAccessibleContext();
    9079                 if (ac != null) {
    9080                     Accessible accessibleChild = ac.getAccessibleChild(i);
    9081                     ac.setAccessibleParent(this);
    9082                     return accessibleChild;
    9083                 } else {
    9084                     return null;
    9085                 }
    9086             }
    9087
    9088             /**
    9089              * Gets the locale of the component. If the component
    9090              * does not have a locale, then the locale of its parent
    9091              * is returned.
    9092              *
    9093              * @return this component's locale; if this component does
    9094              *    not have a locale, the locale of its parent is returned
    9095              * @exception IllegalComponentStateException if the
    9096              *    <code>Component</code> does not have its own locale
    9097              *    and has not yet been added to a containment hierarchy
    9098              *    such that the locale can be determined from the
    9099              *    containing parent
    9100              * @see #setLocale
    9101              */
    9102             public Locale getLocale() {
    9103                 AccessibleContext ac = getCurrentAccessibleContext();
    9104                 if (ac != null) {
    9105                     return ac.getLocale();
    9106                 } else {
    9107                     return null;
    9108                 }
    9109             }
    9110
    9111             /**
    9112              * Adds a <code>PropertyChangeListener</code> to the listener list.
    9113              * The listener is registered for all properties.
    9114              *
    9115              * @param l  the <code>PropertyChangeListener</code>
    9116              *     to be added
    9117              */
    9118             public void addPropertyChangeListener(PropertyChangeListener l) {
    9119                 AccessibleContext ac = getCurrentAccessibleContext();
    9120                 if (ac != null) {
    9121                     ac.addPropertyChangeListener(l);
    9122                 } else {
    9123                     super.addPropertyChangeListener(l);
    9124                 }
    9125             }
    9126
    9127             /**
    9128              * Removes a <code>PropertyChangeListener</code> from the
    9129              * listener list. This removes a <code>PropertyChangeListener</code>
    9130              * that was registered for all properties.
    9131              *
    9132              * @param l  the <code>PropertyChangeListener</code>
    9133              *    to be removed
    9134              */
    9135             public void removePropertyChangeListener(PropertyChangeListener l) {
    9136                 AccessibleContext ac = getCurrentAccessibleContext();
    9137                 if (ac != null) {
    9138                     ac.removePropertyChangeListener(l);
    9139                 } else {
    9140                     super.removePropertyChangeListener(l);
    9141                 }
    9142             }
    9143
    9144             /**
    9145              * Gets the <code>AccessibleAction</code> associated with this
    9146              * object if one exists.  Otherwise returns <code>null</code>.
    9147              *
    9148              * @return the <code>AccessibleAction</code>, or <code>null</code>
    9149              */
    9150             public AccessibleAction getAccessibleAction() {
    9151                 return getCurrentAccessibleContext().getAccessibleAction();
    9152             }
    9153
    9154             /**
    9155              * Gets the <code>AccessibleComponent</code> associated with
    9156              * this object if one exists.  Otherwise returns <code>null</code>.
    9157              *
    9158              * @return the <code>AccessibleComponent</code>, or
    9159              *    <code>null</code>
    9160              */
    9161             public AccessibleComponent getAccessibleComponent() {
    9162                 return this; // to override getBounds()
    9163             }
    9164
    9165             /**
    9166              * Gets the <code>AccessibleSelection</code> associated with
    9167              * this object if one exists.  Otherwise returns <code>null</code>.
    9168              *
    9169              * @return the <code>AccessibleSelection</code>, or
    9170              *    <code>null</code>
    9171              */
    9172             public AccessibleSelection getAccessibleSelection() {
    9173                 return getCurrentAccessibleContext().getAccessibleSelection();
    9174             }
    9175
    9176             /**
    9177              * Gets the <code>AccessibleText</code> associated with this
    9178              * object if one exists.  Otherwise returns <code>null</code>.
    9179              *
    9180              * @return the <code>AccessibleText</code>, or <code>null</code>
    9181              */
    9182             public AccessibleText getAccessibleText() {
    9183                 return getCurrentAccessibleContext().getAccessibleText();
    9184             }
    9185
    9186             /**
    9187              * Gets the <code>AccessibleValue</code> associated with
    9188              * this object if one exists.  Otherwise returns <code>null</code>.
    9189              *
    9190              * @return the <code>AccessibleValue</code>, or <code>null</code>
    9191              */
    9192             public AccessibleValue getAccessibleValue() {
    9193                 return getCurrentAccessibleContext().getAccessibleValue();
    9194             }
    9195
    9196
    9197             // AccessibleComponent methods ==========
    9198
    9199             /**
    9200              * Gets the background color of this object.
    9201              *
    9202              * @return the background color, if supported, of the object;
    9203              *     otherwise, <code>null</code>
    9204              */
    9205             public Color getBackground() {
    9206                 AccessibleContext ac = getCurrentAccessibleContext();
    9207                 if (ac instanceof AccessibleComponent) {
    9208                     return ((AccessibleComponent) ac).getBackground();
    9209                 } else {
    9210                     Component c = getCurrentComponent();
    9211                     if (c != null) {
    9212                         return c.getBackground();
    9213                     } else {
    9214                         return null;
    9215                     }
    9216                 }
    9217             }
    9218
    9219             /**
    9220              * Sets the background color of this object.
    9221              *
    9222              * @param c the new <code>Color</code> for the background
    9223              */
    9224             public void setBackground(Color c) {
    9225                 AccessibleContext ac = getCurrentAccessibleContext();
    9226                 if (ac instanceof AccessibleComponent) {
    9227                     ((AccessibleComponent) ac).setBackground(c);
    9228                 } else {
    9229                     Component cp = getCurrentComponent();
    9230                     if (cp != null) {
    9231                         cp.setBackground(c);
    9232                     }
    9233                 }
    9234             }
    9235
    9236             /**
    9237              * Gets the foreground color of this object.
    9238              *
    9239              * @return the foreground color, if supported, of the object;
    9240              *     otherwise, <code>null</code>
    9241              */
    9242             public Color getForeground() {
    9243                 AccessibleContext ac = getCurrentAccessibleContext();
    9244                 if (ac instanceof AccessibleComponent) {
    9245                     return ((AccessibleComponent) ac).getForeground();
    9246                 } else {
    9247                     Component c = getCurrentComponent();
    9248                     if (c != null) {
    9249                         return c.getForeground();
    9250                     } else {
    9251                         return null;
    9252                     }
    9253                 }
    9254             }
    9255
    9256             /**
    9257              * Sets the foreground color of this object.
    9258              *
    9259              * @param c the new <code>Color</code> for the foreground
    9260              */
    9261             public void setForeground(Color c) {
    9262                 AccessibleContext ac = getCurrentAccessibleContext();
    9263                 if (ac instanceof AccessibleComponent) {
    9264                     ((AccessibleComponent) ac).setForeground(c);
    9265                 } else {
    9266                     Component cp = getCurrentComponent();
    9267                     if (cp != null) {
    9268                         cp.setForeground(c);
    9269                     }
    9270                 }
    9271             }
    9272
    9273             /**
    9274              * Gets the <code>Cursor</code> of this object.
    9275              *
    9276              * @return the <code>Cursor</code>, if supported,
    9277              *    of the object; otherwise, <code>null</code>
    9278              */
    9279             public Cursor getCursor() {
    9280                 AccessibleContext ac = getCurrentAccessibleContext();
    9281                 if (ac instanceof AccessibleComponent) {
    9282                     return ((AccessibleComponent) ac).getCursor();
    9283                 } else {
    9284                     Component c = getCurrentComponent();
    9285                     if (c != null) {
    9286                         return c.getCursor();
    9287                     } else {
    9288                         Accessible ap = getAccessibleParent();
    9289                         if (ap instanceof AccessibleComponent) {
    9290                             return ((AccessibleComponent) ap).getCursor();
    9291                         } else {
    9292                             return null;
    9293                         }
    9294                     }
    9295                 }
    9296             }
    9297
    9298             /**
    9299              * Sets the <code>Cursor</code> of this object.
    9300              *
    9301              * @param c the new <code>Cursor</code> for the object
    9302              */
    9303             public void setCursor(Cursor c) {
    9304                 AccessibleContext ac = getCurrentAccessibleContext();
    9305                 if (ac instanceof AccessibleComponent) {
    9306                     ((AccessibleComponent) ac).setCursor(c);
    9307                 } else {
    9308                     Component cp = getCurrentComponent();
    9309                     if (cp != null) {
    9310                         cp.setCursor(c);
    9311                     }
    9312                 }
    9313             }
    9314
    9315             /**
    9316              * Gets the <code>Font</code> of this object.
    9317              *
    9318              * @return the <code>Font</code>,if supported,
    9319              *   for the object; otherwise, <code>null</code>
    9320              */
    9321             public Font getFont() {
    9322                 AccessibleContext ac = getCurrentAccessibleContext();
    9323                 if (ac instanceof AccessibleComponent) {
    9324                     return ((AccessibleComponent) ac).getFont();
    9325                 } else {
    9326                     Component c = getCurrentComponent();
    9327                     if (c != null) {
    9328                         return c.getFont();
    9329                     } else {
    9330                         return null;
    9331                     }
    9332                 }
    9333             }
    9334
    9335             /**
    9336              * Sets the <code>Font</code> of this object.
    9337              *
    9338              * @param f the new <code>Font</code> for the object
    9339              */
    9340             public void setFont(Font f) {
    9341                 AccessibleContext ac = getCurrentAccessibleContext();
    9342                 if (ac instanceof AccessibleComponent) {
    9343                     ((AccessibleComponent) ac).setFont(f);
    9344                 } else {
    9345                     Component c = getCurrentComponent();
    9346                     if (c != null) {
    9347                         c.setFont(f);
    9348                     }
    9349                 }
    9350             }
    9351
    9352             /**
    9353              * Gets the <code>FontMetrics</code> of this object.
    9354              *
    9355              * @param f the <code>Font</code>
    9356              * @return the <code>FontMetrics</code> object, if supported;
    9357              *    otherwise <code>null</code>
    9358              * @see #getFont
    9359              */
    9360             public FontMetrics getFontMetrics(Font f) {
    9361                 AccessibleContext ac = getCurrentAccessibleContext();
    9362                 if (ac instanceof AccessibleComponent) {
    9363                     return ((AccessibleComponent) ac).getFontMetrics(f);
    9364                 } else {
    9365                     Component c = getCurrentComponent();
    9366                     if (c != null) {
    9367                         return c.getFontMetrics(f);
    9368                     } else {
    9369                         return null;
    9370                     }
    9371                 }
    9372             }
    9373
    9374             /**
    9375              * Determines if the object is enabled.
    9376              *
    9377              * @return true if object is enabled; otherwise, false
    9378              */
    9379             public boolean isEnabled() {
    9380                 AccessibleContext ac = getCurrentAccessibleContext();
    9381                 if (ac instanceof AccessibleComponent) {
    9382                     return ((AccessibleComponent) ac).isEnabled();
    9383                 } else {
    9384                     Component c = getCurrentComponent();
    9385                     if (c != null) {
    9386                         return c.isEnabled();
    9387                     } else {
    9388                         return false;
    9389                     }
    9390                 }
    9391             }
    9392
    9393             /**
    9394              * Sets the enabled state of the object.
    9395              *
    9396              * @param b if true, enables this object; otherwise, disables it
    9397              */
    9398             public void setEnabled(boolean b) {
    9399                 AccessibleContext ac = getCurrentAccessibleContext();
    9400                 if (ac instanceof AccessibleComponent) {
    9401                     ((AccessibleComponent) ac).setEnabled(b);
    9402                 } else {
    9403                     Component c = getCurrentComponent();
    9404                     if (c != null) {
    9405                         c.setEnabled(b);
    9406                     }
    9407                 }
    9408             }
    9409
    9410             /**
    9411              * Determines if this object is visible.  Note: this means that the
    9412              * object intends to be visible; however, it may not in fact be
    9413              * showing on the screen because one of the objects that this object
    9414              * is contained by is not visible.  To determine if an object is
    9415              * showing on the screen, use <code>isShowing</code>.
    9416              *
    9417              * @return true if object is visible; otherwise, false
    9418              */
    9419             public boolean isVisible() {
    9420                 AccessibleContext ac = getCurrentAccessibleContext();
    9421                 if (ac instanceof AccessibleComponent) {
    9422                     return ((AccessibleComponent) ac).isVisible();
    9423                 } else {
    9424                     Component c = getCurrentComponent();
    9425                     if (c != null) {
    9426                         return c.isVisible();
    9427                     } else {
    9428                         return false;
    9429                     }
    9430                 }
    9431             }
    9432
    9433             /**
    9434              * Sets the visible state of the object.
    9435              *
    9436              * @param b if true, shows this object; otherwise, hides it
    9437              */
    9438             public void setVisible(boolean b) {
    9439                 AccessibleContext ac = getCurrentAccessibleContext();
    9440                 if (ac instanceof AccessibleComponent) {
    9441                     ((AccessibleComponent) ac).setVisible(b);
    9442                 } else {
    9443                     Component c = getCurrentComponent();
    9444                     if (c != null) {
    9445                         c.setVisible(b);
    9446                     }
    9447                 }
    9448             }
    9449
    9450             /**
    9451              * Determines if the object is showing.  This is determined
    9452              * by checking the visibility of the object and ancestors
    9453              * of the object.  Note: this will return true even if the
    9454              * object is obscured by another (for example,
    9455              * it happens to be underneath a menu that was pulled down).
    9456              *
    9457              * @return true if the object is showing; otherwise, false
    9458              */
    9459             public boolean isShowing() {
    9460                 AccessibleContext ac = getCurrentAccessibleContext();
    9461                 if (ac instanceof AccessibleComponent) {
    9462                     if (ac.getAccessibleParent() != null) {
    9463                         return ((AccessibleComponent) ac).isShowing();
    9464                     } else {
    9465                         // Fixes 4529616 - AccessibleJTableCell.isShowing()
    9466                         // returns false when the cell on the screen
    9467                         // if no parent
    9468                         return isVisible();
    9469                     }
    9470                 } else {
    9471                     Component c = getCurrentComponent();
    9472                     if (c != null) {
    9473                         return c.isShowing();
    9474                     } else {
    9475                         return false;
    9476                     }
    9477                 }
    9478             }
    9479
    9480             /**
    9481              * Checks whether the specified point is within this
    9482              * object's bounds, where the point's x and y coordinates
    9483              * are defined to be relative to the coordinate system of
    9484              * the object.
    9485              *
    9486              * @param p the <code>Point</code> relative to the
    9487              *    coordinate system of the object
    9488              * @return true if object contains <code>Point</code>;
    9489              *    otherwise false
    9490              */
    9491             public boolean contains(Point p) {
    9492                 AccessibleContext ac = getCurrentAccessibleContext();
    9493                 if (ac instanceof AccessibleComponent) {
    9494                     Rectangle r = ((AccessibleComponent) ac).getBounds();
    9495                     return r.contains(p);
    9496                 } else {
    9497                     Component c = getCurrentComponent();
    9498                     if (c != null) {
    9499                         Rectangle r = c.getBounds();
    9500                         return r.contains(p);
    9501                     } else {
    9502                         return getBounds().contains(p);
    9503                     }
    9504                 }
    9505             }
    9506
    9507             /**
    9508              * Returns the location of the object on the screen.
    9509              *
    9510              * @return location of object on screen -- can be
    9511              *    <code>null</code> if this object is not on the screen
    9512              */
    9513             public Point getLocationOnScreen() {
    9514                 if (parent != null && parent.isShowing()) {
    9515                     Point parentLocation = parent.getLocationOnScreen();
    9516                     Point componentLocation = getLocation();
    9517                     componentLocation.translate(parentLocation.x, parentLocation.y);
    9518                     return componentLocation;
    9519                 } else {
    9520                     return null;
    9521                 }
    9522             }
    9523
    9524             /**
    9525              * Gets the location of the object relative to the parent
    9526              * in the form of a point specifying the object's
    9527              * top-left corner in the screen's coordinate space.
    9528              *
    9529              * @return an instance of <code>Point</code> representing
    9530              *    the top-left corner of the object's bounds in the
    9531              *    coordinate space of the screen; <code>null</code> if
    9532              *    this object or its parent are not on the screen
    9533              */
    9534             public Point getLocation() {
    9535                 if (parent != null) {
    9536                     Rectangle r = parent.getHeaderRect(column);
    9537                     if (r != null) {
    9538                         return r.getLocation();
    9539                     }
    9540                 }
    9541                 return null;
    9542             }
    9543
    9544             /**
    9545              * Sets the location of the object relative to the parent.
    9546              * @param p the new position for the top-left corner
    9547              * @see #getLocation
    9548              */
    9549             public void setLocation(Point p) {
    9550             }
    9551
    9552             /**
    9553              * Gets the bounds of this object in the form of a Rectangle object.
    9554              * The bounds specify this object's width, height, and location
    9555              * relative to its parent.
    9556              *
    9557              * @return A rectangle indicating this component's bounds; null if
    9558              * this object is not on the screen.
    9559              * @see #contains
    9560              */
    9561             public Rectangle getBounds() {
    9562                 if (parent != null) {
    9563                     return parent.getHeaderRect(column);
    9564                 } else {
    9565                     return null;
    9566                 }
    9567             }
    9568
    9569             /**
    9570              * Sets the bounds of this object in the form of a Rectangle object.
    9571              * The bounds specify this object's width, height, and location
    9572              * relative to its parent.
    9573              *
    9574              * @param r rectangle indicating this component's bounds
    9575              * @see #getBounds
    9576              */
    9577             public void setBounds(Rectangle r) {
    9578                 AccessibleContext ac = getCurrentAccessibleContext();
    9579                 if (ac instanceof AccessibleComponent) {
    9580                     ((AccessibleComponent) ac).setBounds(r);
    9581                 } else {
    9582                     Component c = getCurrentComponent();
    9583                     if (c != null) {
    9584                         c.setBounds(r);
    9585                     }
    9586                 }
    9587             }
    9588
    9589             /**
    9590              * Returns the size of this object in the form of a Dimension object.
    9591              * The height field of the Dimension object contains this object's
    9592              * height, and the width field of the Dimension object contains this
    9593              * object's width.
    9594              *
    9595              * @return A Dimension object that indicates the size of this component;
    9596              * null if this object is not on the screen
    9597              * @see #setSize
    9598              */
    9599             public Dimension getSize() {
    9600                 if (parent != null) {
    9601                     Rectangle r = parent.getHeaderRect(column);
    9602                     if (r != null) {
    9603                         return r.getSize();
    9604                     }
    9605                 }
    9606                 return null;
    9607             }
    9608
    9609             /**
    9610              * Resizes this object so that it has width and height.
    9611              *
    9612              * @param d The dimension specifying the new size of the object.
    9613              * @see #getSize
    9614              */
    9615             public void setSize (Dimension d) {
    9616                 AccessibleContext ac = getCurrentAccessibleContext();
    9617                 if (ac instanceof AccessibleComponent) {
    9618                     ((AccessibleComponent) ac).setSize(d);
    9619                 } else {
    9620                     Component c = getCurrentComponent();
    9621                     if (c != null) {
    9622                         c.setSize(d);
    9623                     }
    9624                 }
    9625             }
    9626
    9627             /**
    9628              * Returns the Accessible child, if one exists, contained at the local
    9629              * coordinate Point.
    9630              *
    9631              * @param p The point relative to the coordinate system of this object.
    9632              * @return the Accessible, if it exists, at the specified location;
    9633              * otherwise null
    9634              */
    9635             public Accessible getAccessibleAt(Point p) {
    9636                 AccessibleContext ac = getCurrentAccessibleContext();
    9637                 if (ac instanceof AccessibleComponent) {
    9638                     return ((AccessibleComponent) ac).getAccessibleAt(p);
    9639                 } else {
    9640                     return null;
    9641                 }
    9642             }
    9643
    9644             /**
    9645              * Returns whether this object can accept focus or not.   Objects that
    9646              * can accept focus will also have the AccessibleState.FOCUSABLE state
    9647              * set in their AccessibleStateSets.
    9648              *
    9649              * @return true if object can accept focus; otherwise false
    9650              * @see AccessibleContext#getAccessibleStateSet
    9651              * @see AccessibleState#FOCUSABLE
    9652              * @see AccessibleState#FOCUSED
    9653              * @see AccessibleStateSet
    9654              */
    9655             @SuppressWarnings("deprecation")
    9656             public boolean isFocusTraversable() {
    9657                 AccessibleContext ac = getCurrentAccessibleContext();
    9658                 if (ac instanceof AccessibleComponent) {
    9659                     return ((AccessibleComponent) ac).isFocusTraversable();
    9660                 } else {
    9661                     Component c = getCurrentComponent();
    9662                     if (c != null) {
    9663                         return c.isFocusTraversable();
    9664                     } else {
    9665                         return false;
    9666                     }
    9667                 }
    9668             }
    9669
    9670             /**
    9671              * Requests focus for this object.  If this object cannot accept focus,
    9672              * nothing will happen.  Otherwise, the object will attempt to take
    9673              * focus.
    9674              * @see #isFocusTraversable
    9675              */
    9676             public void requestFocus() {
    9677                 AccessibleContext ac = getCurrentAccessibleContext();
    9678                 if (ac instanceof AccessibleComponent) {
    9679                     ((AccessibleComponent) ac).requestFocus();
    9680                 } else {
    9681                     Component c = getCurrentComponent();
    9682                     if (c != null) {
    9683                         c.requestFocus();
    9684                     }
    9685                 }
    9686             }
    9687
    9688             /**
    9689              * Adds the specified focus listener to receive focus events from this
    9690              * component.
    9691              *
    9692              * @param l the focus listener
    9693              * @see #removeFocusListener
    9694              */
    9695             public void addFocusListener(FocusListener l) {
    9696                 AccessibleContext ac = getCurrentAccessibleContext();
    9697                 if (ac instanceof AccessibleComponent) {
    9698                     ((AccessibleComponent) ac).addFocusListener(l);
    9699                 } else {
    9700                     Component c = getCurrentComponent();
    9701                     if (c != null) {
    9702                         c.addFocusListener(l);
    9703                     }
    9704                 }
    9705             }
    9706
    9707             /**
    9708              * Removes the specified focus listener so it no longer receives focus
    9709              * events from this component.
    9710              *
    9711              * @param l the focus listener
    9712              * @see #addFocusListener
    9713              */
    9714             public void removeFocusListener(FocusListener l) {
    9715                 AccessibleContext ac = getCurrentAccessibleContext();
    9716                 if (ac instanceof AccessibleComponent) {
    9717                     ((AccessibleComponent) ac).removeFocusListener(l);
    9718                 } else {
    9719                     Component c = getCurrentComponent();
    9720                     if (c != null) {
    9721                         c.removeFocusListener(l);
    9722                     }
    9723                 }
    9724             }
    9725
    9726         } // inner class AccessibleJTableHeaderCell
    9727
    9728     }  // inner class AccessibleJTable
    9729
    9730 }  // End of Class JTable
    --- EOF ---