< prev index next >

src/java.desktop/share/classes/javax/swing/JTable.java

Print this page

        

@@ -61,18 +61,18 @@
 import sun.swing.SwingUtilities2.Section;
 import static sun.swing.SwingUtilities2.Section.*;
 import sun.swing.PrintingStatus;
 
 /**
- * The <code>JTable</code> is used to display and edit regular two-dimensional tables
+ * The {@code JTable} is used to display and edit regular two-dimensional tables
  * of cells.
  * See <a href="http://docs.oracle.com/javase/tutorial/uiswing/components/table.html">How to Use Tables</a>
  * in <em>The Java Tutorial</em>
- * for task-oriented documentation and examples of using <code>JTable</code>.
+ * for task-oriented documentation and examples of using {@code JTable}.
  *
  * <p>
- * The <code>JTable</code> has many
+ * The {@code JTable} has many
  * facilities that make it possible to customize its rendering and editing
  * but provides defaults for these features so that simple tables can be
  * set up easily.  For example, to set up a table with 10 rows and 10
  * columns of numbers:
  *

@@ -88,12 +88,12 @@
  * <p>
  * {@code JTable}s are typically placed inside of a {@code JScrollPane}.  By
  * default, a {@code JTable} will adjust its width such that
  * a horizontal scrollbar is unnecessary.  To allow for a horizontal scrollbar,
  * invoke {@link #setAutoResizeMode} with {@code AUTO_RESIZE_OFF}.
- * Note that if you wish to use a <code>JTable</code> in a standalone
- * view (outside of a <code>JScrollPane</code>) and want the header
+ * Note that if you wish to use a {@code JTable} in a standalone
+ * view (outside of a {@code JScrollPane}) and want the header
  * displayed, you can get it using {@link #getTableHeader} and
  * display it separately.
  * <p>
  * To enable sorting and filtering of rows, use a
  * {@code RowSorter}.

@@ -105,92 +105,92 @@
  *       property to {@code true}, so that the {@code JTable}
  *       creates a {@code RowSorter} for
  *       you. For example: {@code setAutoCreateRowSorter(true)}.
  * </ul>
  * <p>
- * When designing applications that use the <code>JTable</code> it is worth paying
+ * When designing applications that use the {@code JTable} it is worth paying
  * close attention to the data structures that will represent the table's data.
- * The <code>DefaultTableModel</code> is a model implementation that
- * uses a <code>Vector</code> of <code>Vector</code>s of <code>Object</code>s to
+ * The {@code DefaultTableModel} is a model implementation that
+ * uses a {@code Vector} of {@code Vector}s of {@code Object}s to
  * store the cell values. As well as copying the data from an
- * application into the <code>DefaultTableModel</code>,
+ * application into the {@code DefaultTableModel},
  * it is also possible to wrap the data in the methods of the
- * <code>TableModel</code> interface so that the data can be passed to the
- * <code>JTable</code> directly, as in the example above. This often results
+ * {@code TableModel} interface so that the data can be passed to the
+ * {@code JTable} directly, as in the example above. This often results
  * in more efficient applications because the model is free to choose the
  * internal representation that best suits the data.
- * A good rule of thumb for deciding whether to use the <code>AbstractTableModel</code>
- * or the <code>DefaultTableModel</code> is to use the <code>AbstractTableModel</code>
- * as the base class for creating subclasses and the <code>DefaultTableModel</code>
+ * A good rule of thumb for deciding whether to use the {@code AbstractTableModel}
+ * or the {@code DefaultTableModel} is to use the {@code AbstractTableModel}
+ * as the base class for creating subclasses and the {@code DefaultTableModel}
  * when subclassing is not required.
  * <p>
  * The "TableExample" directory in the demo area of the source distribution
- * gives a number of complete examples of <code>JTable</code> usage,
- * covering how the <code>JTable</code> can be used to provide an
+ * gives a number of complete examples of {@code JTable} usage,
+ * covering how the {@code JTable} can be used to provide an
  * editable view of data taken from a database and how to modify
  * the columns in the display to use specialized renderers and editors.
  * <p>
- * The <code>JTable</code> uses integers exclusively to refer to both the rows and the columns
- * of the model that it displays. The <code>JTable</code> simply takes a tabular range of cells
- * and uses <code>getValueAt(int, int)</code> to retrieve the
+ * The {@code JTable} uses integers exclusively to refer to both the rows and the columns
+ * of the model that it displays. The {@code JTable} simply takes a tabular range of cells
+ * and uses {@code getValueAt(int, int)} to retrieve the
  * values from the model during painting.  It is important to remember that
- * the column and row indexes returned by various <code>JTable</code> methods
- * are in terms of the <code>JTable</code> (the view) and are not
+ * the column and row indexes returned by various {@code JTable} methods
+ * are in terms of the {@code JTable} (the view) and are not
  * necessarily the same indexes used by the model.
  * <p>
- * By default, columns may be rearranged in the <code>JTable</code> so that the
+ * By default, columns may be rearranged in the {@code JTable} so that the
  * view's columns appear in a different order to the columns in the model.
  * This does not affect the implementation of the model at all: when the
- * columns are reordered, the <code>JTable</code> maintains the new order of the columns
+ * columns are reordered, the {@code JTable} maintains the new order of the columns
  * internally and converts its column indices before querying the model.
  * <p>
- * So, when writing a <code>TableModel</code>, it is not necessary to listen for column
+ * So, when writing a {@code TableModel}, it is not necessary to listen for column
  * reordering events as the model will be queried in its own coordinate
  * system regardless of what is happening in the view.
  * In the examples area there is a demonstration of a sorting algorithm making
  * use of exactly this technique to interpose yet another coordinate system
  * where the order of the rows is changed, rather than the order of the columns.
  * <p>
  * Similarly when using the sorting and filtering functionality
- * provided by <code>RowSorter</code> the underlying
- * <code>TableModel</code> does not need to know how to do sorting,
- * rather <code>RowSorter</code> will handle it.  Coordinate
+ * provided by {@code RowSorter} the underlying
+ * {@code TableModel} does not need to know how to do sorting,
+ * rather {@code RowSorter} will handle it.  Coordinate
  * conversions will be necessary when using the row based methods of
- * <code>JTable</code> with the underlying <code>TableModel</code>.
- * All of <code>JTable</code>s row based methods are in terms of the
- * <code>RowSorter</code>, which is not necessarily the same as that
- * of the underlying <code>TableModel</code>.  For example, the
- * selection is always in terms of <code>JTable</code> so that when
- * using <code>RowSorter</code> you will need to convert using
- * <code>convertRowIndexToView</code> or
- * <code>convertRowIndexToModel</code>.  The following shows how to
- * convert coordinates from <code>JTable</code> to that of the
+ * {@code JTable} with the underlying {@code TableModel}.
+ * All of {@code JTable}s row based methods are in terms of the
+ * {@code RowSorter}, which is not necessarily the same as that
+ * of the underlying {@code TableModel}.  For example, the
+ * selection is always in terms of {@code JTable} so that when
+ * using {@code RowSorter} you will need to convert using
+ * {@code convertRowIndexToView} or
+ * {@code convertRowIndexToModel}.  The following shows how to
+ * convert coordinates from {@code JTable} to that of the
  * underlying model:
  * <pre>
  *   int[] selection = table.getSelectedRows();
  *   for (int i = 0; i &lt; selection.length; i++) {
  *     selection[i] = table.convertRowIndexToModel(selection[i]);
  *   }
  *   // selection is now in terms of the underlying TableModel
  * </pre>
  * <p>
- * By default if sorting is enabled <code>JTable</code> will persist the
+ * By default if sorting is enabled {@code JTable} will persist the
  * selection and variable row heights in terms of the model on
  * sorting.  For example if row 0, in terms of the underlying model,
  * is currently selected, after the sort row 0, in terms of the
  * underlying model will be selected.  Visually the selection may
  * change, but in terms of the underlying model it will remain the
  * same.  The one exception to that is if the model index is no longer
  * visible or was removed.  For example, if row 0 in terms of model
  * was filtered out the selection will be empty after the sort.
  * <p>
- * J2SE 5 adds methods to <code>JTable</code> to provide convenient access to some
+ * J2SE 5 adds methods to {@code JTable} to provide convenient access to some
  * common printing needs. Simple new {@link #print()} methods allow for quick
  * and easy addition of printing support to your application. In addition, a new
  * {@link #getPrintable} method is available for more advanced printing needs.
  * <p>
- * As for all <code>JComponent</code> classes, you can use
+ * As for all {@code JComponent} classes, you can use
  * {@link InputMap} and {@link ActionMap} to associate an
  * {@link Action} object with a {@link KeyStroke} and execute the
  * action under specified conditions.
  * <p>
  * <strong>Warning:</strong> Swing is not thread safe. For more

@@ -202,11 +202,11 @@
  * Serialized objects of this class will not be compatible with
  * future Swing releases. The current serialization support is
  * appropriate for short term storage or RMI between applications running
  * the same version of Swing.  As of 1.4, support for long term storage
  * of all JavaBeans&trade;
- * has been added to the <code>java.beans</code> package.
+ * has been added to the {@code java.beans} package.
  * Please see {@link java.beans.XMLEncoder}.
  *
  *
  * @beaninfo
  *   attribute: isContainer false

@@ -252,11 +252,11 @@
     /** During all resize operations, proportionately resize all columns. */
     public static final int     AUTO_RESIZE_ALL_COLUMNS = 4;
 
 
     /**
-     * Printing modes, used in printing <code>JTable</code>s.
+     * Printing modes, used in printing {@code JTable}s.
      *
      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
      *             boolean, PrintRequestAttributeSet, boolean)
      * @see #getPrintable
      * @since 1.5

@@ -280,20 +280,20 @@
 
 //
 // Instance Variables
 //
 
-    /** The <code>TableModel</code> of the table. */
+    /** The {@code TableModel} of the table. */
     protected TableModel        dataModel;
 
-    /** The <code>TableColumnModel</code> of the table. */
+    /** The {@code TableColumnModel} of the table. */
     protected TableColumnModel  columnModel;
 
-    /** The <code>ListSelectionModel</code> of the table, used to keep track of row selections. */
+    /** The {@code ListSelectionModel} of the table, used to keep track of row selections. */
     protected ListSelectionModel selectionModel;
 
-    /** The <code>TableHeader</code> working with the table. */
+    /** The {@code TableHeader} working with the table. */
     protected JTableHeader      tableHeader;
 
     /** The height in pixels of each row in the table. */
     protected int               rowHeight;
 

@@ -301,50 +301,50 @@
     protected int               rowMargin;
 
     /** The color of the grid. */
     protected Color             gridColor;
 
-    /** The table draws horizontal lines between cells if <code>showHorizontalLines</code> is true. */
+    /** The table draws horizontal lines between cells if {@code showHorizontalLines} is true. */
     protected boolean           showHorizontalLines;
 
-    /** The table draws vertical lines between cells if <code>showVerticalLines</code> is true. */
+    /** The table draws vertical lines between cells if {@code showVerticalLines} is true. */
     protected boolean           showVerticalLines;
 
     /**
      *  Determines if the table automatically resizes the
      *  width of the table's columns to take up the entire width of the
      *  table, and how it does the resizing.
      */
     protected int               autoResizeMode;
 
     /**
-     *  The table will query the <code>TableModel</code> to build the default
+     *  The table will query the {@code TableModel} to build the default
      *  set of columns if this is true.
      */
     protected boolean           autoCreateColumnsFromModel;
 
-    /** Used by the <code>Scrollable</code> interface to determine the initial visible area. */
+    /** Used by the {@code Scrollable} interface to determine the initial visible area. */
     protected Dimension         preferredViewportSize;
 
     /** True if row selection is allowed in this table. */
     protected boolean           rowSelectionAllowed;
 
     /**
      * Obsolete as of Java 2 platform v1.3.  Please use the
-     * <code>rowSelectionAllowed</code> property and the
-     * <code>columnSelectionAllowed</code> property of the
-     * <code>columnModel</code> instead. Or use the
-     * method <code>getCellSelectionEnabled</code>.
+     * {@code rowSelectionAllowed} property and the
+     * {@code columnSelectionAllowed} property of the
+     * {@code columnModel} instead. Or use the
+     * method {@code getCellSelectionEnabled}.
      */
     /*
      * If true, both a row selection and a column selection
      * can be non-empty at the same time, the selected cells are the
      * the cells whose row and column are both selected.
      */
     protected boolean           cellSelectionEnabled;
 
-    /** If editing, the <code>Component</code> that is handling the editing. */
+    /** If editing, the {@code Component} that is handling the editing. */
     protected transient Component       editorComp;
 
     /**
      * The active cell editor object, that overwrites the screen real estate
      * occupied by the current cell and allows the user to change its contents.

@@ -358,21 +358,21 @@
     /** Identifies the row of the cell being edited. */
     protected transient int             editingRow;
 
    /**
      * A table of objects that display the contents of a cell,
-     * indexed by class as declared in <code>getColumnClass</code>
-     * in the <code>TableModel</code> interface.
+     * indexed by class as declared in {@code getColumnClass}
+     * in the {@code TableModel} interface.
      */
     protected transient Hashtable<Object, Object> defaultRenderersByColumnClass;
     // Logicaly, the above is a Hashtable<Class<?>, TableCellRenderer>.
     // It is declared otherwise to accomodate using UIDefaults.
 
     /**
      * A table of objects that display and edit the contents of a cell,
-     * indexed by class as declared in <code>getColumnClass</code>
-     * in the <code>TableModel</code> interface.
+     * indexed by class as declared in {@code getColumnClass}
+     * in the {@code TableModel} interface.
      */
     protected transient Hashtable<Object, Object> defaultEditorsByColumnClass;
     // Logicaly, the above is a Hashtable<Class<?>, TableCellEditor>.
     // It is declared otherwise to accomodate using UIDefaults.
 

@@ -455,12 +455,12 @@
      * The drop location.
      */
     private transient DropLocation dropLocation;
 
     /**
-     * A subclass of <code>TransferHandler.DropLocation</code> representing
-     * a drop location for a <code>JTable</code>.
+     * A subclass of {@code TransferHandler.DropLocation} representing
+     * a drop location for a {@code JTable}.
      *
      * @see #getDropLocation
      * @since 1.6
      */
     public static final class DropLocation extends TransferHandler.DropLocation {

@@ -480,17 +480,17 @@
         }
 
         /**
          * Returns the row index where a dropped item should be placed in the
          * table. Interpretation of the value depends on the return of
-         * <code>isInsertRow()</code>. If that method returns
-         * <code>true</code> this value indicates the index where a new
+         * {@code isInsertRow()}. If that method returns
+         * {@code true} this value indicates the index where a new
          * row should be inserted. Otherwise, it represents the value
          * of an existing row on which the data was dropped. This index is
          * in terms of the view.
          * <p>
-         * <code>-1</code> indicates that the drop occurred over empty space,
+         * {@code -1} indicates that the drop occurred over empty space,
          * and no row could be calculated.
          *
          * @return the drop row
          */
         public int getRow() {

@@ -498,17 +498,17 @@
         }
 
         /**
          * Returns the column index where a dropped item should be placed in the
          * table. Interpretation of the value depends on the return of
-         * <code>isInsertColumn()</code>. If that method returns
-         * <code>true</code> this value indicates the index where a new
+         * {@code isInsertColumn()}. If that method returns
+         * {@code true} this value indicates the index where a new
          * column should be inserted. Otherwise, it represents the value
          * of an existing column on which the data was dropped. This index is
          * in terms of the view.
          * <p>
-         * <code>-1</code> indicates that the drop occurred over empty space,
+         * {@code -1} indicates that the drop occurred over empty space,
          * and no column could be calculated.
          *
          * @return the drop row
          */
         public int getColumn() {

@@ -556,11 +556,11 @@
 //
 // Constructors
 //
 
     /**
-     * Constructs a default <code>JTable</code> that is initialized with a default
+     * Constructs a default {@code JTable} that is initialized with a default
      * data model, a default column model, and a default selection
      * model.
      *
      * @see #createDefaultDataModel
      * @see #createDefaultColumnModel

@@ -569,12 +569,12 @@
     public JTable() {
         this(null, null, null);
     }
 
     /**
-     * Constructs a <code>JTable</code> that is initialized with
-     * <code>dm</code> as the data model, a default column model,
+     * Constructs a {@code JTable} that is initialized with
+     * {@code dm} as the data model, a default column model,
      * and a default selection model.
      *
      * @param dm        the data model for the table
      * @see #createDefaultColumnModel
      * @see #createDefaultSelectionModel

@@ -582,12 +582,12 @@
     public JTable(TableModel dm) {
         this(dm, null, null);
     }
 
     /**
-     * Constructs a <code>JTable</code> that is initialized with
-     * <code>dm</code> as the data model, <code>cm</code>
+     * Constructs a {@code JTable} that is initialized with
+     * {@code dm} as the data model, {@code cm}
      * as the column model, and a default selection model.
      *
      * @param dm        the data model for the table
      * @param cm        the column model for the table
      * @see #createDefaultSelectionModel

@@ -595,19 +595,19 @@
     public JTable(TableModel dm, TableColumnModel cm) {
         this(dm, cm, null);
     }
 
     /**
-     * Constructs a <code>JTable</code> that is initialized with
-     * <code>dm</code> as the data model, <code>cm</code> as the
-     * column model, and <code>sm</code> as the selection model.
-     * If any of the parameters are <code>null</code> this method
+     * Constructs a {@code JTable} that is initialized with
+     * {@code dm} as the data model, {@code cm} as the
+     * column model, and {@code sm} as the selection model.
+     * If any of the parameters are {@code null} this method
      * will initialize the table with the corresponding default model.
-     * The <code>autoCreateColumnsFromModel</code> flag is set to false
-     * if <code>cm</code> is non-null, otherwise it is set to true
+     * The {@code autoCreateColumnsFromModel} flag is set to false
+     * if {@code cm} is non-null, otherwise it is set to true
      * and the column model is populated with suitable
-     * <code>TableColumns</code> for the columns in <code>dm</code>.
+     * {@code TableColumns} for the columns in {@code dm}.
      *
      * @param dm        the data model for the table
      * @param cm        the column model for the table
      * @param sm        the row selection model for the table
      * @see #createDefaultDataModel

@@ -644,13 +644,13 @@
         initializeLocalVars();
         updateUI();
     }
 
     /**
-     * Constructs a <code>JTable</code> with <code>numRows</code>
-     * and <code>numColumns</code> of empty cells using
-     * <code>DefaultTableModel</code>.  The columns will have
+     * Constructs a {@code JTable} with {@code numRows}
+     * and {@code numColumns} of empty cells using
+     * {@code DefaultTableModel}.  The columns will have
      * names of the form "A", "B", "C", etc.
      *
      * @param numRows           the number of rows the table holds
      * @param numColumns        the number of columns the table holds
      * @see javax.swing.table.DefaultTableModel

@@ -658,14 +658,14 @@
     public JTable(int numRows, int numColumns) {
         this(new DefaultTableModel(numRows, numColumns));
     }
 
     /**
-     * Constructs a <code>JTable</code> to display the values in the
-     * <code>Vector</code> of <code>Vectors</code>, <code>rowData</code>,
-     * with column names, <code>columnNames</code>.  The
-     * <code>Vectors</code> contained in <code>rowData</code>
+     * Constructs a {@code JTable} to display the values in the
+     * {@code Vector} of {@code Vectors}, {@code rowData},
+     * with column names, {@code columnNames}.  The
+     * {@code Vectors} contained in {@code rowData}
      * should contain the values for that row. In other words,
      * the value of the cell at row 1, column 5 can be obtained
      * with the following code:
      *
      * <pre>((Vector)rowData.elementAt(1)).elementAt(5);</pre>

@@ -677,18 +677,18 @@
     public JTable(Vector<? extends Vector> rowData, Vector<?> columnNames) {
         this(new DefaultTableModel(rowData, columnNames));
     }
 
     /**
-     * Constructs a <code>JTable</code> to display the values in the two dimensional array,
-     * <code>rowData</code>, with column names, <code>columnNames</code>.
-     * <code>rowData</code> is an array of rows, so the value of the cell at row 1,
+     * Constructs a {@code JTable} to display the values in the two dimensional array,
+     * {@code rowData}, with column names, {@code columnNames}.
+     * {@code rowData} is an array of rows, so the value of the cell at row 1,
      * column 5 can be obtained with the following code:
      *
      * <pre> rowData[1][5]; </pre>
      * <p>
-     * All rows must be of the same length as <code>columnNames</code>.
+     * All rows must be of the same length as {@code columnNames}.
      *
      * @param rowData           the data for the new table
      * @param columnNames       names of each column
      */
     public JTable(final Object[][] rowData, final Object[] columnNames) {

@@ -704,27 +704,27 @@
             }
         });
     }
 
     /**
-     * Calls the <code>configureEnclosingScrollPane</code> method.
+     * Calls the {@code configureEnclosingScrollPane} method.
      *
      * @see #configureEnclosingScrollPane
      */
     public void addNotify() {
         super.addNotify();
         configureEnclosingScrollPane();
     }
 
     /**
-     * If this <code>JTable</code> is the <code>viewportView</code> of an enclosing <code>JScrollPane</code>
-     * (the usual situation), configure this <code>ScrollPane</code> by, amongst other things,
-     * installing the table's <code>tableHeader</code> as the <code>columnHeaderView</code> of the scroll pane.
-     * When a <code>JTable</code> is added to a <code>JScrollPane</code> in the usual way,
-     * using <code>new JScrollPane(myTable)</code>, <code>addNotify</code> is
-     * called in the <code>JTable</code> (when the table is added to the viewport).
-     * <code>JTable</code>'s <code>addNotify</code> method in turn calls this method,
+     * If this {@code JTable} is the {@code viewportView} of an enclosing {@code JScrollPane}
+     * (the usual situation), configure this {@code ScrollPane} by, amongst other things,
+     * installing the table's {@code tableHeader} as the {@code columnHeaderView} of the scroll pane.
+     * When a {@code JTable} is added to a {@code JScrollPane} in the usual way,
+     * using {@code new JScrollPane(myTable)}, {@code addNotify} is
+     * called in the {@code JTable} (when the table is added to the viewport).
+     * {@code JTable}'s {@code addNotify} method in turn calls this method,
      * which is protected so that this default installation procedure can
      * be overridden by a subclass.
      *
      * @see #addNotify
      */

@@ -803,11 +803,11 @@
             }
         }
     }
 
     /**
-     * Calls the <code>unconfigureEnclosingScrollPane</code> method.
+     * Calls the {@code unconfigureEnclosingScrollPane} method.
      *
      * @see #unconfigureEnclosingScrollPane
      */
     public void removeNotify() {
         KeyboardFocusManager.getCurrentKeyboardFocusManager().

@@ -816,14 +816,14 @@
         unconfigureEnclosingScrollPane();
         super.removeNotify();
     }
 
     /**
-     * Reverses the effect of <code>configureEnclosingScrollPane</code>
-     * by replacing the <code>columnHeaderView</code> of the enclosing
-     * scroll pane with <code>null</code>. <code>JTable</code>'s
-     * <code>removeNotify</code> method calls
+     * Reverses the effect of {@code configureEnclosingScrollPane}
+     * by replacing the {@code columnHeaderView} of the enclosing
+     * scroll pane with {@code null}. {@code JTable}'s
+     * {@code removeNotify} method calls
      * this method, which is protected so that this default uninstallation
      * procedure can be overridden by a subclass.
      *
      * @see #removeNotify
      * @see #configureEnclosingScrollPane

@@ -870,16 +870,16 @@
 //
 // Static Methods
 //
 
     /**
-     * Equivalent to <code>new JScrollPane(aTable)</code>.
+     * Equivalent to {@code new JScrollPane(aTable)}.
      *
      * @param aTable a {@code JTable} to be used for the scroll pane
      * @return a {@code JScrollPane} created using {@code aTable}
      * @deprecated As of Swing version 1.0.2,
-     * replaced by <code>new JScrollPane(aTable)</code>.
+     * replaced by {@code new JScrollPane(aTable)}.
      */
     @Deprecated
     public static JScrollPane createScrollPaneForTable(JTable aTable) {
         return new JScrollPane(aTable);
     }

@@ -887,12 +887,12 @@
 //
 // Table Attributes
 //
 
     /**
-     * Sets the <code>tableHeader</code> working with this <code>JTable</code> to <code>newHeader</code>.
-     * It is legal to have a <code>null</code> <code>tableHeader</code>.
+     * Sets the {@code tableHeader} working with this {@code JTable} to {@code newHeader}.
+     * It is legal to have a {@code null tableHeader}.
      *
      * @param   tableHeader                       new tableHeader
      * @see     #getTableHeader
      * @beaninfo
      *  bound: true

@@ -912,27 +912,27 @@
             firePropertyChange("tableHeader", old, tableHeader);
         }
     }
 
     /**
-     * Returns the <code>tableHeader</code> used by this <code>JTable</code>.
+     * Returns the {@code tableHeader} used by this {@code JTable}.
      *
-     * @return  the <code>tableHeader</code> used by this table
+     * @return  the {@code tableHeader} used by this table
      * @see     #setTableHeader
      */
     public JTableHeader getTableHeader() {
         return tableHeader;
     }
 
     /**
-     * Sets the height, in pixels, of all cells to <code>rowHeight</code>,
+     * Sets the height, in pixels, of all cells to {@code rowHeight},
      * revalidates, and repaints.
      * The height of the cells will be equal to the row height minus
      * the row margin.
      *
      * @param   rowHeight                       new row height
-     * @exception IllegalArgumentException      if <code>rowHeight</code> is
+     * @exception IllegalArgumentException      if {@code rowHeight} is
      *                                          less than 1
      * @see     #getRowHeight
      * @beaninfo
      *  bound: true
      *  description: The height of the specified row.

@@ -968,22 +968,22 @@
         }
         return rowModel;
     }
 
     /**
-     * Sets the height for <code>row</code> to <code>rowHeight</code>,
+     * Sets the height for {@code row} to {@code rowHeight},
      * revalidates, and repaints. The height of the cells in this row
      * will be equal to the row height minus the row margin.
      *
      * @param   row                             the row whose height is being
                                                 changed
      * @param   rowHeight                       new row height, in pixels
-     * @exception IllegalArgumentException      if <code>rowHeight</code> is
+     * @exception IllegalArgumentException      if {@code rowHeight} is
      *                                          less than 1
      * @beaninfo
      *  bound: true
-     *  description: The height in pixels of the cells in <code>row</code>
+     *  description: The height in pixels of the cells in {@code row}
      * @since 1.3
      */
     public void setRowHeight(int row, int rowHeight) {
         if (rowHeight <= 0) {
             throw new IllegalArgumentException("New row height less than 1");

@@ -994,11 +994,11 @@
         }
         resizeAndRepaint();
     }
 
     /**
-     * Returns the height, in pixels, of the cells in <code>row</code>.
+     * Returns the height, in pixels, of the cells in {@code row}.
      * @param   row              the row whose height is to be returned
      * @return the height, in pixels, of the cells in the row
      * @since 1.3
      */
     public int getRowHeight(int row) {

@@ -1021,25 +1021,25 @@
         firePropertyChange("rowMargin", old, rowMargin);
     }
 
     /**
      * Gets the amount of empty space, in pixels, between cells. Equivalent to:
-     * <code>getIntercellSpacing().height</code>.
+     * {@code getIntercellSpacing().height}.
      * @return the number of pixels between cells in a row
      *
      * @see     #setRowMargin
      */
     public int getRowMargin() {
         return rowMargin;
     }
 
     /**
-     * Sets the <code>rowMargin</code> and the <code>columnMargin</code> --
+     * Sets the {@code rowMargin} and the {@code columnMargin} --
      * the height and width of the space between cells -- to
-     * <code>intercellSpacing</code>.
+     * {@code intercellSpacing}.
      *
-     * @param   intercellSpacing        a <code>Dimension</code>
+     * @param   intercellSpacing        a {@code Dimension}
      *                                  specifying the new width
      *                                  and height between cells
      * @see     #getIntercellSpacing
      * @beaninfo
      *  description: The spacing between the cells,

@@ -1063,15 +1063,15 @@
     public Dimension getIntercellSpacing() {
         return new Dimension(getColumnModel().getColumnMargin(), rowMargin);
     }
 
     /**
-     * Sets the color used to draw grid lines to <code>gridColor</code> and redisplays.
+     * Sets the color used to draw grid lines to {@code gridColor} and redisplays.
      * The default color is look and feel dependent.
      *
      * @param   gridColor                       the new color of the grid lines
-     * @exception IllegalArgumentException      if <code>gridColor</code> is <code>null</code>
+     * @exception IllegalArgumentException      if {@code gridColor} is {@code null}
      * @see     #getGridColor
      * @beaninfo
      *  bound: true
      *  description: The grid color.
      */

@@ -1097,13 +1097,13 @@
         return gridColor;
     }
 
     /**
      *  Sets whether the table draws grid lines around cells.
-     *  If <code>showGrid</code> is true it does; if it is false it doesn't.
-     *  There is no <code>getShowGrid</code> method as this state is held
-     *  in two variables -- <code>showHorizontalLines</code> and <code>showVerticalLines</code> --
+     *  If {@code showGrid} is true it does; if it is false it doesn't.
+     *  There is no {@code getShowGrid} method as this state is held
+     *  in two variables -- {@code showHorizontalLines} and {@code showVerticalLines} --
      *  each of which can be queried independently.
      *
      * @param   showGrid                 true if table view should draw grid lines
      *
      * @see     #setShowVerticalLines

@@ -1119,11 +1119,11 @@
         repaint();
     }
 
     /**
      *  Sets whether the table draws horizontal lines between cells.
-     *  If <code>showHorizontalLines</code> is true it does; if it is false it doesn't.
+     *  If {@code showHorizontalLines} is true it does; if it is false it doesn't.
      *
      * @param   showHorizontalLines      true if table view should draw horizontal lines
      * @see     #getShowHorizontalLines
      * @see     #setShowGrid
      * @see     #setShowVerticalLines

@@ -1140,11 +1140,11 @@
         repaint();
     }
 
     /**
      *  Sets whether the table draws vertical lines between cells.
-     *  If <code>showVerticalLines</code> is true it does; if it is false it doesn't.
+     *  If {@code showVerticalLines} is true it does; if it is false it doesn't.
      *
      * @param   showVerticalLines              true if table view should draw vertical lines
      * @see     #getShowVerticalLines
      * @see     #setShowGrid
      * @see     #setShowHorizontalLines

@@ -1239,15 +1239,15 @@
     public int getAutoResizeMode() {
         return autoResizeMode;
     }
 
     /**
-     * Sets this table's <code>autoCreateColumnsFromModel</code> flag.
-     * This method calls <code>createDefaultColumnsFromModel</code> if
-     * <code>autoCreateColumnsFromModel</code> changes from false to true.
+     * Sets this table's {@code autoCreateColumnsFromModel} flag.
+     * This method calls {@code createDefaultColumnsFromModel} if
+     * {@code autoCreateColumnsFromModel} changes from false to true.
      *
-     * @param   autoCreateColumnsFromModel   true if <code>JTable</code> should automatically create columns
+     * @param   autoCreateColumnsFromModel   true if {@code JTable} should automatically create columns
      * @see     #getAutoCreateColumnsFromModel
      * @see     #createDefaultColumnsFromModel
      * @beaninfo
      *  bound: true
      *  description: Automatically populates the columnModel when a new TableModel is submitted.

@@ -1263,13 +1263,13 @@
         }
     }
 
     /**
      * Determines whether the table will create default columns from the model.
-     * If true, <code>setModel</code> will clear any existing columns and
+     * If true, {@code setModel} will clear any existing columns and
      * create new columns from the new model.  Also, if the event in
-     * the <code>tableChanged</code> notification specifies that the
+     * the {@code tableChanged} notification specifies that the
      * entire table changed, then the columns will be rebuilt.
      * The default is true.
      *
      * @return  the autoCreateColumnsFromModel of the table
      * @see     #setAutoCreateColumnsFromModel

@@ -1279,12 +1279,12 @@
         return autoCreateColumnsFromModel;
     }
 
     /**
      * Creates default columns for the table from
-     * the data model using the <code>getColumnCount</code> method
-     * defined in the <code>TableModel</code> interface.
+     * the data model using the {@code getColumnCount} method
+     * defined in the {@code TableModel} interface.
      * <p>
      * Clears any existing columns before creating the
      * new columns based on information from the model.
      *
      * @see     #getAutoCreateColumnsFromModel

@@ -1306,11 +1306,11 @@
         }
     }
 
     /**
      * Sets a default cell renderer to be used if no renderer has been set in
-     * a <code>TableColumn</code>. If renderer is <code>null</code>,
+     * a {@code TableColumn}. If renderer is {@code null},
      * removes the default renderer for this column class.
      *
      * @param  columnClass     set the default cell renderer for this columnClass
      * @param  renderer        default cell renderer to be used for this
      *                         columnClass

@@ -1326,15 +1326,15 @@
         }
     }
 
     /**
      * Returns the cell renderer to be used when no renderer has been set in
-     * a <code>TableColumn</code>. During the rendering of cells the renderer is fetched from
-     * a <code>Hashtable</code> of entries according to the class of the cells in the column. If
-     * there is no entry for this <code>columnClass</code> the method returns
-     * the entry for the most specific superclass. The <code>JTable</code> installs entries
-     * for <code>Object</code>, <code>Number</code>, and <code>Boolean</code>, all of which can be modified
+     * a {@code TableColumn}. During the rendering of cells the renderer is fetched from
+     * a {@code Hashtable} of entries according to the class of the cells in the column. If
+     * there is no entry for this {@code columnClass} the method returns
+     * the entry for the most specific superclass. The {@code JTable} installs entries
+     * for {@code Object}, {@code Number}, and {@code Boolean}, all of which can be modified
      * or replaced.
      *
      * @param   columnClass   return the default cell renderer
      *                        for this columnClass
      * @return  the renderer for this columnClass

@@ -1360,15 +1360,15 @@
         }
     }
 
     /**
      * Sets a default cell editor to be used if no editor has been set in
-     * a <code>TableColumn</code>. If no editing is required in a table, or a
-     * particular column in a table, uses the <code>isCellEditable</code>
-     * method in the <code>TableModel</code> interface to ensure that this
-     * <code>JTable</code> will not start an editor in these columns.
-     * If editor is <code>null</code>, removes the default editor for this
+     * a {@code TableColumn}. If no editing is required in a table, or a
+     * particular column in a table, uses the {@code isCellEditable}
+     * method in the {@code TableModel} interface to ensure that this
+     * {@code JTable} will not start an editor in these columns.
+     * If editor is {@code null}, removes the default editor for this
      * column class.
      *
      * @param  columnClass  set the default cell editor for this columnClass
      * @param  editor   default cell editor to be used for this columnClass
      * @see     TableModel#isCellEditable

@@ -1384,15 +1384,15 @@
         }
     }
 
     /**
      * Returns the editor to be used when no editor has been set in
-     * a <code>TableColumn</code>. During the editing of cells the editor is fetched from
-     * a <code>Hashtable</code> of entries according to the class of the cells in the column. If
-     * there is no entry for this <code>columnClass</code> the method returns
-     * the entry for the most specific superclass. The <code>JTable</code> installs entries
-     * for <code>Object</code>, <code>Number</code>, and <code>Boolean</code>, all of which can be modified
+     * a {@code TableColumn}. During the editing of cells the editor is fetched from
+     * a {@code Hashtable} of entries according to the class of the cells in the column. If
+     * there is no entry for this {@code columnClass} the method returns
+     * the entry for the most specific superclass. The {@code JTable} installs entries
+     * for {@code Object}, {@code Number}, and {@code Boolean}, all of which can be modified
      * or replaced.
      *
      * @param   columnClass  return the default cell editor for this columnClass
      * @return the default cell editor to be used for this columnClass
      * @see     #setDefaultEditor

@@ -1432,13 +1432,13 @@
      * begin a drag and drop operation by calling {@code exportAsDrag} on the
      * table's {@code TransferHandler}.
      *
      * @param b whether or not to enable automatic drag handling
      * @exception HeadlessException if
-     *            <code>b</code> is <code>true</code> and
-     *            <code>GraphicsEnvironment.isHeadless()</code>
-     *            returns <code>true</code>
+     *            {@code b} is {@code true} and
+     *            {@code GraphicsEnvironment.isHeadless()}
+     *            returns {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      * @see #getDragEnabled
      * @see #setTransferHandler
      * @see TransferHandler
      * @since 1.4

@@ -1469,34 +1469,34 @@
         return dragEnabled;
     }
 
     /**
      * Sets the drop mode for this component. For backward compatibility,
-     * the default for this property is <code>DropMode.USE_SELECTION</code>.
+     * the default for this property is {@code DropMode.USE_SELECTION}.
      * Usage of one of the other modes is recommended, however, for an
-     * improved user experience. <code>DropMode.ON</code>, for instance,
+     * improved user experience. {@code DropMode.ON}, for instance,
      * offers similar behavior of showing items as selected, but does so without
      * affecting the actual selection in the table.
      * <p>
-     * <code>JTable</code> supports the following drop modes:
+     * {@code JTable} supports the following drop modes:
      * <ul>
-     *    <li><code>DropMode.USE_SELECTION</code></li>
-     *    <li><code>DropMode.ON</code></li>
-     *    <li><code>DropMode.INSERT</code></li>
-     *    <li><code>DropMode.INSERT_ROWS</code></li>
-     *    <li><code>DropMode.INSERT_COLS</code></li>
-     *    <li><code>DropMode.ON_OR_INSERT</code></li>
-     *    <li><code>DropMode.ON_OR_INSERT_ROWS</code></li>
-     *    <li><code>DropMode.ON_OR_INSERT_COLS</code></li>
+     *    <li>{@code DropMode.USE_SELECTION}</li>
+     *    <li>{@code DropMode.ON}</li>
+     *    <li>{@code DropMode.INSERT}</li>
+     *    <li>{@code DropMode.INSERT_ROWS}</li>
+     *    <li>{@code DropMode.INSERT_COLS}</li>
+     *    <li>{@code DropMode.ON_OR_INSERT}</li>
+     *    <li>{@code DropMode.ON_OR_INSERT_ROWS}</li>
+     *    <li>{@code DropMode.ON_OR_INSERT_COLS}</li>
      * </ul>
      * <p>
      * The drop mode is only meaningful if this component has a
-     * <code>TransferHandler</code> that accepts drops.
+     * {@code TransferHandler} that accepts drops.
      *
      * @param dropMode the drop mode to use
      * @throws IllegalArgumentException if the drop mode is unsupported
-     *         or <code>null</code>
+     *         or {@code null}
      * @see #getDropMode
      * @see #getDropLocation
      * @see #setTransferHandler
      * @see TransferHandler
      * @since 1.6

@@ -1537,11 +1537,11 @@
     /**
      * Calculates a drop location in this component, representing where a
      * drop at the given point should insert data.
      *
      * @param p the point to calculate a drop location for
-     * @return the drop location, or <code>null</code>
+     * @return the drop location, or {@code null}
      */
     DropLocation dropLocationForPoint(Point p) {
         DropLocation location = null;
 
         int row = rowAtPoint(p);

@@ -1733,24 +1733,24 @@
      * a drop index). It can return a state object to the caller encapsulating
      * any saved selection state. On a second call, let's say the drop location
      * is being changed to something else. The component doesn't need to
      * restore anything yet, so it simply passes back the same state object
      * to have the DnD system continue storing it. Finally, let's say this
-     * method is messaged with <code>null</code>. This means DnD
+     * method is messaged with {@code null}. This means DnD
      * is finished with this component for now, meaning it should restore
      * state. At this point, it can use the state parameter to restore
-     * said state, and of course return <code>null</code> since there's
+     * said state, and of course return {@code null} since there's
      * no longer anything to store.
      *
      * @param location the drop location (as calculated by
-     *        <code>dropLocationForPoint</code>) or <code>null</code>
+     *        {@code dropLocationForPoint}) or {@code null}
      *        if there's no longer a valid drop location
      * @param state the state object saved earlier for this component,
-     *        or <code>null</code>
+     *        or {@code null}
      * @param forDrop whether or not the method is being called because an
      *        actual drop occurred
-     * @return any saved state for this component, or <code>null</code> if none
+     * @return any saved state for this component, or {@code null} if none
      */
     Object setDropLocation(TransferHandler.DropLocation location,
                            Object state,
                            boolean forDrop) {
 

@@ -1821,11 +1821,11 @@
      * as the drop location during a DnD operation over the component,
      * or {@code null} if no location is to currently be shown.
      * <p>
      * This method is not meant for querying the drop location
      * from a {@code TransferHandler}, as the drop location is only
-     * set after the {@code TransferHandler}'s <code>canImport</code>
+     * set after the {@code TransferHandler}'s {@code canImport}
      * has returned and has allowed for the location to be shown.
      * <p>
      * When this property changes, a property change event with
      * name "dropLocation" is fired by the component.
      *

@@ -1911,24 +1911,24 @@
     public boolean getUpdateSelectionOnSort() {
         return updateSelectionOnSort;
     }
 
     /**
-     * Sets the <code>RowSorter</code>.  <code>RowSorter</code> is used
-     * to provide sorting and filtering to a <code>JTable</code>.
+     * Sets the {@code RowSorter}.  {@code RowSorter} is used
+     * to provide sorting and filtering to a {@code JTable}.
      * <p>
      * This method clears the selection and resets any variable row heights.
      * <p>
-     * This method fires a <code>PropertyChangeEvent</code> when appropriate,
-     * with the property name <code>"rowSorter"</code>.  For
+     * This method fires a {@code PropertyChangeEvent} when appropriate,
+     * with the property name {@code "rowSorter"}.  For
      * backward-compatibility, this method fires an additional event with the
-     * property name <code>"sorter"</code>.
+     * property name {@code "sorter"}.
      * <p>
-     * If the underlying model of the <code>RowSorter</code> differs from
-     * that of this <code>JTable</code> undefined behavior will result.
+     * If the underlying model of the {@code RowSorter} differs from
+     * that of this {@code JTable} undefined behavior will result.
      *
-     * @param sorter the <code>RowSorter</code>; <code>null</code> turns
+     * @param sorter the {@code RowSorter}; {@code null} turns
      *        sorting off
      * @see javax.swing.table.TableRowSorter
      * @beaninfo
      *        bound: true
      *  description: The table's RowSorter

@@ -1967,23 +1967,23 @@
     /**
      * Sets the table's selection mode to allow only single selections, a single
      * contiguous interval, or multiple intervals.
      * <P>
      * <b>Note:</b>
-     * <code>JTable</code> provides all the methods for handling
+     * {@code JTable} provides all the methods for handling
      * column and row selection.  When setting states,
-     * such as <code>setSelectionMode</code>, it not only
+     * such as {@code setSelectionMode}, it not only
      * updates the mode for the row selection model but also sets similar
-     * values in the selection model of the <code>columnModel</code>.
+     * values in the selection model of the {@code columnModel}.
      * If you want to have the row and column selection models operating
      * in different modes, set them both directly.
      * <p>
-     * Both the row and column selection models for <code>JTable</code>
-     * default to using a <code>DefaultListSelectionModel</code>
-     * so that <code>JTable</code> works the same way as the
-     * <code>JList</code>. See the <code>setSelectionMode</code> method
-     * in <code>JList</code> for details about the modes.
+     * Both the row and column selection models for {@code JTable}
+     * default to using a {@code DefaultListSelectionModel}
+     * so that {@code JTable} works the same way as the
+     * {@code JList}. See the {@code setSelectionMode} method
+     * in {@code JList} for details about the modes.
      *
      * @param selectionMode the mode used by the row and column selection models
      * @see JList#setSelectionMode
      * @beaninfo
      * description: The selection mode used by the row and column selection models.

@@ -2057,15 +2057,15 @@
 
     /**
      * Sets whether this table allows both a column selection and a
      * row selection to exist simultaneously. When set,
      * the table treats the intersection of the row and column selection
-     * models as the selected cells. Override <code>isCellSelected</code> to
+     * models as the selected cells. Override {@code isCellSelected} to
      * change this default behavior. This method is equivalent to setting
-     * both the <code>rowSelectionAllowed</code> property and
-     * <code>columnSelectionAllowed</code> property of the
-     * <code>columnModel</code> to the supplied value.
+     * both the {@code rowSelectionAllowed} property and
+     * {@code columnSelectionAllowed} property of the
+     * {@code columnModel} to the supplied value.
      *
      * @param  cellSelectionEnabled     true if simultaneous row and column
      *                                  selection is allowed
      * @see #getCellSelectionEnabled
      * @see #isCellSelected

@@ -2083,12 +2083,12 @@
         firePropertyChange("cellSelectionEnabled", old, cellSelectionEnabled);
     }
 
     /**
      * Returns true if both row and column selection models are enabled.
-     * Equivalent to <code>getRowSelectionAllowed() &amp;&amp;
-     * getColumnSelectionAllowed()</code>.
+     * Equivalent to
+     * {@code getRowSelectionAllowed() && getColumnSelectionAllowed()}.
      *
      * @return true if both row and column selection models are enabled
      *
      * @see #setCellSelectionEnabled
      */

@@ -2176,83 +2176,83 @@
         }
         return col;
     }
 
     /**
-     * Selects the rows from <code>index0</code> to <code>index1</code>,
+     * Selects the rows from {@code index0} to {@code index1},
      * inclusive.
      *
-     * @exception IllegalArgumentException      if <code>index0</code> or
-     *                                          <code>index1</code> lie outside
-     *                                          [0, <code>getRowCount()</code>-1]
+     * @exception IllegalArgumentException      if {@code index0} or
+     *                                          {@code index1} lie outside
+     *                                          [0, {@code getRowCount()}-1]
      * @param   index0 one end of the interval
      * @param   index1 the other end of the interval
      */
     public void setRowSelectionInterval(int index0, int index1) {
         selectionModel.setSelectionInterval(boundRow(index0), boundRow(index1));
     }
 
     /**
-     * Selects the columns from <code>index0</code> to <code>index1</code>,
+     * Selects the columns from {@code index0} to {@code index1},
      * inclusive.
      *
-     * @exception IllegalArgumentException      if <code>index0</code> or
-     *                                          <code>index1</code> lie outside
-     *                                          [0, <code>getColumnCount()</code>-1]
+     * @exception IllegalArgumentException      if {@code index0} or
+     *                                          {@code index1} lie outside
+     *                                          [0, {@code getColumnCount()}-1]
      * @param   index0 one end of the interval
      * @param   index1 the other end of the interval
      */
     public void setColumnSelectionInterval(int index0, int index1) {
         columnModel.getSelectionModel().setSelectionInterval(boundColumn(index0), boundColumn(index1));
     }
 
     /**
-     * Adds the rows from <code>index0</code> to <code>index1</code>, inclusive, to
+     * Adds the rows from {@code index0} to {@code index1}, inclusive, to
      * the current selection.
      *
-     * @exception IllegalArgumentException      if <code>index0</code> or <code>index1</code>
-     *                                          lie outside [0, <code>getRowCount()</code>-1]
+     * @exception IllegalArgumentException      if {@code index0} or {@code index1}
+     *                                          lie outside [0, {@code getRowCount()}-1]
      * @param   index0 one end of the interval
      * @param   index1 the other end of the interval
      */
     public void addRowSelectionInterval(int index0, int index1) {
         selectionModel.addSelectionInterval(boundRow(index0), boundRow(index1));
     }
 
     /**
-     * Adds the columns from <code>index0</code> to <code>index1</code>,
+     * Adds the columns from {@code index0} to {@code index1},
      * inclusive, to the current selection.
      *
-     * @exception IllegalArgumentException      if <code>index0</code> or
-     *                                          <code>index1</code> lie outside
-     *                                          [0, <code>getColumnCount()</code>-1]
+     * @exception IllegalArgumentException      if {@code index0} or
+     *                                          {@code index1} lie outside
+     *                                          [0, {@code getColumnCount()}-1]
      * @param   index0 one end of the interval
      * @param   index1 the other end of the interval
      */
     public void addColumnSelectionInterval(int index0, int index1) {
         columnModel.getSelectionModel().addSelectionInterval(boundColumn(index0), boundColumn(index1));
     }
 
     /**
-     * Deselects the rows from <code>index0</code> to <code>index1</code>, inclusive.
+     * Deselects the rows from {@code index0} to {@code index1}, inclusive.
      *
-     * @exception IllegalArgumentException      if <code>index0</code> or
-     *                                          <code>index1</code> lie outside
-     *                                          [0, <code>getRowCount()</code>-1]
+     * @exception IllegalArgumentException      if {@code index0} or
+     *                                          {@code index1} lie outside
+     *                                          [0, {@code getRowCount()}-1]
      * @param   index0 one end of the interval
      * @param   index1 the other end of the interval
      */
     public void removeRowSelectionInterval(int index0, int index1) {
         selectionModel.removeSelectionInterval(boundRow(index0), boundRow(index1));
     }
 
     /**
-     * Deselects the columns from <code>index0</code> to <code>index1</code>, inclusive.
+     * Deselects the columns from {@code index0} to {@code index1}, inclusive.
      *
-     * @exception IllegalArgumentException      if <code>index0</code> or
-     *                                          <code>index1</code> lie outside
-     *                                          [0, <code>getColumnCount()</code>-1]
+     * @exception IllegalArgumentException      if {@code index0} or
+     *                                          {@code index1} lie outside
+     *                                          [0, {@code getColumnCount()}-1]
      * @param   index0 one end of the interval
      * @param   index1 the other end of the interval
      */
     public void removeColumnSelectionInterval(int index0, int index1) {
         columnModel.getSelectionModel().removeSelectionInterval(boundColumn(index0), boundColumn(index1));

@@ -2343,11 +2343,11 @@
     /**
      * Returns true if the specified index is in the valid range of rows,
      * and the row at that index is selected.
      *
      * @param row a row in the row model
-     * @return true if <code>row</code> is a valid index and the row at
+     * @return true if {@code row} is a valid index and the row at
      *              that index is selected (where 0 is the first row)
      */
     public boolean isRowSelected(int row) {
         return selectionModel.isSelectedIndex(row);
     }

@@ -2355,11 +2355,11 @@
     /**
      * Returns true if the specified index is in the valid range of columns,
      * and the column at that index is selected.
      *
      * @param   column   the column in the column model
-     * @return true if <code>column</code> is a valid index and the column at
+     * @return true if {@code column} is a valid index and the column at
      *              that index is selected (where 0 is the first column)
      */
     public boolean isColumnSelected(int column) {
         return columnModel.getSelectionModel().isSelectedIndex(column);
     }

@@ -2368,12 +2368,12 @@
      * Returns true if the specified indices are in the valid range of rows
      * and columns and the cell at the specified position is selected.
      * @param row   the row being queried
      * @param column  the column being queried
      *
-     * @return true if <code>row</code> and <code>column</code> are valid indices
-     *              and the cell at index <code>(row, column)</code> is selected,
+     * @return true if {@code row} and {@code column} are valid indices
+     *              and the cell at index {@code (row, column)} is selected,
      *              where the first row and first column are at index 0
      */
     public boolean isCellSelected(int row, int column) {
         if (!getRowSelectionAllowed() && !getColumnSelectionAllowed()) {
             return false;

@@ -2417,32 +2417,32 @@
         }
     }
 
     /**
      * Updates the selection models of the table, depending on the state of the
-     * two flags: <code>toggle</code> and <code>extend</code>. Most changes
+     * two flags: {@code toggle} and {@code extend}. Most changes
      * to the selection that are the result of keyboard or mouse events received
      * by the UI are channeled through this method so that the behavior may be
      * overridden by a subclass. Some UIs may need more functionality than
      * this method provides, such as when manipulating the lead for discontiguous
      * selection, and may not call into this method for some selection changes.
      * <p>
      * This implementation uses the following conventions:
      * <ul>
-     * <li> <code>toggle</code>: <em>false</em>, <code>extend</code>: <em>false</em>.
+     * <li> {@code toggle}: <em>false</em>, {@code extend}: <em>false</em>.
      *      Clear the previous selection and ensure the new cell is selected.
-     * <li> <code>toggle</code>: <em>false</em>, <code>extend</code>: <em>true</em>.
+     * <li> {@code toggle}: <em>false</em>, {@code extend}: <em>true</em>.
      *      Extend the previous selection from the anchor to the specified cell,
      *      clearing all other selections.
-     * <li> <code>toggle</code>: <em>true</em>, <code>extend</code>: <em>false</em>.
+     * <li> {@code toggle}: <em>true</em>, {@code extend}: <em>false</em>.
      *      If the specified cell is selected, deselect it. If it is not selected, select it.
-     * <li> <code>toggle</code>: <em>true</em>, <code>extend</code>: <em>true</em>.
+     * <li> {@code toggle}: <em>true</em>, {@code extend}: <em>true</em>.
      *      Apply the selection state of the anchor to all cells between it and the
      *      specified cell.
      * </ul>
-     * @param  rowIndex   affects the selection at <code>row</code>
-     * @param  columnIndex  affects the selection at <code>column</code>
+     * @param  rowIndex   affects the selection at {@code row}
+     * @param  columnIndex  affects the selection at {@code column}
      * @param  toggle  see description above
      * @param  extend  if true, extend the current selection
      *
      * @since 1.3
      */

@@ -2496,11 +2496,11 @@
     }
 
     /**
      * Returns the foreground color for selected cells.
      *
-     * @return the <code>Color</code> object for the foreground property
+     * @return the {@code Color} object for the foreground property
      * @see #setSelectionForeground
      * @see #setSelectionBackground
      */
     public Color getSelectionForeground() {
         return selectionForeground;

@@ -2514,11 +2514,11 @@
      * The default value of this property is defined by the look
      * and feel implementation.
      * <p>
      * This is a <a href="http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html">JavaBeans</a> bound property.
      *
-     * @param selectionForeground  the <code>Color</code> to use in the foreground
+     * @param selectionForeground  the {@code Color} to use in the foreground
      *                             for selected list items
      * @see #getSelectionForeground
      * @see #setSelectionBackground
      * @see #setForeground
      * @see #setBackground

@@ -2535,11 +2535,11 @@
     }
 
     /**
      * Returns the background color for selected cells.
      *
-     * @return the <code>Color</code> used for the background of selected list items
+     * @return the {@code Color} used for the background of selected list items
      * @see #setSelectionBackground
      * @see #setSelectionForeground
      */
     public Color getSelectionBackground() {
         return selectionBackground;

@@ -2552,11 +2552,11 @@
      * The default value of this property is defined by the look
      * and feel implementation.
      * <p>
      * This is a <a href="http://docs.oracle.com/javase/tutorial/javabeans/writing/properties.html">JavaBeans</a> bound property.
      *
-     * @param selectionBackground  the <code>Color</code> to use for the background
+     * @param selectionBackground  the {@code Color} to use for the background
      *                             of selected cells
      * @see #getSelectionBackground
      * @see #setSelectionForeground
      * @see #setForeground
      * @see #setBackground

@@ -2571,16 +2571,16 @@
         firePropertyChange("selectionBackground", old, selectionBackground);
         repaint();
     }
 
     /**
-     * Returns the <code>TableColumn</code> object for the column in the table
-     * whose identifier is equal to <code>identifier</code>, when compared using
-     * <code>equals</code>.
+     * Returns the {@code TableColumn} object for the column in the table
+     * whose identifier is equal to {@code identifier}, when compared using
+     * {@code equals}.
      *
-     * @return  the <code>TableColumn</code> object that matches the identifier
-     * @exception IllegalArgumentException      if <code>identifier</code> is <code>null</code> or no <code>TableColumn</code> has this identifier
+     * @return  the {@code TableColumn} object that matches the identifier
+     * @exception IllegalArgumentException      if {@code identifier} is {@code null} or no {@code TableColumn} has this identifier
      *
      * @param   identifier                      the identifier object
      */
     public TableColumn getColumn(Object identifier) {
         TableColumnModel cm = getColumnModel();

@@ -2592,14 +2592,14 @@
 // Informally implement the TableModel interface.
 //
 
     /**
      * Maps the index of the column in the view at
-     * <code>viewColumnIndex</code> to the index of the column
+     * {@code viewColumnIndex} to the index of the column
      * in the table model.  Returns the index of the corresponding
-     * column in the model.  If <code>viewColumnIndex</code>
-     * is less than zero, returns <code>viewColumnIndex</code>.
+     * column in the model.  If {@code viewColumnIndex}
+     * is less than zero, returns {@code viewColumnIndex}.
      *
      * @param   viewColumnIndex     the index of the column in the view
      * @return  the index of the corresponding column in the model
      *
      * @see #convertColumnIndexToView

@@ -2609,15 +2609,15 @@
                 getColumnModel(), viewColumnIndex);
     }
 
     /**
      * Maps the index of the column in the table model at
-     * <code>modelColumnIndex</code> to the index of the column
+     * {@code modelColumnIndex} to the index of the column
      * in the view.  Returns the index of the
      * corresponding column in the view; returns -1 if this column is not
-     * being displayed.  If <code>modelColumnIndex</code> is less than zero,
-     * returns <code>modelColumnIndex</code>.
+     * being displayed.  If {@code modelColumnIndex} is less than zero,
+     * returns {@code modelColumnIndex}.
      *
      * @param   modelColumnIndex     the index of the column in the model
      * @return   the index of the corresponding column in the view
      *
      * @see #convertColumnIndexToModel

@@ -2627,18 +2627,18 @@
                 getColumnModel(), modelColumnIndex);
     }
 
     /**
      * Maps the index of the row in terms of the
-     * <code>TableModel</code> to the view.  If the contents of the
+     * {@code TableModel} to the view.  If the contents of the
      * model are not sorted the model and view indices are the same.
      *
      * @param modelRowIndex the index of the row in terms of the model
      * @return the index of the corresponding row in the view, or -1 if
      *         the row isn't visible
      * @throws IndexOutOfBoundsException if sorting is enabled and passed an
-     *         index outside the number of rows of the <code>TableModel</code>
+     *         index outside the number of rows of the {@code TableModel}
      * @see javax.swing.table.TableRowSorter
      * @since 1.6
      */
     public int convertRowIndexToView(int modelRowIndex) {
         RowSorter<?> sorter = getRowSorter();

@@ -2648,18 +2648,18 @@
         return modelRowIndex;
     }
 
     /**
      * Maps the index of the row in terms of the view to the
-     * underlying <code>TableModel</code>.  If the contents of the
+     * underlying {@code TableModel}.  If the contents of the
      * model are not sorted the model and view indices are the same.
      *
      * @param viewRowIndex the index of the row in the view
      * @return the index of the corresponding row in the model
      * @throws IndexOutOfBoundsException if sorting is enabled and passed an
-     *         index outside the range of the <code>JTable</code> as
-     *         determined by the method <code>getRowCount</code>
+     *         index outside the range of the {@code JTable} as
+     *         determined by the method {@code getRowCount}
      * @see javax.swing.table.TableRowSorter
      * @see #getRowCount
      * @since 1.6
      */
     public int convertRowIndexToModel(int viewRowIndex) {

@@ -2670,16 +2670,16 @@
         return viewRowIndex;
     }
 
     /**
      * Returns the number of rows that can be shown in the
-     * <code>JTable</code>, given unlimited space.  If a
-     * <code>RowSorter</code> with a filter has been specified, the
+     * {@code JTable}, given unlimited space.  If a
+     * {@code RowSorter} with a filter has been specified, the
      * number of rows returned may differ from that of the underlying
-     * <code>TableModel</code>.
+     * {@code TableModel}.
      *
-     * @return the number of rows shown in the <code>JTable</code>
+     * @return the number of rows shown in the {@code JTable}
      * @see #getColumnCount
      */
     public int getRowCount() {
         RowSorter<?> sorter = getRowSorter();
         if (sorter != null) {

@@ -2700,37 +2700,37 @@
         return getColumnModel().getColumnCount();
     }
 
     /**
      * Returns the name of the column appearing in the view at
-     * column position <code>column</code>.
+     * column position {@code column}.
      *
      * @param  column    the column in the view being queried
-     * @return the name of the column at position <code>column</code>
+     * @return the name of the column at position {@code column}
                         in the view where the first column is column 0
      */
     public String getColumnName(int column) {
         return getModel().getColumnName(convertColumnIndexToModel(column));
     }
 
     /**
      * Returns the type of the column appearing in the view at
-     * column position <code>column</code>.
+     * column position {@code column}.
      *
      * @param   column   the column in the view being queried
-     * @return the type of the column at position <code>column</code>
+     * @return the type of the column at position {@code column}
      *          in the view where the first column is column 0
      */
     public Class<?> getColumnClass(int column) {
         return getModel().getColumnClass(convertColumnIndexToModel(column));
     }
 
     /**
-     * Returns the cell value at <code>row</code> and <code>column</code>.
+     * Returns the cell value at {@code row} and {@code column}.
      * <p>
      * <b>Note</b>: The column is specified in the table view's display
-     *              order, and not in the <code>TableModel</code>'s column
+     *              order, and not in the {@code TableModel}'s column
      *              order.  This is an important distinction because as the
      *              user rearranges the columns in the table,
      *              the column at a given index in the view will change.
      *              Meanwhile the user's actions never affect the model's
      *              column ordering.

@@ -2743,22 +2743,22 @@
         return getModel().getValueAt(convertRowIndexToModel(row),
                                      convertColumnIndexToModel(column));
     }
 
     /**
-     * Sets the value for the cell in the table model at <code>row</code>
-     * and <code>column</code>.
+     * Sets the value for the cell in the table model at {@code row}
+     * and {@code column}.
      * <p>
      * <b>Note</b>: The column is specified in the table view's display
-     *              order, and not in the <code>TableModel</code>'s column
+     *              order, and not in the {@code TableModel}'s column
      *              order.  This is an important distinction because as the
      *              user rearranges the columns in the table,
      *              the column at a given index in the view will change.
      *              Meanwhile the user's actions never affect the model's
      *              column ordering.
      *
-     * <code>aValue</code> is the new value.
+     * {@code aValue} is the new value.
      *
      * @param   aValue          the new value
      * @param   row             the row of the cell to be changed
      * @param   column          the column of the cell to be changed
      * @see #getValueAt

@@ -2767,16 +2767,16 @@
         getModel().setValueAt(aValue, convertRowIndexToModel(row),
                               convertColumnIndexToModel(column));
     }
 
     /**
-     * Returns true if the cell at <code>row</code> and <code>column</code>
-     * is editable.  Otherwise, invoking <code>setValueAt</code> on the cell
+     * Returns true if the cell at {@code row} and {@code column}
+     * is editable.  Otherwise, invoking {@code setValueAt} on the cell
      * will have no effect.
      * <p>
      * <b>Note</b>: The column is specified in the table view's display
-     *              order, and not in the <code>TableModel</code>'s column
+     *              order, and not in the {@code TableModel}'s column
      *              order.  This is an important distinction because as the
      *              user rearranges the columns in the table,
      *              the column at a given index in the view will change.
      *              Meanwhile the user's actions never affect the model's
      *              column ordering.

@@ -2794,33 +2794,33 @@
 //
 // Adding and removing columns in the view
 //
 
     /**
-     *  Appends <code>aColumn</code> to the end of the array of columns held by
-     *  this <code>JTable</code>'s column model.
-     *  If the column name of <code>aColumn</code> is <code>null</code>,
-     *  sets the column name of <code>aColumn</code> to the name
-     *  returned by <code>getModel().getColumnName()</code>.
-     *  <p>
-     *  To add a column to this <code>JTable</code> to display the
-     *  <code>modelColumn</code>'th column of data in the model with a
-     *  given <code>width</code>, <code>cellRenderer</code>,
-     *  and <code>cellEditor</code> you can use:
+     *  Appends {@code aColumn} to the end of the array of columns held by
+     *  this {@code JTable}'s column model.
+     *  If the column name of {@code aColumn} is {@code null},
+     *  sets the column name of {@code aColumn} to the name
+     *  returned by {@code getModel().getColumnName()}.
+     *  <p>
+     *  To add a column to this {@code JTable} to display the
+     *  {@code modelColumn}'th column of data in the model with a
+     *  given {@code width}, {@code cellRenderer},
+     *  and {@code cellEditor} you can use:
      *  <pre>
      *
      *      addColumn(new TableColumn(modelColumn, width, cellRenderer, cellEditor));
      *
      *  </pre>
-     *  [Any of the <code>TableColumn</code> constructors can be used
+     *  [Any of the {@code TableColumn} constructors can be used
      *  instead of this one.]
-     *  The model column number is stored inside the <code>TableColumn</code>
+     *  The model column number is stored inside the {@code TableColumn}
      *  and is used during rendering and editing to locate the appropriates
      *  data values in the model. The model column number does not change
      *  when columns are reordered in the view.
      *
-     *  @param  aColumn         the <code>TableColumn</code> to be added
+     *  @param  aColumn         the {@code TableColumn} to be added
      *  @see    #removeColumn
      */
     public void addColumn(TableColumn aColumn) {
         if (aColumn.getHeaderValue() == null) {
             int modelColumn = aColumn.getModelIndex();

@@ -2829,26 +2829,26 @@
         }
         getColumnModel().addColumn(aColumn);
     }
 
     /**
-     *  Removes <code>aColumn</code> from this <code>JTable</code>'s
+     *  Removes {@code aColumn} from this {@code JTable}'s
      *  array of columns.  Note: this method does not remove the column
-     *  of data from the model; it just removes the <code>TableColumn</code>
+     *  of data from the model; it just removes the {@code TableColumn}
      *  that was responsible for displaying it.
      *
-     *  @param  aColumn         the <code>TableColumn</code> to be removed
+     *  @param  aColumn         the {@code TableColumn} to be removed
      *  @see    #addColumn
      */
     public void removeColumn(TableColumn aColumn) {
         getColumnModel().removeColumn(aColumn);
     }
 
     /**
-     * Moves the column <code>column</code> to the position currently
-     * occupied by the column <code>targetColumn</code> in the view.
-     * The old column at <code>targetColumn</code> is
+     * Moves the column {@code column} to the position currently
+     * occupied by the column {@code targetColumn} in the view.
+     * The old column at {@code targetColumn} is
      * shifted left or right to make room.
      *
      * @param   column                  the index of column to be moved
      * @param   targetColumn            the new index of the column
      */

@@ -2859,18 +2859,18 @@
 //
 // Cover methods for various models and helper methods
 //
 
     /**
-     * Returns the index of the column that <code>point</code> lies in,
+     * Returns the index of the column that {@code point} lies in,
      * or -1 if the result is not in the range
-     * [0, <code>getColumnCount()</code>-1].
+     * [0, {@code getColumnCount()}-1].
      *
      * @param   point   the location of interest
-     * @return  the index of the column that <code>point</code> lies in,
+     * @return  the index of the column that {@code point} lies in,
      *          or -1 if the result is not in the range
-     *          [0, <code>getColumnCount()</code>-1]
+     *          [0, {@code getColumnCount()}-1]
      * @see     #rowAtPoint
      */
     public int columnAtPoint(Point point) {
         int x = point.x;
         if( !getComponentOrientation().isLeftToRight() ) {

@@ -2878,18 +2878,18 @@
         }
         return getColumnModel().getColumnIndexAtX(x);
     }
 
     /**
-     * Returns the index of the row that <code>point</code> lies in,
+     * Returns the index of the row that {@code point} lies in,
      * or -1 if the result is not in the range
-     * [0, <code>getRowCount()</code>-1].
+     * [0, {@code getRowCount()}-1].
      *
      * @param   point   the location of interest
-     * @return  the index of the row that <code>point</code> lies in,
+     * @return  the index of the row that {@code point} lies in,
      *          or -1 if the result is not in the range
-     *          [0, <code>getRowCount()</code>-1]
+     *          [0, {@code getRowCount()}-1]
      * @see     #columnAtPoint
      */
     public int rowAtPoint(Point point) {
         int y = point.y;
         int result = (rowModel == null) ?  y/getRowHeight() : rowModel.getIndex(y);

@@ -2904,32 +2904,32 @@
         }
     }
 
     /**
      * Returns a rectangle for the cell that lies at the intersection of
-     * <code>row</code> and <code>column</code>.
-     * If <code>includeSpacing</code> is true then the value returned
+     * {@code row} and {@code column}.
+     * If {@code includeSpacing} is true then the value returned
      * has the full height and width of the row and column
      * specified. If it is false, the returned rectangle is inset by the
      * intercell spacing to return the true bounds of the rendering or
      * editing component as it will be set during rendering.
      * <p>
      * If the column index is valid but the row index is less
      * than zero the method returns a rectangle with the
-     * <code>y</code> and <code>height</code> values set appropriately
-     * and the <code>x</code> and <code>width</code> values both set
+     * {@code y} and {@code height} values set appropriately
+     * and the {@code x} and {@code width} values both set
      * to zero. In general, when either the row or column indices indicate a
      * cell outside the appropriate range, the method returns a rectangle
      * depicting the closest edge of the closest cell that is within
      * the table's range. When both row and column indices are out
      * of range the returned rectangle covers the closest
      * point of the closest cell.
      * <p>
      * In all cases, calculations that use this method to calculate
      * results along one axis will not fail because of anomalies in
      * calculations along the other axis. When the cell is not valid
-     * the <code>includeSpacing</code> parameter is ignored.
+     * the {@code includeSpacing} parameter is ignored.
      *
      * @param   row                   the row index where the desired cell
      *                                is located
      * @param   column                the column index where the desired cell
      *                                is located in the display; this is not

@@ -2943,11 +2943,11 @@
      *                                computed by subtracting the intercell
      *                                spacing from the height and widths of
      *                                the column and row models
      *
      * @return  the rectangle containing the cell at location
-     *          <code>row</code>,<code>column</code>
+     *          {@code row},{@code column}
      * @see #getIntercellSpacing
      */
     public Rectangle getCellRect(int row, int column, boolean includeSpacing) {
         Rectangle r = new Rectangle();
         boolean valid = true;

@@ -3016,34 +3016,34 @@
     /**
      * Causes this table to lay out its rows and columns.  Overridden so
      * that columns can be resized to accommodate a change in the size of
      * a containing parent.
      * Resizes one or more of the columns in the table
-     * so that the total width of all of this <code>JTable</code>'s
+     * so that the total width of all of this {@code JTable}'s
      * columns is equal to the width of the table.
      * <p>
      * Before the layout begins the method gets the
-     * <code>resizingColumn</code> of the <code>tableHeader</code>.
+     * {@code resizingColumn} of the {@code tableHeader}.
      * When the method is called as a result of the resizing of an enclosing window,
-     * the <code>resizingColumn</code> is <code>null</code>. This means that resizing
-     * has taken place "outside" the <code>JTable</code> and the change -
+     * the {@code resizingColumn} is {@code null}. This means that resizing
+     * has taken place "outside" the {@code JTable} and the change -
      * or "delta" - should be distributed to all of the columns regardless
-     * of this <code>JTable</code>'s automatic resize mode.
+     * of this {@code JTable}'s automatic resize mode.
      * <p>
-     * If the <code>resizingColumn</code> is not <code>null</code>, it is one of
+     * If the {@code resizingColumn} is not {@code null}, it is one of
      * the columns in the table that has changed size rather than
      * the table itself. In this case the auto-resize modes govern
      * the way the extra (or deficit) space is distributed
      * amongst the available columns.
      * <p>
      * The modes are:
      * <ul>
      * <li>  AUTO_RESIZE_OFF: Don't automatically adjust the column's
      * widths at all. Use a horizontal scrollbar to accommodate the
      * columns when their sum exceeds the width of the
-     * <code>Viewport</code>.  If the <code>JTable</code> is not
-     * enclosed in a <code>JScrollPane</code> this may
+     * {@code Viewport}.  If the {@code JTable} is not
+     * enclosed in a {@code JScrollPane} this may
      * leave parts of the table invisible.
      * <li>  AUTO_RESIZE_NEXT_COLUMN: Use just the column after the
      * resizing column. This results in the "boundary" or divider
      * between adjacent cells being independently adjustable.
      * <li>  AUTO_RESIZE_SUBSEQUENT_COLUMNS: Use all columns after the

@@ -3053,38 +3053,38 @@
      * size of the last column only. If the bounds of the last column
      * prevent the desired size from being allocated, set the
      * width of the last column to the appropriate limit and make
      * no further adjustments.
      * <li>  AUTO_RESIZE_ALL_COLUMNS: Spread the delta amongst all the columns
-     * in the <code>JTable</code>, including the one that is being
+     * in the {@code JTable}, including the one that is being
      * adjusted.
      * </ul>
      * <p>
-     * <b>Note:</b> When a <code>JTable</code> makes adjustments
+     * <b>Note:</b> When a {@code JTable} makes adjustments
      *   to the widths of the columns it respects their minimum and
      *   maximum values absolutely.  It is therefore possible that,
      *   even after this method is called, the total width of the columns
      *   is still not equal to the width of the table. When this happens
-     *   the <code>JTable</code> does not put itself
+     *   the {@code JTable} does not put itself
      *   in AUTO_RESIZE_OFF mode to bring up a scroll bar, or break other
      *   commitments of its current auto-resize mode -- instead it
      *   allows its bounds to be set larger (or smaller) than the total of the
      *   column minimum or maximum, meaning, either that there
      *   will not be enough room to display all of the columns, or that the
-     *   columns will not fill the <code>JTable</code>'s bounds.
+     *   columns will not fill the {@code JTable}'s bounds.
      *   These respectively, result in the clipping of some columns
-     *   or an area being painted in the <code>JTable</code>'s
+     *   or an area being painted in the {@code JTable}'s
      *   background color during painting.
      * <p>
      *   The mechanism for distributing the delta amongst the available
-     *   columns is provided in a private method in the <code>JTable</code>
+     *   columns is provided in a private method in the {@code JTable}
      *   class:
      * <pre>
      *   adjustSizes(long targetSize, final Resizable3 r, boolean inverse)
      * </pre>
      *   an explanation of which is provided in the following section.
-     *   <code>Resizable3</code> is a private
+     *   {@code Resizable3} is a private
      *   interface that allows any data structure containing a collection
      *   of elements with a size, preferred size, maximum size and minimum size
      *   to have its elements manipulated by the algorithm.
      *
      * <H3> Distributing the delta </H3>

@@ -3136,16 +3136,16 @@
      * the aggregated rounding errors caused by doing this operation in finite
      * precision (using ints). To deal with this, the multiplying factor above,
      * is constantly recalculated and this takes account of the rounding
      * errors in the previous iterations. The result is an algorithm that
      * produces a set of integers whose values exactly sum to the supplied
-     * <code>targetSize</code>, and does so by spreading the rounding
+     * {@code targetSize}, and does so by spreading the rounding
      * errors evenly over the given elements.
      *
      * <H4>When the MAX and MIN bounds are hit</H4>
      * <P>
-     * When <code>targetSize</code> is outside the [MIN, MAX] range,
+     * When {@code targetSize} is outside the [MIN, MAX] range,
      * the algorithm sets all sizes to their appropriate limiting value
      * (maximum or minimum).
      *
      */
     public void doLayout() {

@@ -3199,11 +3199,11 @@
     /**
      * Sizes the table columns to fit the available space.
      *
      * @param lastColumnOnly determines whether to resize last column only
      * @deprecated As of Swing version 1.0.3,
-     * replaced by <code>doLayout()</code>.
+     * replaced by {@code doLayout()}.
      * @see #doLayout
      */
     @Deprecated
     public void sizeColumnsToFit(boolean lastColumnOnly) {
         int oldAutoResizeMode = autoResizeMode;

@@ -3213,11 +3213,11 @@
         setAutoResizeMode(oldAutoResizeMode);
     }
 
     /**
      * Obsolete as of Java 2 platform v1.4.  Please use the
-     * <code>doLayout()</code> method instead.
+     * {@code doLayout()} method instead.
      * @param resizingColumn    the column whose resizing made this adjustment
      *                          necessary or -1 if there is no such column
      * @see  #doLayout
      */
     public void sizeColumnsToFit(int resizingColumn) {

@@ -3389,21 +3389,21 @@
             totalUpperBound -= upperBound;
         }
     }
 
     /**
-     * Overrides <code>JComponent</code>'s <code>getToolTipText</code>
+     * Overrides {@code JComponent}'s {@code getToolTipText}
      * method in order to allow the renderer's tips to be used
      * if it has text set.
      * <p>
-     * <b>Note:</b> For <code>JTable</code> to properly display
+     * <b>Note:</b> For {@code JTable} to properly display
      * tooltips of its renderers
-     * <code>JTable</code> must be a registered component with the
-     * <code>ToolTipManager</code>.
-     * This is done automatically in <code>initializeLocalVars</code>,
-     * but if at a later point <code>JTable</code> is told
-     * <code>setToolTipText(null)</code> it will unregister the table
+     * {@code JTable} must be a registered component with the
+     * {@code ToolTipManager}.
+     * This is done automatically in {@code initializeLocalVars},
+     * but if at a later point {@code JTable} is told
+     * {@code setToolTipText(null)} it will unregister the table
      * component, and no tips from renderers will display anymore.
      *
      * @see JComponent#getToolTipText
      */
     public String getToolTipText(MouseEvent event) {

@@ -3481,15 +3481,15 @@
     public boolean getSurrendersFocusOnKeystroke() {
         return surrendersFocusOnKeystroke;
     }
 
     /**
-     * Programmatically starts editing the cell at <code>row</code> and
-     * <code>column</code>, if those indices are in the valid range, and
+     * Programmatically starts editing the cell at {@code row} and
+     * {@code column}, if those indices are in the valid range, and
      * the cell at those indices is editable.
      * Note that this is a convenience method for
-     * <code>editCellAt(int, int, null)</code>.
+     * {@code editCellAt(int, int, null)}.
      *
      * @param   row                             the row to be edited
      * @param   column                          the column to be edited
      * @return  false if for any reason the cell cannot be edited,
      *                or if the indices are invalid

@@ -3497,23 +3497,23 @@
     public boolean editCellAt(int row, int column) {
         return editCellAt(row, column, null);
     }
 
     /**
-     * Programmatically starts editing the cell at <code>row</code> and
-     * <code>column</code>, if those indices are in the valid range, and
+     * Programmatically starts editing the cell at {@code row} and
+     * {@code column}, if those indices are in the valid range, and
      * the cell at those indices is editable.
-     * To prevent the <code>JTable</code> from
+     * To prevent the {@code JTable} from
      * editing a particular table, column or cell value, return false from
-     * the <code>isCellEditable</code> method in the <code>TableModel</code>
+     * the {@code isCellEditable} method in the {@code TableModel}
      * interface.
      *
      * @param   row     the row to be edited
      * @param   column  the column to be edited
-     * @param   e       event to pass into <code>shouldSelectCell</code>;
+     * @param   e       event to pass into {@code shouldSelectCell};
      *                  note that as of Java 2 platform v1.2, the call to
-     *                  <code>shouldSelectCell</code> is no longer made
+     *                  {@code shouldSelectCell} is no longer made
      * @return  false if for any reason the cell cannot be edited,
      *                or if the indices are invalid
      */
     public boolean editCellAt(int row, int column, EventObject e){
         if (cellEditor != null && !cellEditor.stopCellEditing()) {

@@ -3607,11 +3607,11 @@
 //
 
     /**
      * Returns the L&amp;F object that renders this component.
      *
-     * @return the <code>TableUI</code> object that renders this component
+     * @return the {@code TableUI} object that renders this component
      */
     public TableUI getUI() {
         return (TableUI)ui;
     }
 

@@ -3632,13 +3632,13 @@
             repaint();
         }
     }
 
     /**
-     * Notification from the <code>UIManager</code> that the L&amp;F has changed.
+     * Notification from the {@code UIManager} that the L&amp;F has changed.
      * Replaces the current UI object with the latest version from the
-     * <code>UIManager</code>.
+     * {@code UIManager}.
      *
      * @see JComponent#updateUI
      */
     public void updateUI() {
         // Update the UIs of the cell renderers, cell editors and header renderers.

@@ -3827,15 +3827,15 @@
 //
 // RowSorterListener
 //
 
     /**
-     * <code>RowSorterListener</code> notification that the
-     * <code>RowSorter</code> has changed in some way.
+     * {@code RowSorterListener} notification that the
+     * {@code RowSorter} has changed in some way.
      *
-     * @param e the <code>RowSorterEvent</code> describing the change
-     * @throws NullPointerException if <code>e</code> is <code>null</code>
+     * @param e the {@code RowSorterEvent} describing the change
+     * @throws NullPointerException if {@code e} is {@code null}
      * @since 1.6
      */
     public void sorterChanged(RowSorterEvent e) {
         if (e.getType() == RowSorterEvent.Type.SORT_ORDER_CHANGED) {
             JTableHeader header = getTableHeader();

@@ -4123,12 +4123,12 @@
             allRowsChanged = (e.getLastRow() == Integer.MAX_VALUE);
         }
     }
 
     /**
-     * Invoked when <code>sorterChanged</code> is invoked, or
-     * when <code>tableChanged</code> is invoked and sorting is enabled.
+     * Invoked when {@code sorterChanged} is invoked, or
+     * when {@code tableChanged} is invoked and sorting is enabled.
      */
     private void sortedTableChanged(RowSorterEvent sortedEvent,
                                     TableModelEvent e) {
         int editingModelIndex = -1;
         ModelChange change = (e != null) ? new ModelChange(e) : null;

@@ -4380,19 +4380,19 @@
 //
 // Implementing TableModelListener interface
 //
 
     /**
-     * Invoked when this table's <code>TableModel</code> generates
-     * a <code>TableModelEvent</code>.
-     * The <code>TableModelEvent</code> should be constructed in the
+     * Invoked when this table's {@code TableModel} generates
+     * a {@code TableModelEvent}.
+     * The {@code TableModelEvent} should be constructed in the
      * coordinate system of the model; the appropriate mapping to the
-     * view coordinate system is performed by this <code>JTable</code>
+     * view coordinate system is performed by this {@code JTable}
      * when it receives the event.
      * <p>
      * Application code will not use these methods explicitly, they
-     * are used internally by <code>JTable</code>.
+     * are used internally by {@code JTable}.
      * <p>
      * Note that as of 1.3, this method clears the selection, if any.
      */
     public void tableChanged(TableModelEvent e) {
         if (e == null || e.getFirstRow() == TableModelEvent.HEADER_ROW) {

@@ -4639,11 +4639,11 @@
     private int limit(int i, int a, int b) {
         return Math.min(b, Math.max(i, a));
     }
 
     /**
-     * Invoked when the selection model of the <code>TableColumnModel</code>
+     * Invoked when the selection model of the {@code TableColumnModel}
      * is changed.
      * <p>
      * Application code will not use these methods explicitly, they
      * are used internally by JTable.
      *

@@ -4779,12 +4779,12 @@
 //
 
     /**
      * Sets the preferred size of the viewport for this table.
      *
-     * @param size  a <code>Dimension</code> object specifying the <code>preferredSize</code> of a
-     *              <code>JViewport</code> whose view is this table
+     * @param size  a {@code Dimension} object specifying the {@code preferredSize} of a
+     *              {@code JViewport} whose view is this table
      * @see Scrollable#getPreferredScrollableViewportSize
      * @beaninfo
      * description: The preferred size of the viewport.
      */
     public void setPreferredScrollableViewportSize(Dimension size) {

@@ -4792,11 +4792,11 @@
     }
 
     /**
      * Returns the preferred size of the viewport for this table.
      *
-     * @return a <code>Dimension</code> object containing the <code>preferredSize</code> of the <code>JViewport</code>
+     * @return a {@code Dimension} object containing the {@code preferredSize} of the {@code JViewport}
      *         which displays this table
      * @see Scrollable#getPreferredScrollableViewportSize
      */
     public Dimension getPreferredScrollableViewportSize() {
         return preferredViewportSize;

@@ -4807,12 +4807,12 @@
      * row or column (depending on the orientation).
      * <p>
      * This method is called each time the user requests a unit scroll.
      *
      * @param visibleRect the view area visible within the viewport
-     * @param orientation either <code>SwingConstants.VERTICAL</code>
-     *                  or <code>SwingConstants.HORIZONTAL</code>
+     * @param orientation either {@code SwingConstants.VERTICAL}
+     *                  or {@code SwingConstants.HORIZONTAL}
      * @param direction less than zero to scroll up/left,
      *                  greater than zero for down/right
      * @return the "unit" increment for scrolling in the specified direction
      * @see Scrollable#getScrollableUnitIncrement
      */

@@ -4903,19 +4903,19 @@
             }
         }
     }
 
     /**
-     * Returns <code>visibleRect.height</code> or
-     * <code>visibleRect.width</code>,
+     * Returns {@code visibleRect.height} or
+     * {@code visibleRect.width},
      * depending on this table's orientation.  Note that as of Swing 1.1.1
      * (Java 2 v 1.2.2) the value
      * returned will ensure that the viewport is cleanly aligned on
      * a row boundary.
      *
-     * @return <code>visibleRect.height</code> or
-     *                                  <code>visibleRect.width</code>
+     * @return {@code visibleRect.height} or
+     *                                  {@code visibleRect.width}
      *                                  per the orientation
      * @see Scrollable#getScrollableBlockIncrement
      */
     public int getScrollableBlockIncrement(Rectangle visibleRect,
             int orientation, int direction) {

@@ -5211,17 +5211,17 @@
             return rect.x;
         }
     }
 
     /**
-     * Returns false if <code>autoResizeMode</code> is set to
-     * <code>AUTO_RESIZE_OFF</code>, which indicates that the
+     * Returns false if {@code autoResizeMode} is set to
+     * {@code AUTO_RESIZE_OFF}, which indicates that the
      * width of the viewport does not determine the width
      * of the table.  Otherwise returns true.
      *
-     * @return false if <code>autoResizeMode</code> is set
-     *   to <code>AUTO_RESIZE_OFF</code>, otherwise returns true
+     * @return false if {@code autoResizeMode} is set
+     *   to {@code AUTO_RESIZE_OFF}, otherwise returns true
      * @see Scrollable#getScrollableTracksViewportWidth
      */
     public boolean getScrollableTracksViewportWidth() {
         return !(autoResizeMode == AUTO_RESIZE_OFF);
     }

@@ -5587,11 +5587,11 @@
         setAutoscrolls(true);
     }
 
     /**
      * Returns the default table model object, which is
-     * a <code>DefaultTableModel</code>.  A subclass can override this
+     * a {@code DefaultTableModel}.  A subclass can override this
      * method to return a different table model object.
      *
      * @return the default table model object
      * @see javax.swing.table.DefaultTableModel
      */

@@ -5599,11 +5599,11 @@
         return new DefaultTableModel();
     }
 
     /**
      * Returns the default column model object, which is
-     * a <code>DefaultTableColumnModel</code>.  A subclass can override this
+     * a {@code DefaultTableColumnModel}.  A subclass can override this
      * method to return a different column model object.
      *
      * @return the default column model object
      * @see javax.swing.table.DefaultTableColumnModel
      */

@@ -5611,11 +5611,11 @@
         return new DefaultTableColumnModel();
     }
 
     /**
      * Returns the default selection model object, which is
-     * a <code>DefaultListSelectionModel</code>.  A subclass can override this
+     * a {@code DefaultListSelectionModel}.  A subclass can override this
      * method to return a different selection model object.
      *
      * @return the default selection model object
      * @see javax.swing.DefaultListSelectionModel
      */

@@ -5623,22 +5623,22 @@
         return new DefaultListSelectionModel();
     }
 
     /**
      * Returns the default table header object, which is
-     * a <code>JTableHeader</code>.  A subclass can override this
+     * a {@code JTableHeader}.  A subclass can override this
      * method to return a different table header object.
      *
      * @return the default table header object
      * @see javax.swing.table.JTableHeader
      */
     protected JTableHeader createDefaultTableHeader() {
         return new JTableHeader(columnModel);
     }
 
     /**
-     * Equivalent to <code>revalidate</code> followed by <code>repaint</code>.
+     * Equivalent to {@code revalidate} followed by {@code repaint}.
      */
     protected void resizeAndRepaint() {
         revalidate();
         repaint();
     }

@@ -5670,45 +5670,45 @@
         cellEditor = anEditor;
         firePropertyChange("tableCellEditor", oldEditor, anEditor);
     }
 
     /**
-     * Sets the <code>editingColumn</code> variable.
+     * Sets the {@code editingColumn} variable.
      * @param aColumn  the column of the cell to be edited
      *
      * @see #editingColumn
      */
     public void setEditingColumn(int aColumn) {
         editingColumn = aColumn;
     }
 
     /**
-     * Sets the <code>editingRow</code> variable.
+     * Sets the {@code editingRow} variable.
      * @param aRow  the row of the cell to be edited
      *
      * @see #editingRow
      */
     public void setEditingRow(int aRow) {
         editingRow = aRow;
     }
 
     /**
      * Returns an appropriate renderer for the cell specified by this row and
-     * column. If the <code>TableColumn</code> for this column has a non-null
+     * column. If the {@code TableColumn} for this column has a non-null
      * renderer, returns that.  If not, finds the class of the data in
-     * this column (using <code>getColumnClass</code>)
+     * this column (using {@code getColumnClass})
      * and returns the default renderer for this type of data.
      * <p>
      * <b>Note:</b>
      * Throughout the table package, the internal implementations always
      * use this method to provide renderers so that this default behavior
      * can be safely overridden by a subclass.
      *
      * @param row       the row of the cell to render, where 0 is the first row
      * @param column    the column of the cell to render,
      *                  where 0 is the first column
-     * @return the assigned renderer; if <code>null</code>
+     * @return the assigned renderer; if {@code null}
      *                  returns the default renderer
      *                  for this type of object
      * @see javax.swing.table.DefaultTableCellRenderer
      * @see javax.swing.table.TableColumn#setCellRenderer
      * @see #setDefaultRenderer

@@ -5723,13 +5723,13 @@
     }
 
     /**
      * Prepares the renderer by querying the data model for the
      * value and selection state
-     * of the cell at <code>row</code>, <code>column</code>.
-     * Returns the component (may be a <code>Component</code>
-     * or a <code>JComponent</code>) under the event location.
+     * of the cell at {@code row}, {@code column}.
+     * Returns the component (may be a {@code Component}
+     * or a {@code JComponent}) under the event location.
      * <p>
      * During a printing operation, this method will configure the
      * renderer without indicating selection or focus, to prevent
      * them from appearing in the printed output. To do other
      * customizations based on whether or not the table is being

@@ -5740,15 +5740,15 @@
      * <b>Note:</b>
      * Throughout the table package, the internal implementations always
      * use this method to prepare renderers so that this default behavior
      * can be safely overridden by a subclass.
      *
-     * @param renderer  the <code>TableCellRenderer</code> to prepare
+     * @param renderer  the {@code TableCellRenderer} to prepare
      * @param row       the row of the cell to render, where 0 is the first row
      * @param column    the column of the cell to render,
      *                  where 0 is the first column
-     * @return          the <code>Component</code> under the event location
+     * @return          the {@code Component} under the event location
      */
     public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
         Object value = getValueAt(row, column);
 
         boolean isSelected = false;

@@ -5771,14 +5771,14 @@
                                                       row, column);
     }
 
     /**
      * Returns an appropriate editor for the cell specified by
-     * <code>row</code> and <code>column</code>. If the
-     * <code>TableColumn</code> for this column has a non-null editor,
+     * {@code row} and {@code column}. If the
+     * {@code TableColumn} for this column has a non-null editor,
      * returns that.  If not, finds the class of the data in this
-     * column (using <code>getColumnClass</code>)
+     * column (using {@code getColumnClass})
      * and returns the default editor for this type of data.
      * <p>
      * <b>Note:</b>
      * Throughout the table package, the internal implementations always
      * use this method to provide editors so that this default behavior

@@ -5786,11 +5786,11 @@
      *
      * @param row       the row of the cell to edit, where 0 is the first row
      * @param column    the column of the cell to edit,
      *                  where 0 is the first column
      * @return          the editor for this cell;
-     *                  if <code>null</code> return the default editor for
+     *                  if {@code null} return the default editor for
      *                  this type of cell
      * @see DefaultCellEditor
      */
     public TableCellEditor getCellEditor(int row, int column) {
         TableColumn tableColumn = getColumnModel().getColumn(column);

@@ -5802,23 +5802,23 @@
     }
 
 
     /**
      * Prepares the editor by querying the data model for the value and
-     * selection state of the cell at <code>row</code>, <code>column</code>.
+     * selection state of the cell at {@code row}, {@code column}.
      * <p>
      * <b>Note:</b>
      * Throughout the table package, the internal implementations always
      * use this method to prepare editors so that this default behavior
      * can be safely overridden by a subclass.
      *
-     * @param editor  the <code>TableCellEditor</code> to set up
+     * @param editor  the {@code TableCellEditor} to set up
      * @param row     the row of the cell to edit,
      *                where 0 is the first row
      * @param column  the column of the cell to edit,
      *                where 0 is the first column
-     * @return the <code>Component</code> being edited
+     * @return the {@code Component} being edited
      */
     @SuppressWarnings("deprecation")
     public Component prepareEditor(TableCellEditor editor, int row, int column) {
         Object value = getValueAt(row, column);
         boolean isSelected = isCellSelected(row, column);

@@ -5987,11 +5987,11 @@
     /**
      * Returns a string representation of this table. This method
      * is intended to be used only for debugging purposes, and the
      * content and format of the returned string may vary between
      * implementations. The returned string may be empty but may not
-     * be <code>null</code>.
+     * be {@code null}.
      *
      * @return  a string representation of this table
      */
     protected String paramString() {
         String gridColorString = (gridColor != null ?

@@ -6084,11 +6084,11 @@
 // Printing Support
 /////////////////
 
     /**
      * A convenience method that displays a printing dialog, and then prints
-     * this <code>JTable</code> in mode <code>PrintMode.FIT_WIDTH</code>,
+     * this {@code JTable} in mode {@code PrintMode.FIT_WIDTH},
      * with no header or footer text. A modal progress dialog, with an abort
      * option, will be shown for the duration of printing.
      * <p>
      * Note: In headless mode, no dialogs are shown and printing
      * occurs on the default printer.

@@ -6109,11 +6109,11 @@
         return print(PrintMode.FIT_WIDTH);
     }
 
     /**
      * A convenience method that displays a printing dialog, and then prints
-     * this <code>JTable</code> in the given printing mode,
+     * this {@code JTable} in the given printing mode,
      * with no header or footer text. A modal progress dialog, with an abort
      * option, will be shown for the duration of printing.
      * <p>
      * Note: In headless mode, no dialogs are shown and printing
      * occurs on the default printer.

@@ -6135,22 +6135,22 @@
         return print(printMode, null, null);
     }
 
     /**
      * A convenience method that displays a printing dialog, and then prints
-     * this <code>JTable</code> in the given printing mode,
+     * this {@code JTable} in the given printing mode,
      * with the specified header and footer text. A modal progress dialog,
      * with an abort option, will be shown for the duration of printing.
      * <p>
      * Note: In headless mode, no dialogs are shown and printing
      * occurs on the default printer.
      *
      * @param  printMode        the printing mode that the printable should use
-     * @param  headerFormat     a <code>MessageFormat</code> specifying the text
+     * @param  headerFormat     a {@code MessageFormat} specifying the text
      *                          to be used in printing a header,
      *                          or null for none
-     * @param  footerFormat     a <code>MessageFormat</code> specifying the text
+     * @param  footerFormat     a {@code MessageFormat} specifying the text
      *                          to be used in printing a footer,
      *                          or null for none
      * @return true, unless printing is cancelled by the user
      * @throws SecurityException if this thread is not allowed to
      *                           initiate a print job request

@@ -6176,26 +6176,26 @@
      * {@link #print(JTable.PrintMode, MessageFormat, MessageFormat,
      * boolean, PrintRequestAttributeSet, boolean, PrintService) print}
      * method, with the default printer specified as the print service.
      *
      * @param  printMode        the printing mode that the printable should use
-     * @param  headerFormat     a <code>MessageFormat</code> specifying the text
+     * @param  headerFormat     a {@code MessageFormat} specifying the text
      *                          to be used in printing a header,
-     *                          or <code>null</code> for none
-     * @param  footerFormat     a <code>MessageFormat</code> specifying the text
+     *                          or {@code null} for none
+     * @param  footerFormat     a {@code MessageFormat} specifying the text
      *                          to be used in printing a footer,
-     *                          or <code>null</code> for none
+     *                          or {@code null} for none
      * @param  showPrintDialog  whether or not to display a print dialog
-     * @param  attr             a <code>PrintRequestAttributeSet</code>
+     * @param  attr             a {@code PrintRequestAttributeSet}
      *                          specifying any printing attributes,
-     *                          or <code>null</code> for none
+     *                          or {@code null} for none
      * @param  interactive      whether or not to print in an interactive mode
      * @return true, unless printing is cancelled by the user
      * @throws HeadlessException if the method is asked to show a printing
      *                           dialog or run interactively, and
-     *                           <code>GraphicsEnvironment.isHeadless</code>
-     *                           returns <code>true</code>
+     *                           {@code GraphicsEnvironment.isHeadless}
+     *                           returns {@code true}
      * @throws SecurityException if this thread is not allowed to
      *                           initiate a print job request
      * @throws PrinterException if an error in the print system causes the job
      *                          to be aborted
      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,

@@ -6220,77 +6220,77 @@
                      interactive,
                      null);
     }
 
     /**
-     * Prints this <code>JTable</code>. Takes steps that the majority of
-     * developers would take in order to print a <code>JTable</code>.
-     * In short, it prepares the table, calls <code>getPrintable</code> to
-     * fetch an appropriate <code>Printable</code>, and then sends it to the
+     * Prints this {@code JTable}. Takes steps that the majority of
+     * developers would take in order to print a {@code JTable}.
+     * In short, it prepares the table, calls {@code getPrintable} to
+     * fetch an appropriate {@code Printable}, and then sends it to the
      * printer.
      * <p>
-     * A <code>boolean</code> parameter allows you to specify whether or not
+     * A {@code boolean} parameter allows you to specify whether or not
      * a printing dialog is displayed to the user. When it is, the user may
      * use the dialog to change the destination printer or printing attributes,
      * or even to cancel the print. Another two parameters allow for a
-     * <code>PrintService</code> and printing attributes to be specified.
+     * {@code PrintService} and printing attributes to be specified.
      * These parameters can be used either to provide initial values for the
      * print dialog, or to specify values when the dialog is not shown.
      * <p>
-     * A second <code>boolean</code> parameter allows you to specify whether
-     * or not to perform printing in an interactive mode. If <code>true</code>,
+     * A second {@code boolean} parameter allows you to specify whether
+     * or not to perform printing in an interactive mode. If {@code true},
      * a modal progress dialog, with an abort option, is displayed for the
      * duration of printing . This dialog also prevents any user action which
      * may affect the table. However, it can not prevent the table from being
      * modified by code (for example, another thread that posts updates using
-     * <code>SwingUtilities.invokeLater</code>). It is therefore the
+     * {@code SwingUtilities.invokeLater}). It is therefore the
      * responsibility of the developer to ensure that no other code modifies
      * the table in any way during printing (invalid modifications include
      * changes in: size, renderers, or underlying data). Printing behavior is
      * undefined when the table is changed during printing.
      * <p>
-     * If <code>false</code> is specified for this parameter, no dialog will
+     * If {@code false} is specified for this parameter, no dialog will
      * be displayed and printing will begin immediately on the event-dispatch
      * thread. This blocks any other events, including repaints, from being
      * processed until printing is complete. Although this effectively prevents
      * the table from being changed, it doesn't provide a good user experience.
-     * For this reason, specifying <code>false</code> is only recommended when
+     * For this reason, specifying {@code false} is only recommended when
      * printing from an application with no visible GUI.
      * <p>
      * Note: Attempting to show the printing dialog or run interactively, while
-     * in headless mode, will result in a <code>HeadlessException</code>.
+     * in headless mode, will result in a {@code HeadlessException}.
      * <p>
      * Before fetching the printable, this method will gracefully terminate
      * editing, if necessary, to prevent an editor from showing in the printed
-     * result. Additionally, <code>JTable</code> will prepare its renderers
+     * result. Additionally, {@code JTable} will prepare its renderers
      * during printing such that selection and focus are not indicated.
      * As far as customizing further how the table looks in the printout,
      * developers can provide custom renderers or paint code that conditionalize
      * on the value of {@link javax.swing.JComponent#isPaintingForPrint()}.
      * <p>
      * See {@link #getPrintable} for more description on how the table is
      * printed.
      *
      * @param  printMode        the printing mode that the printable should use
-     * @param  headerFormat     a <code>MessageFormat</code> specifying the text
+     * @param  headerFormat     a {@code MessageFormat} specifying the text
      *                          to be used in printing a header,
-     *                          or <code>null</code> for none
-     * @param  footerFormat     a <code>MessageFormat</code> specifying the text
+     *                          or {@code null} for none
+     * @param  footerFormat     a {@code MessageFormat} specifying the text
      *                          to be used in printing a footer,
-     *                          or <code>null</code> for none
+     *                          or {@code null} for none
      * @param  showPrintDialog  whether or not to display a print dialog
-     * @param  attr             a <code>PrintRequestAttributeSet</code>
+     * @param  attr             a {@code PrintRequestAttributeSet}
      *                          specifying any printing attributes,
-     *                          or <code>null</code> for none
+     *                          or {@code null} for none
      * @param  interactive      whether or not to print in an interactive mode
-     * @param  service          the destination <code>PrintService</code>,
-     *                          or <code>null</code> to use the default printer
+     * @param  service          the destination {@code PrintService},
+     *                          or {@code null} to use the default printer
      * @return true, unless printing is cancelled by the user
      * @throws HeadlessException if the method is asked to show a printing
      *                           dialog or run interactively, and
-     *                           <code>GraphicsEnvironment.isHeadless</code>
-     *                           returns <code>true</code>
+     *                           {@code GraphicsEnvironment.isHeadless}
+     *                           returns {@code true}
      * @throws  SecurityException if a security manager exists and its
      *          {@link java.lang.SecurityManager#checkPrintJobAccess}
      *          method disallows this thread from creating a print job request
      * @throws PrinterException if an error in the print system causes the job
      *                          to be aborted

@@ -6434,103 +6434,103 @@
 
         return true;
     }
 
     /**
-     * Return a <code>Printable</code> for use in printing this JTable.
+     * Return a {@code Printable} for use in printing this JTable.
      * <p>
      * This method is meant for those wishing to customize the default
-     * <code>Printable</code> implementation used by <code>JTable</code>'s
-     * <code>print</code> methods. Developers wanting simply to print the table
+     * {@code Printable} implementation used by {@code JTable}'s
+     * {@code print} methods. Developers wanting simply to print the table
      * should use one of those methods directly.
      * <p>
-     * The <code>Printable</code> can be requested in one of two printing modes.
+     * The {@code Printable} can be requested in one of two printing modes.
      * In both modes, it spreads table rows naturally in sequence across
      * multiple pages, fitting as many rows as possible per page.
-     * <code>PrintMode.NORMAL</code> specifies that the table be
+     * {@code PrintMode.NORMAL} specifies that the table be
      * printed at its current size. In this mode, there may be a need to spread
      * columns across pages in a similar manner to that of the rows. When the
      * need arises, columns are distributed in an order consistent with the
-     * table's <code>ComponentOrientation</code>.
-     * <code>PrintMode.FIT_WIDTH</code> specifies that the output be
+     * table's {@code ComponentOrientation}.
+     * {@code PrintMode.FIT_WIDTH} specifies that the output be
      * scaled smaller, if necessary, to fit the table's entire width
      * (and thereby all columns) on each page. Width and height are scaled
      * equally, maintaining the aspect ratio of the output.
      * <p>
-     * The <code>Printable</code> heads the portion of table on each page
-     * with the appropriate section from the table's <code>JTableHeader</code>,
+     * The {@code Printable} heads the portion of table on each page
+     * with the appropriate section from the table's {@code JTableHeader},
      * if it has one.
      * <p>
      * Header and footer text can be added to the output by providing
-     * <code>MessageFormat</code> arguments. The printing code requests
+     * {@code MessageFormat} arguments. The printing code requests
      * Strings from the formats, providing a single item which may be included
-     * in the formatted string: an <code>Integer</code> representing the current
+     * in the formatted string: an {@code Integer} representing the current
      * page number.
      * <p>
      * You are encouraged to read the documentation for
-     * <code>MessageFormat</code> as some characters, such as single-quote,
+     * {@code MessageFormat} as some characters, such as single-quote,
      * are special and need to be escaped.
      * <p>
-     * Here's an example of creating a <code>MessageFormat</code> that can be
+     * Here's an example of creating a {@code MessageFormat} that can be
      * used to print "Duke's Table: Page - " and the current page number:
      *
      * <pre>
      *     // notice the escaping of the single quote
      *     // notice how the page number is included with "{0}"
      *     MessageFormat format = new MessageFormat("Duke''s Table: Page - {0}");
      * </pre>
      * <p>
-     * The <code>Printable</code> constrains what it draws to the printable
+     * The {@code Printable} constrains what it draws to the printable
      * area of each page that it prints. Under certain circumstances, it may
      * find it impossible to fit all of a page's content into that area. In
      * these cases the output may be clipped, but the implementation
      * makes an effort to do something reasonable. Here are a few situations
      * where this is known to occur, and how they may be handled by this
      * particular implementation:
      * <ul>
      *   <li>In any mode, when the header or footer text is too wide to fit
      *       completely in the printable area -- print as much of the text as
      *       possible starting from the beginning, as determined by the table's
-     *       <code>ComponentOrientation</code>.
+     *       {@code ComponentOrientation}.
      *   <li>In any mode, when a row is too tall to fit in the
      *       printable area -- print the upper-most portion of the row
      *       and paint no lower border on the table.
-     *   <li>In <code>PrintMode.NORMAL</code> when a column
+     *   <li>In {@code PrintMode.NORMAL} when a column
      *       is too wide to fit in the printable area -- print the center
      *       portion of the column and leave the left and right borders
      *       off the table.
      * </ul>
      * <p>
-     * It is entirely valid for this <code>Printable</code> to be wrapped
+     * It is entirely valid for this {@code Printable} to be wrapped
      * inside another in order to create complex reports and documents. You may
      * even request that different pages be rendered into different sized
      * printable areas. The implementation must be prepared to handle this
      * (possibly by doing its layout calculations on the fly). However,
      * providing different heights to each page will likely not work well
-     * with <code>PrintMode.NORMAL</code> when it has to spread columns
+     * with {@code PrintMode.NORMAL} when it has to spread columns
      * across pages.
      * <p>
      * As far as customizing how the table looks in the printed result,
-     * <code>JTable</code> itself will take care of hiding the selection
+     * {@code JTable} itself will take care of hiding the selection
      * and focus during printing. For additional customizations, your
      * renderers or painting code can customize the look based on the value
      * of {@link javax.swing.JComponent#isPaintingForPrint()}
      * <p>
      * Also, <i>before</i> calling this method you may wish to <i>first</i>
      * modify the state of the table, such as to cancel cell editing or
      * have the user size the table appropriately. However, you must not
-     * modify the state of the table <i>after</i> this <code>Printable</code>
+     * modify the state of the table <i>after</i> this {@code Printable}
      * has been fetched (invalid modifications include changes in size or
-     * underlying data). The behavior of the returned <code>Printable</code>
+     * underlying data). The behavior of the returned {@code Printable}
      * is undefined once the table has been changed.
      *
      * @param  printMode     the printing mode that the printable should use
-     * @param  headerFormat  a <code>MessageFormat</code> specifying the text to
+     * @param  headerFormat  a {@code MessageFormat} specifying the text to
      *                       be used in printing a header, or null for none
-     * @param  footerFormat  a <code>MessageFormat</code> specifying the text to
+     * @param  footerFormat  a {@code MessageFormat} specifying the text to
      *                       be used in printing a footer, or null for none
-     * @return a <code>Printable</code> for printing this JTable
+     * @return a {@code Printable} for printing this JTable
      * @see #print(JTable.PrintMode, MessageFormat, MessageFormat,
      *             boolean, PrintRequestAttributeSet, boolean)
      * @see Printable
      * @see PrinterJob
      *

@@ -6543,33 +6543,33 @@
         return new TablePrintable(this, printMode, headerFormat, footerFormat);
     }
 
 
     /**
-     * A <code>Printable</code> implementation that wraps another
-     * <code>Printable</code>, making it safe for printing on another thread.
+     * A {@code Printable} implementation that wraps another
+     * {@code Printable}, making it safe for printing on another thread.
      */
     private class ThreadSafePrintable implements Printable {
 
-        /** The delegate <code>Printable</code>. */
+        /** The delegate {@code Printable}. */
         private Printable printDelegate;
 
         /**
          * To communicate any return value when delegating.
          */
         private int retVal;
 
         /**
-         * To communicate any <code>Throwable</code> when delegating.
+         * To communicate any {@code Throwable} when delegating.
          */
         private Throwable retThrowable;
 
         /**
-         * Construct a <code>ThreadSafePrintable</code> around the given
+         * Construct a {@code ThreadSafePrintable} around the given
          * delegate.
          *
-         * @param printDelegate the <code>Printable</code> to delegate to
+         * @param printDelegate the {@code Printable} to delegate to
          */
         public ThreadSafePrintable(Printable printDelegate) {
             this.printDelegate = printDelegate;
         }
 

@@ -6667,20 +6667,20 @@
     // *** should also implement AccessibleSelection?
     // *** and what's up with keyboard navigation/manipulation?
     //
     /**
      * This class implements accessibility support for the
-     * <code>JTable</code> class.  It provides an implementation of the
+     * {@code JTable} class.  It provides an implementation of the
      * Java Accessibility API appropriate to table user-interface elements.
      * <p>
      * <strong>Warning:</strong>
      * Serialized objects of this class will not be compatible with
      * future Swing releases. The current serialization support is
      * appropriate for short term storage or RMI between applications running
      * the same version of Swing.  As of 1.4, support for long term storage
      * of all JavaBeans&trade;
-     * has been added to the <code>java.beans</code> package.
+     * has been added to the {@code java.beans} package.
      * Please see {@link java.beans.XMLEncoder}.
      */
     @SuppressWarnings("serial") // Same-version serialization only
     protected class AccessibleJTable extends AccessibleJComponent
     implements AccessibleSelection, ListSelectionListener, TableModelListener,

@@ -7117,18 +7117,18 @@
         public AccessibleRole getAccessibleRole() {
             return AccessibleRole.TABLE;
         }
 
         /**
-         * Returns the <code>Accessible</code> child, if one exists,
-         * contained at the local coordinate <code>Point</code>.
+         * Returns the {@code Accessible} child, if one exists,
+         * contained at the local coordinate {@code Point}.
          *
          * @param p the point defining the top-left corner of the
-         *    <code>Accessible</code>, given in the coordinate space
+         *    {@code Accessible}, given in the coordinate space
          *    of the object's parent
-         * @return the <code>Accessible</code>, if it exists,
-         *    at the specified location; else <code>null</code>
+         * @return the {@code Accessible}, if it exists,
+         *    at the specified location; else {@code null}
          */
         public Accessible getAccessibleAt(Point p) {
             int column = columnAtPoint(p);
             int row = rowAtPoint(p);
 

@@ -7148,21 +7148,21 @@
             return null;
         }
 
         /**
          * Returns the number of accessible children in the object.  If all
-         * of the children of this object implement <code>Accessible</code>,
+         * of the children of this object implement {@code Accessible},
          * then this method should return the number of children of this object.
          *
          * @return the number of accessible children in the object
          */
         public int getAccessibleChildrenCount() {
             return (JTable.this.getColumnCount() * JTable.this.getRowCount());
         }
 
         /**
-         * Returns the nth <code>Accessible</code> child of the object.
+         * Returns the nth {@code Accessible} child of the object.
          *
          * @param i zero-based index of child
          * @return the nth Accessible child of the object
          */
         public Accessible getAccessibleChild(int i) {

@@ -7189,11 +7189,11 @@
         }
 
     // AccessibleSelection support
 
         /**
-         * Returns the number of <code>Accessible</code> children
+         * Returns the number of {@code Accessible} children
          * currently selected.
          * If no children are selected, the return value will be 0.
          *
          * @return the number of items currently selected
          */

@@ -7225,15 +7225,15 @@
                 }
             }
         }
 
         /**
-         * Returns an <code>Accessible</code> representing the
+         * Returns an {@code Accessible} representing the
          * specified selected child in the object.  If there
          * isn't a selection, or there are fewer children selected
          * than the integer passed in, the return
-         * value will be <code>null</code>.
+         * value will be {@code null}.
          * <p>Note that the index represents the i-th selected child, which
          * is different from the i-th child.
          *
          * @param i the zero-based index of selected children
          * @return the i-th selected child

@@ -7359,29 +7359,29 @@
 
         /**
          * Determines if the current child of this object is selected.
          *
          * @param i the zero-based index of the child in this
-         *    <code>Accessible</code> object
+         *    {@code Accessible} object
          * @return true if the current child of this object is selected
          * @see AccessibleContext#getAccessibleChild
          */
         public boolean isAccessibleChildSelected(int i) {
             int column = getAccessibleColumnAtIndex(i);
             int row = getAccessibleRowAtIndex(i);
             return JTable.this.isCellSelected(row, column);
         }
 
         /**
-         * Adds the specified <code>Accessible</code> child of the
+         * Adds the specified {@code Accessible} child of the
          * object to the object's selection.  If the object supports
          * multiple selections, the specified child is added to
          * any existing selection, otherwise
          * it replaces any existing selection in the object.  If the
          * specified child is already selected, this method has no effect.
          * <p>
-         * This method only works on <code>JTable</code>s which have
+         * This method only works on {@code JTable}s which have
          * individual cell selection enabled.
          *
          * @param i the zero-based index of the child
          * @see AccessibleContext#getAccessibleChild
          */

@@ -7395,11 +7395,11 @@
         /**
          * Removes the specified child of the object from the object's
          * selection.  If the specified item isn't currently selected, this
          * method has no effect.
          * <p>
-         * This method only works on <code>JTables</code> which have
+         * This method only works on {@code JTables} which have
          * individual cell selection enabled.
          *
          * @param i the zero-based index of the child
          * @see AccessibleContext#getAccessibleChild
          */

@@ -7420,11 +7420,11 @@
             JTable.this.clearSelection();
         }
 
         /**
          * Causes every child of the object to be selected, but only
-         * if the <code>JTable</code> supports multiple selections,
+         * if the {@code JTable} supports multiple selections,
          * and if individual cell selection is enabled.
          */
         public void selectAllAccessibleSelection() {
             if (JTable.this.cellSelectionEnabled) {
                 JTable.this.selectAll();

@@ -7478,14 +7478,14 @@
         private Accessible summary;
         private Accessible [] rowDescription;
         private Accessible [] columnDescription;
 
         /**
-         * Gets the <code>AccessibleTable</code> associated with this
+         * Gets the {@code AccessibleTable} associated with this
          * object.  In the implementation of the Java Accessibility
          * API for this class, return this object, which is responsible
-         * for implementing the <code>AccessibleTables</code> interface
+         * for implementing the {@code AccessibleTables} interface
          * on behalf of itself.
          *
          * @return this object
          * @since 1.3
          */

@@ -7556,75 +7556,75 @@
         public int getAccessibleColumnCount() {
             return JTable.this.getColumnCount();
         }
 
         /*
-         * Returns the <code>Accessible</code> at a specified row
+         * Returns the {@code Accessible} at a specified row
          * and column in the table.
          *
          * @param r zero-based row of the table
          * @param c zero-based column of the table
-         * @return the <code>Accessible</code> at the specified row and column
+         * @return the {@code Accessible} at the specified row and column
          * in the table
          */
         public Accessible getAccessibleAt(int r, int c) {
             return getAccessibleChild((r * getAccessibleColumnCount()) + c);
         }
 
         /**
-         * Returns the number of rows occupied by the <code>Accessible</code>
+         * Returns the number of rows occupied by the {@code Accessible}
          * at a specified row and column in the table.
          *
-         * @return the number of rows occupied by the <code>Accessible</code>
+         * @return the number of rows occupied by the {@code Accessible}
          *     at a specified row and column in the table
          * @since 1.3
          */
         public int getAccessibleRowExtentAt(int r, int c) {
             return 1;
         }
 
         /**
          * Returns the number of columns occupied by the
-         * <code>Accessible</code> at a given (row, column).
+         * {@code Accessible} at a given (row, column).
          *
-         * @return the number of columns occupied by the <code>Accessible</code>
+         * @return the number of columns occupied by the {@code Accessible}
          *     at a specified row and column in the table
          * @since 1.3
          */
         public int getAccessibleColumnExtentAt(int r, int c) {
             return 1;
         }
 
         /**
-         * Returns the row headers as an <code>AccessibleTable</code>.
+         * Returns the row headers as an {@code AccessibleTable}.
          *
-         * @return an <code>AccessibleTable</code> representing the row
+         * @return an {@code AccessibleTable} representing the row
          * headers
          * @since 1.3
          */
         public AccessibleTable getAccessibleRowHeader() {
             // row headers are not supported
             return null;
         }
 
         /**
-         * Sets the row headers as an <code>AccessibleTable</code>.
+         * Sets the row headers as an {@code AccessibleTable}.
          *
-         * @param a an <code>AccessibleTable</code> representing the row
+         * @param a an {@code AccessibleTable} representing the row
          *  headers
          * @since 1.3
          */
         public void setAccessibleRowHeader(AccessibleTable a) {
             // row headers are not supported
         }
 
         /**
-         * Returns the column headers as an <code>AccessibleTable</code>.
+         * Returns the column headers as an {@code AccessibleTable}.
          *
-         *  @return an <code>AccessibleTable</code> representing the column
-         *          headers, or <code>null</code> if the table header is
-         *          <code>null</code>
+         *  @return an {@code AccessibleTable} representing the column
+         *          headers, or {@code null} if the table header is
+         *          {@code null}
          * @since 1.3
          */
         public AccessibleTable getAccessibleColumnHeader() {
             JTableHeader header = JTable.this.getTableHeader();
             return header == null ? null : new AccessibleTableHeader(header);

@@ -7855,13 +7855,13 @@
             public int [] getSelectedAccessibleColumns() { return new int[0]; }
         }
 
 
         /**
-         * Sets the column headers as an <code>AccessibleTable</code>.
+         * Sets the column headers as an {@code AccessibleTable}.
          *
-         * @param a an <code>AccessibleTable</code> representing the
+         * @param a an {@code AccessibleTable} representing the
          * column headers
          * @since 1.3
          */
         public void setAccessibleColumnHeader(AccessibleTable a) {
             // XXX not implemented

@@ -8058,11 +8058,11 @@
             private int row;
             private int column;
             private int index;
 
             /**
-             *  Constructs an <code>AccessibleJTableHeaderEntry</code>.
+             *  Constructs an {@code AccessibleJTableHeaderEntry}.
              *
              * @param t a {@code JTable}
              * @param r an {@code int} specifying a row
              * @param c an {@code int} specifying a column
              * @param i an {@code int} specifying the index to this cell

@@ -8075,27 +8075,27 @@
                 index = i;
                 this.setAccessibleParent(parent);
             }
 
             /**
-             * Gets the <code>AccessibleContext</code> associated with this
+             * Gets the {@code AccessibleContext} associated with this
              * component. In the implementation of the Java Accessibility
              * API for this class, return this object, which is its own
-             * <code>AccessibleContext</code>.
+             * {@code AccessibleContext}.
              *
              * @return this object
              */
             public AccessibleContext getAccessibleContext() {
                 return this;
             }
 
             /**
              * Gets the AccessibleContext for the table cell renderer.
              *
-             * @return the <code>AccessibleContext</code> for the table
+             * @return the {@code AccessibleContext} for the table
              * cell renderer if one exists;
-             * otherwise, returns <code>null</code>.
+             * otherwise, returns {@code null}.
              * @since 1.6
              */
             protected AccessibleContext getCurrentAccessibleContext() {
                 TableColumn aColumn = getColumnModel().getColumn(column);
                 TableCellRenderer renderer = aColumn.getCellRenderer();

@@ -8115,11 +8115,11 @@
 
             /**
              * Gets the table cell renderer component.
              *
              * @return the table cell renderer component if one exists;
-             * otherwise, returns <code>null</code>.
+             * otherwise, returns {@code null}.
              * @since 1.6
              */
             protected Component getCurrentComponent() {
                 TableColumn aColumn = getColumnModel().getColumn(column);
                 TableCellRenderer renderer = aColumn.getCellRenderer();

@@ -8135,11 +8135,11 @@
         // AccessibleContext methods
 
             /**
              * Gets the accessible name of this object.
              *
-             * @return the localized name of the object; <code>null</code>
+             * @return the localized name of the object; {@code null}
              *     if this object does not have a name
              */
             public String getAccessibleName() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -8176,11 +8176,11 @@
             //
             /**
              * Gets the accessible description of this object.
              *
              * @return the localized description of the object;
-             *     <code>null</code> if this object does not have
+             *     {@code null} if this object does not have
              *     a description
              */
             public String getAccessibleDescription() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -8205,11 +8205,11 @@
             }
 
             /**
              * Gets the role of this object.
              *
-             * @return an instance of <code>AccessibleRole</code>
+             * @return an instance of {@code AccessibleRole}
              *      describing the role of the object
              * @see AccessibleRole
              */
             public AccessibleRole getAccessibleRole() {
                 AccessibleContext ac = getCurrentAccessibleContext();

@@ -8221,11 +8221,11 @@
             }
 
             /**
              * Gets the state set of this object.
              *
-             * @return an instance of <code>AccessibleStateSet</code>
+             * @return an instance of {@code AccessibleStateSet}
              *     containing the current state set of the object
              * @see AccessibleState
              */
             public AccessibleStateSet getAccessibleStateSet() {
                 AccessibleContext ac = getCurrentAccessibleContext();

@@ -8257,15 +8257,15 @@
                 as.add(AccessibleState.TRANSIENT);
                 return as;
             }
 
             /**
-             * Gets the <code>Accessible</code> parent of this object.
+             * Gets the {@code Accessible} parent of this object.
              *
              * @return the Accessible parent of this object;
-             *     <code>null</code> if this object does not
-             *     have an <code>Accessible</code> parent
+             *     {@code null} if this object does not
+             *     have an {@code Accessible} parent
              */
             public Accessible getAccessibleParent() {
                 return parent;
             }
 

@@ -8293,15 +8293,15 @@
                     return 0;
                 }
             }
 
             /**
-             * Returns the specified <code>Accessible</code> child of the
+             * Returns the specified {@code Accessible} child of the
              * object.
              *
              * @param i zero-based index of child
-             * @return the <code>Accessible</code> child of the object
+             * @return the {@code Accessible} child of the object
              */
             public Accessible getAccessibleChild(int i) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {
                     Accessible accessibleChild = ac.getAccessibleChild(i);

@@ -8318,11 +8318,11 @@
              * is returned.
              *
              * @return this component's locale; if this component does
              *    not have a locale, the locale of its parent is returned
              * @exception IllegalComponentStateException if the
-             *    <code>Component</code> does not have its own locale
+             *    {@code Component} does not have its own locale
              *    and has not yet been added to a containment hierarchy
              *    such that the locale can be determined from the
              *    containing parent
              * @see #setLocale
              */

@@ -8334,14 +8334,14 @@
                     return null;
                 }
             }
 
             /**
-             * Adds a <code>PropertyChangeListener</code> to the listener list.
+             * Adds a {@code PropertyChangeListener} to the listener list.
              * The listener is registered for all properties.
              *
-             * @param l  the <code>PropertyChangeListener</code>
+             * @param l  the {@code PropertyChangeListener}
              *     to be added
              */
             public void addPropertyChangeListener(PropertyChangeListener l) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -8350,15 +8350,15 @@
                     super.addPropertyChangeListener(l);
                 }
             }
 
             /**
-             * Removes a <code>PropertyChangeListener</code> from the
-             * listener list. This removes a <code>PropertyChangeListener</code>
+             * Removes a {@code PropertyChangeListener} from the
+             * listener list. This removes a {@code PropertyChangeListener}
              * that was registered for all properties.
              *
-             * @param l  the <code>PropertyChangeListener</code>
+             * @param l  the {@code PropertyChangeListener}
              *    to be removed
              */
             public void removePropertyChangeListener(PropertyChangeListener l) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -8367,56 +8367,56 @@
                     super.removePropertyChangeListener(l);
                 }
             }
 
             /**
-             * Gets the <code>AccessibleAction</code> associated with this
-             * object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleAction} associated with this
+             * object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleAction</code>, or <code>null</code>
+             * @return the {@code AccessibleAction}, or {@code null}
              */
             public AccessibleAction getAccessibleAction() {
                 return getCurrentAccessibleContext().getAccessibleAction();
             }
 
             /**
-             * Gets the <code>AccessibleComponent</code> associated with
-             * this object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleComponent} associated with
+             * this object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleComponent</code>, or
-             *    <code>null</code>
+             * @return the {@code AccessibleComponent}, or
+             *    {@code null}
              */
             public AccessibleComponent getAccessibleComponent() {
                 return this; // to override getBounds()
             }
 
             /**
-             * Gets the <code>AccessibleSelection</code> associated with
-             * this object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleSelection} associated with
+             * this object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleSelection</code>, or
-             *    <code>null</code>
+             * @return the {@code AccessibleSelection}, or
+             *    {@code null}
              */
             public AccessibleSelection getAccessibleSelection() {
                 return getCurrentAccessibleContext().getAccessibleSelection();
             }
 
             /**
-             * Gets the <code>AccessibleText</code> associated with this
-             * object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleText} associated with this
+             * object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleText</code>, or <code>null</code>
+             * @return the {@code AccessibleText}, or {@code null}
              */
             public AccessibleText getAccessibleText() {
                 return getCurrentAccessibleContext().getAccessibleText();
             }
 
             /**
-             * Gets the <code>AccessibleValue</code> associated with
-             * this object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleValue} associated with
+             * this object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleValue</code>, or <code>null</code>
+             * @return the {@code AccessibleValue}, or {@code null}
              */
             public AccessibleValue getAccessibleValue() {
                 return getCurrentAccessibleContext().getAccessibleValue();
             }
 

@@ -8425,11 +8425,11 @@
 
             /**
              * Gets the background color of this object.
              *
              * @return the background color, if supported, of the object;
-             *     otherwise, <code>null</code>
+             *     otherwise, {@code null}
              */
             public Color getBackground() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getBackground();

@@ -8444,11 +8444,11 @@
             }
 
             /**
              * Sets the background color of this object.
              *
-             * @param c the new <code>Color</code> for the background
+             * @param c the new {@code Color} for the background
              */
             public void setBackground(Color c) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setBackground(c);

@@ -8462,11 +8462,11 @@
 
             /**
              * Gets the foreground color of this object.
              *
              * @return the foreground color, if supported, of the object;
-             *     otherwise, <code>null</code>
+             *     otherwise, {@code null}
              */
             public Color getForeground() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getForeground();

@@ -8481,11 +8481,11 @@
             }
 
             /**
              * Sets the foreground color of this object.
              *
-             * @param c the new <code>Color</code> for the foreground
+             * @param c the new {@code Color} for the foreground
              */
             public void setForeground(Color c) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setForeground(c);

@@ -8496,14 +8496,14 @@
                     }
                 }
             }
 
             /**
-             * Gets the <code>Cursor</code> of this object.
+             * Gets the {@code Cursor} of this object.
              *
-             * @return the <code>Cursor</code>, if supported,
-             *    of the object; otherwise, <code>null</code>
+             * @return the {@code Cursor}, if supported,
+             *    of the object; otherwise, {@code null}
              */
             public Cursor getCursor() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getCursor();

@@ -8521,13 +8521,13 @@
                     }
                 }
             }
 
             /**
-             * Sets the <code>Cursor</code> of this object.
+             * Sets the {@code Cursor} of this object.
              *
-             * @param c the new <code>Cursor</code> for the object
+             * @param c the new {@code Cursor} for the object
              */
             public void setCursor(Cursor c) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setCursor(c);

@@ -8538,14 +8538,14 @@
                     }
                 }
             }
 
             /**
-             * Gets the <code>Font</code> of this object.
+             * Gets the {@code Font} of this object.
              *
-             * @return the <code>Font</code>,if supported,
-             *   for the object; otherwise, <code>null</code>
+             * @return the {@code Font},if supported,
+             *   for the object; otherwise, {@code null}
              */
             public Font getFont() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getFont();

@@ -8558,13 +8558,13 @@
                     }
                 }
             }
 
             /**
-             * Sets the <code>Font</code> of this object.
+             * Sets the {@code Font} of this object.
              *
-             * @param f the new <code>Font</code> for the object
+             * @param f the new {@code Font} for the object
              */
             public void setFont(Font f) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setFont(f);

@@ -8575,15 +8575,15 @@
                     }
                 }
             }
 
             /**
-             * Gets the <code>FontMetrics</code> of this object.
+             * Gets the {@code FontMetrics} of this object.
              *
-             * @param f the <code>Font</code>
-             * @return the <code>FontMetrics</code> object, if supported;
-             *    otherwise <code>null</code>
+             * @param f the {@code Font}
+             * @return the {@code FontMetrics} object, if supported;
+             *    otherwise {@code null}
              * @see #getFont
              */
             public FontMetrics getFontMetrics(Font f) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {

@@ -8637,11 +8637,11 @@
             /**
              * Determines if this object is visible.  Note: this means that the
              * object intends to be visible; however, it may not in fact be
              * showing on the screen because one of the objects that this object
              * is contained by is not visible.  To determine if an object is
-             * showing on the screen, use <code>isShowing</code>.
+             * showing on the screen, use {@code isShowing}.
              *
              * @return true if object is visible; otherwise, false
              */
             public boolean isVisible() {
                 AccessibleContext ac = getCurrentAccessibleContext();

@@ -8708,13 +8708,13 @@
              * Checks whether the specified point is within this
              * object's bounds, where the point's x and y coordinates
              * are defined to be relative to the coordinate system of
              * the object.
              *
-             * @param p the <code>Point</code> relative to the
+             * @param p the {@code Point} relative to the
              *    coordinate system of the object
-             * @return true if object contains <code>Point</code>;
+             * @return true if object contains {@code Point};
              *    otherwise false
              */
             public boolean contains(Point p) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {

@@ -8733,11 +8733,11 @@
 
             /**
              * Returns the location of the object on the screen.
              *
              * @return location of object on screen -- can be
-             *    <code>null</code> if this object is not on the screen
+             *    {@code null} if this object is not on the screen
              */
             public Point getLocationOnScreen() {
                 if (parent != null && parent.isShowing()) {
                     Point parentLocation = parent.getLocationOnScreen();
                     Point componentLocation = getLocation();

@@ -8751,13 +8751,13 @@
             /**
              * Gets the location of the object relative to the parent
              * in the form of a point specifying the object's
              * top-left corner in the screen's coordinate space.
              *
-             * @return an instance of <code>Point</code> representing
+             * @return an instance of {@code Point} representing
              *    the top-left corner of the object's bounds in the
-             *    coordinate space of the screen; <code>null</code> if
+             *    coordinate space of the screen; {@code null} if
              *    this object or its parent are not on the screen
              */
             public Point getLocation() {
                 if (parent != null) {
                     Rectangle r = parent.getCellRect(row, column, false);

@@ -8893,11 +8893,11 @@
             private int column;
             private JTableHeader parent;
             private Component rendererComponent;
 
             /**
-             * Constructs an <code>AccessibleJTableHeaderEntry</code> instance.
+             * Constructs an {@code AccessibleJTableHeaderEntry} instance.
              *
              * @param row header cell row index
              * @param column header cell column index
              * @param parent header cell parent
              * @param rendererComponent component that renders the header cell

@@ -8911,14 +8911,14 @@
                 this.rendererComponent = rendererComponent;
                 this.setAccessibleParent(parent);
             }
 
             /**
-             * Gets the <code>AccessibleContext</code> associated with this
+             * Gets the {@code AccessibleContext} associated with this
              * component. In the implementation of the Java Accessibility
              * API for this class, return this object, which is its own
-             * <code>AccessibleContext</code>.
+             * {@code AccessibleContext}.
              *
              * @return this object
              */
             public AccessibleContext getAccessibleContext() {
                 return this;

@@ -8942,11 +8942,11 @@
             // AccessibleContext methods ==========
 
             /**
              * Gets the accessible name of this object.
              *
-             * @return the localized name of the object; <code>null</code>
+             * @return the localized name of the object; {@code null}
              *     if this object does not have a name
              */
             public String getAccessibleName() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -8978,11 +8978,11 @@
 
             /**
              * Gets the accessible description of this object.
              *
              * @return the localized description of the object;
-             *     <code>null</code> if this object does not have
+             *     {@code null} if this object does not have
              *     a description
              */
             public String getAccessibleDescription() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -9007,11 +9007,11 @@
             }
 
             /**
              * Gets the role of this object.
              *
-             * @return an instance of <code>AccessibleRole</code>
+             * @return an instance of {@code AccessibleRole}
              *      describing the role of the object
              * @see AccessibleRole
              */
             public AccessibleRole getAccessibleRole() {
                 AccessibleContext ac = getCurrentAccessibleContext();

@@ -9023,11 +9023,11 @@
             }
 
             /**
              * Gets the state set of this object.
              *
-             * @return an instance of <code>AccessibleStateSet</code>
+             * @return an instance of {@code AccessibleStateSet}
              *     containing the current state set of the object
              * @see AccessibleState
              */
             public AccessibleStateSet getAccessibleStateSet() {
                 AccessibleContext ac = getCurrentAccessibleContext();

@@ -9059,15 +9059,15 @@
                 as.add(AccessibleState.TRANSIENT);
                 return as;
             }
 
             /**
-             * Gets the <code>Accessible</code> parent of this object.
+             * Gets the {@code Accessible} parent of this object.
              *
              * @return the Accessible parent of this object;
-             *     <code>null</code> if this object does not
-             *     have an <code>Accessible</code> parent
+             *     {@code null} if this object does not
+             *     have an {@code Accessible} parent
              */
             public Accessible getAccessibleParent() {
                 return parent;
             }
 

@@ -9095,15 +9095,15 @@
                     return 0;
                 }
             }
 
             /**
-             * Returns the specified <code>Accessible</code> child of the
+             * Returns the specified {@code Accessible} child of the
              * object.
              *
              * @param i zero-based index of child
-             * @return the <code>Accessible</code> child of the object
+             * @return the {@code Accessible} child of the object
              */
             public Accessible getAccessibleChild(int i) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {
                     Accessible accessibleChild = ac.getAccessibleChild(i);

@@ -9120,11 +9120,11 @@
              * is returned.
              *
              * @return this component's locale; if this component does
              *    not have a locale, the locale of its parent is returned
              * @exception IllegalComponentStateException if the
-             *    <code>Component</code> does not have its own locale
+             *    {@code Component} does not have its own locale
              *    and has not yet been added to a containment hierarchy
              *    such that the locale can be determined from the
              *    containing parent
              * @see #setLocale
              */

@@ -9136,14 +9136,14 @@
                     return null;
                 }
             }
 
             /**
-             * Adds a <code>PropertyChangeListener</code> to the listener list.
+             * Adds a {@code PropertyChangeListener} to the listener list.
              * The listener is registered for all properties.
              *
-             * @param l  the <code>PropertyChangeListener</code>
+             * @param l  the {@code PropertyChangeListener}
              *     to be added
              */
             public void addPropertyChangeListener(PropertyChangeListener l) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -9152,15 +9152,15 @@
                     super.addPropertyChangeListener(l);
                 }
             }
 
             /**
-             * Removes a <code>PropertyChangeListener</code> from the
-             * listener list. This removes a <code>PropertyChangeListener</code>
+             * Removes a {@code PropertyChangeListener} from the
+             * listener list. This removes a {@code PropertyChangeListener}
              * that was registered for all properties.
              *
-             * @param l  the <code>PropertyChangeListener</code>
+             * @param l  the {@code PropertyChangeListener}
              *    to be removed
              */
             public void removePropertyChangeListener(PropertyChangeListener l) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac != null) {

@@ -9169,56 +9169,56 @@
                     super.removePropertyChangeListener(l);
                 }
             }
 
             /**
-             * Gets the <code>AccessibleAction</code> associated with this
-             * object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleAction} associated with this
+             * object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleAction</code>, or <code>null</code>
+             * @return the {@code AccessibleAction}, or {@code null}
              */
             public AccessibleAction getAccessibleAction() {
                 return getCurrentAccessibleContext().getAccessibleAction();
             }
 
             /**
-             * Gets the <code>AccessibleComponent</code> associated with
-             * this object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleComponent} associated with
+             * this object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleComponent</code>, or
-             *    <code>null</code>
+             * @return the {@code AccessibleComponent}, or
+             *    {@code null}
              */
             public AccessibleComponent getAccessibleComponent() {
                 return this; // to override getBounds()
             }
 
             /**
-             * Gets the <code>AccessibleSelection</code> associated with
-             * this object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleSelection} associated with
+             * this object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleSelection</code>, or
-             *    <code>null</code>
+             * @return the {@code AccessibleSelection}, or
+             *    {@code null}
              */
             public AccessibleSelection getAccessibleSelection() {
                 return getCurrentAccessibleContext().getAccessibleSelection();
             }
 
             /**
-             * Gets the <code>AccessibleText</code> associated with this
-             * object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleText} associated with this
+             * object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleText</code>, or <code>null</code>
+             * @return the {@code AccessibleText}, or {@code null}
              */
             public AccessibleText getAccessibleText() {
                 return getCurrentAccessibleContext().getAccessibleText();
             }
 
             /**
-             * Gets the <code>AccessibleValue</code> associated with
-             * this object if one exists.  Otherwise returns <code>null</code>.
+             * Gets the {@code AccessibleValue} associated with
+             * this object if one exists.  Otherwise returns {@code null}.
              *
-             * @return the <code>AccessibleValue</code>, or <code>null</code>
+             * @return the {@code AccessibleValue}, or {@code null}
              */
             public AccessibleValue getAccessibleValue() {
                 return getCurrentAccessibleContext().getAccessibleValue();
             }
 

@@ -9227,11 +9227,11 @@
 
             /**
              * Gets the background color of this object.
              *
              * @return the background color, if supported, of the object;
-             *     otherwise, <code>null</code>
+             *     otherwise, {@code null}
              */
             public Color getBackground() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getBackground();

@@ -9246,11 +9246,11 @@
             }
 
             /**
              * Sets the background color of this object.
              *
-             * @param c the new <code>Color</code> for the background
+             * @param c the new {@code Color} for the background
              */
             public void setBackground(Color c) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setBackground(c);

@@ -9264,11 +9264,11 @@
 
             /**
              * Gets the foreground color of this object.
              *
              * @return the foreground color, if supported, of the object;
-             *     otherwise, <code>null</code>
+             *     otherwise, {@code null}
              */
             public Color getForeground() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getForeground();

@@ -9283,11 +9283,11 @@
             }
 
             /**
              * Sets the foreground color of this object.
              *
-             * @param c the new <code>Color</code> for the foreground
+             * @param c the new {@code Color} for the foreground
              */
             public void setForeground(Color c) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setForeground(c);

@@ -9298,14 +9298,14 @@
                     }
                 }
             }
 
             /**
-             * Gets the <code>Cursor</code> of this object.
+             * Gets the {@code Cursor} of this object.
              *
-             * @return the <code>Cursor</code>, if supported,
-             *    of the object; otherwise, <code>null</code>
+             * @return the {@code Cursor}, if supported,
+             *    of the object; otherwise, {@code null}
              */
             public Cursor getCursor() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getCursor();

@@ -9323,13 +9323,13 @@
                     }
                 }
             }
 
             /**
-             * Sets the <code>Cursor</code> of this object.
+             * Sets the {@code Cursor} of this object.
              *
-             * @param c the new <code>Cursor</code> for the object
+             * @param c the new {@code Cursor} for the object
              */
             public void setCursor(Cursor c) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setCursor(c);

@@ -9340,14 +9340,14 @@
                     }
                 }
             }
 
             /**
-             * Gets the <code>Font</code> of this object.
+             * Gets the {@code Font} of this object.
              *
-             * @return the <code>Font</code>,if supported,
-             *   for the object; otherwise, <code>null</code>
+             * @return the {@code Font},if supported,
+             *   for the object; otherwise, {@code null}
              */
             public Font getFont() {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     return ((AccessibleComponent) ac).getFont();

@@ -9360,13 +9360,13 @@
                     }
                 }
             }
 
             /**
-             * Sets the <code>Font</code> of this object.
+             * Sets the {@code Font} of this object.
              *
-             * @param f the new <code>Font</code> for the object
+             * @param f the new {@code Font} for the object
              */
             public void setFont(Font f) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {
                     ((AccessibleComponent) ac).setFont(f);

@@ -9377,15 +9377,15 @@
                     }
                 }
             }
 
             /**
-             * Gets the <code>FontMetrics</code> of this object.
+             * Gets the {@code FontMetrics} of this object.
              *
-             * @param f the <code>Font</code>
-             * @return the <code>FontMetrics</code> object, if supported;
-             *    otherwise <code>null</code>
+             * @param f the {@code Font}
+             * @return the {@code FontMetrics} object, if supported;
+             *    otherwise {@code null}
              * @see #getFont
              */
             public FontMetrics getFontMetrics(Font f) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {

@@ -9439,11 +9439,11 @@
             /**
              * Determines if this object is visible.  Note: this means that the
              * object intends to be visible; however, it may not in fact be
              * showing on the screen because one of the objects that this object
              * is contained by is not visible.  To determine if an object is
-             * showing on the screen, use <code>isShowing</code>.
+             * showing on the screen, use {@code isShowing}.
              *
              * @return true if object is visible; otherwise, false
              */
             public boolean isVisible() {
                 AccessibleContext ac = getCurrentAccessibleContext();

@@ -9510,13 +9510,13 @@
              * Checks whether the specified point is within this
              * object's bounds, where the point's x and y coordinates
              * are defined to be relative to the coordinate system of
              * the object.
              *
-             * @param p the <code>Point</code> relative to the
+             * @param p the {@code Point} relative to the
              *    coordinate system of the object
-             * @return true if object contains <code>Point</code>;
+             * @return true if object contains {@code Point};
              *    otherwise false
              */
             public boolean contains(Point p) {
                 AccessibleContext ac = getCurrentAccessibleContext();
                 if (ac instanceof AccessibleComponent) {

@@ -9535,11 +9535,11 @@
 
             /**
              * Returns the location of the object on the screen.
              *
              * @return location of object on screen -- can be
-             *    <code>null</code> if this object is not on the screen
+             *    {@code null} if this object is not on the screen
              */
             public Point getLocationOnScreen() {
                 if (parent != null && parent.isShowing()) {
                     Point parentLocation = parent.getLocationOnScreen();
                     Point componentLocation = getLocation();

@@ -9553,13 +9553,13 @@
             /**
              * Gets the location of the object relative to the parent
              * in the form of a point specifying the object's
              * top-left corner in the screen's coordinate space.
              *
-             * @return an instance of <code>Point</code> representing
+             * @return an instance of {@code Point} representing
              *    the top-left corner of the object's bounds in the
-             *    coordinate space of the screen; <code>null</code> if
+             *    coordinate space of the screen; {@code null} if
              *    this object or its parent are not on the screen
              */
             public Point getLocation() {
                 if (parent != null) {
                     Rectangle r = parent.getHeaderRect(column);
< prev index next >