< prev index next >

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

Print this page

        

@@ -54,23 +54,23 @@
 import javax.accessibility.*;
 import static javax.swing.ClientPropertyKey.PopupFactory_FORCE_HEAVYWEIGHT_POPUP;
 import sun.awt.AWTAccessor;
 
 /**
- * <code>JOptionPane</code> makes it easy to pop up a standard dialog box that
+ * {@code JOptionPane} makes it easy to pop up a standard dialog box that
  * prompts users for a value or informs them of something.
- * For information about using <code>JOptionPane</code>, see
+ * For information about using {@code JOptionPane}, see
  * <a
  href="http://docs.oracle.com/javase/tutorial/uiswing/components/dialog.html">How to Make Dialogs</a>,
  * a section in <em>The Java Tutorial</em>.
  *
  * <p>
  *
- * While the <code>JOptionPane</code>
+ * While the {@code JOptionPane}
  * class may appear complex because of the large number of methods, almost
  * all uses of this class are one-line calls to one of the static
- * <code>showXxxDialog</code> methods shown below:
+ * {@code showXxxDialog} methods shown below:
  * <blockquote>
  *
  *
  * <table border=1 summary="Common JOptionPane method names and their descriptions">
  * <tr>

@@ -94,17 +94,17 @@
  *   <td>The Grand Unification of the above three.</td>
  * </tr>
  * </table>
  *
  * </blockquote>
- * Each of these methods also comes in a <code>showInternalXXX</code>
+ * Each of these methods also comes in a {@code showInternalXXX}
  * flavor, which uses an internal frame to hold the dialog box (see
  * {@link JInternalFrame}).
  * Multiple convenience methods have also been defined -- overloaded
  * versions of the basic methods that use different parameter lists.
  * <p>
- * All dialogs are modal. Each <code>showXxxDialog</code> method blocks
+ * All dialogs are modal. Each {@code showXxxDialog} method blocks
  * the caller until the user's interaction is complete.
  *
  * <table cellspacing=6 cellpadding=4 border=0 style="float:right" summary="layout">
  * <tr>
  *  <td style="background-color:#FFe0d0" rowspan=2>icon</td>

@@ -121,110 +121,110 @@
  * The basic appearance of one of these dialog boxes is generally
  * similar to the picture at the right, although the various
  * look-and-feels are
  * ultimately responsible for the final result.  In particular, the
  * look-and-feels will adjust the layout to accommodate the option pane's
- * <code>ComponentOrientation</code> property.
+ * {@code ComponentOrientation} property.
  * <br style="clear:all">
  * <p>
  * <b>Parameters:</b><br>
  * The parameters to these methods follow consistent patterns:
  * <blockquote>
  * <dl>
  * <dt>parentComponent<dd>
- * Defines the <code>Component</code> that is to be the parent of this
+ * Defines the {@code Component} that is to be the parent of this
  * dialog box.
- * It is used in two ways: the <code>Frame</code> that contains
- * it is used as the <code>Frame</code>
+ * It is used in two ways: the {@code Frame} that contains
+ * it is used as the {@code Frame}
  * parent for the dialog box, and its screen coordinates are used in
  * the placement of the dialog box. In general, the dialog box is placed
- * just below the component. This parameter may be <code>null</code>,
- * in which case a default <code>Frame</code> is used as the parent,
+ * just below the component. This parameter may be {@code null},
+ * in which case a default {@code Frame} is used as the parent,
  * and the dialog will be
  * centered on the screen (depending on the {@literal L&F}).
  * <dt><a name=message>message</a><dd>
  * A descriptive message to be placed in the dialog box.
- * In the most common usage, message is just a <code>String</code> or
- * <code>String</code> constant.
- * However, the type of this parameter is actually <code>Object</code>. Its
+ * In the most common usage, message is just a {@code String} or
+ * {@code String} constant.
+ * However, the type of this parameter is actually {@code Object}. Its
  * interpretation depends on its type:
  * <dl>
  * <dt>Object[]<dd>An array of objects is interpreted as a series of
  *                 messages (one per object) arranged in a vertical stack.
  *                 The interpretation is recursive -- each object in the
  *                 array is interpreted according to its type.
- * <dt>Component<dd>The <code>Component</code> is displayed in the dialog.
- * <dt>Icon<dd>The <code>Icon</code> is wrapped in a <code>JLabel</code>
+ * <dt>Component<dd>The {@code Component} is displayed in the dialog.
+ * <dt>Icon<dd>The {@code Icon} is wrapped in a {@code JLabel}
  *               and displayed in the dialog.
- * <dt>others<dd>The object is converted to a <code>String</code> by calling
- *               its <code>toString</code> method. The result is wrapped in a
- *               <code>JLabel</code> and displayed.
+ * <dt>others<dd>The object is converted to a {@code String} by calling
+ *               its {@code toString} method. The result is wrapped in a
+ *               {@code JLabel} and displayed.
  * </dl>
  * <dt>messageType<dd>Defines the style of the message. The Look and Feel
  * manager may lay out the dialog differently depending on this value, and
  * will often provide a default icon. The possible values are:
  * <ul>
- * <li><code>ERROR_MESSAGE</code>
- * <li><code>INFORMATION_MESSAGE</code>
- * <li><code>WARNING_MESSAGE</code>
- * <li><code>QUESTION_MESSAGE</code>
- * <li><code>PLAIN_MESSAGE</code>
+ * <li>{@code ERROR_MESSAGE}
+ * <li>{@code INFORMATION_MESSAGE}
+ * <li>{@code WARNING_MESSAGE}
+ * <li>{@code QUESTION_MESSAGE}
+ * <li>{@code PLAIN_MESSAGE}
  * </ul>
  * <dt>optionType<dd>Defines the set of option buttons that appear at
  * the bottom of the dialog box:
  * <ul>
- * <li><code>DEFAULT_OPTION</code>
- * <li><code>YES_NO_OPTION</code>
- * <li><code>YES_NO_CANCEL_OPTION</code>
- * <li><code>OK_CANCEL_OPTION</code>
+ * <li>{@code DEFAULT_OPTION}
+ * <li>{@code YES_NO_OPTION}
+ * <li>{@code YES_NO_CANCEL_OPTION}
+ * <li>{@code OK_CANCEL_OPTION}
  * </ul>
  * You aren't limited to this set of option buttons.  You can provide any
  * buttons you want using the options parameter.
  * <dt>options<dd>A more detailed description of the set of option buttons
  * that will appear at the bottom of the dialog box.
  * The usual value for the options parameter is an array of
- * <code>String</code>s. But
- * the parameter type is an array of <code>Objects</code>.
+ * {@code String}s. But
+ * the parameter type is an array of {@code Objects}.
  * A button is created for each object depending on its type:
  * <dl>
  * <dt>Component<dd>The component is added to the button row directly.
- * <dt>Icon<dd>A <code>JButton</code> is created with this as its label.
- * <dt>other<dd>The <code>Object</code> is converted to a string using its
- *              <code>toString</code> method and the result is used to
- *              label a <code>JButton</code>.
+ * <dt>Icon<dd>A {@code JButton} is created with this as its label.
+ * <dt>other<dd>The {@code Object} is converted to a string using its
+ *              {@code toString} method and the result is used to
+ *              label a {@code JButton}.
  * </dl>
  * <dt>icon<dd>A decorative icon to be placed in the dialog box. A default
- * value for this is determined by the <code>messageType</code> parameter.
+ * value for this is determined by the {@code messageType} parameter.
  * <dt>title<dd>The title for the dialog box.
  * <dt>initialValue<dd>The default selection (input value).
  * </dl>
  * </blockquote>
  * <p>
- * When the selection is changed, <code>setValue</code> is invoked,
- * which generates a <code>PropertyChangeEvent</code>.
+ * When the selection is changed, {@code setValue} is invoked,
+ * which generates a {@code PropertyChangeEvent}.
  * <p>
- * If a <code>JOptionPane</code> has configured to all input
- * <code>setWantsInput</code>
- * the bound property <code>JOptionPane.INPUT_VALUE_PROPERTY</code>
+ * If a {@code JOptionPane} has configured to all input
+ * {@code setWantsInput}
+ * the bound property {@code JOptionPane.INPUT_VALUE_PROPERTY}
  *  can also be listened
  * to, to determine when the user has input or selected a value.
  * <p>
- * When one of the <code>showXxxDialog</code> methods returns an integer,
+ * When one of the {@code showXxxDialog} methods returns an integer,
  * the possible values are:
  * <ul>
- * <li><code>YES_OPTION</code>
- * <li><code>NO_OPTION</code>
- * <li><code>CANCEL_OPTION</code>
- * <li><code>OK_OPTION</code>
- * <li><code>CLOSED_OPTION</code>
+ * <li>{@code YES_OPTION}
+ * <li>{@code NO_OPTION}
+ * <li>{@code CANCEL_OPTION}
+ * <li>{@code OK_OPTION}
+ * <li>{@code CLOSED_OPTION}
  * </ul>
  * <b>Examples:</b>
  * <dl>
  * <dt>Show an error dialog that displays the message, 'alert':
- * <dd><code>
+ * <dd>{@code
  * JOptionPane.showMessageDialog(null, "alert", "alert", JOptionPane.ERROR_MESSAGE);
- * </code>
+ * }
  * <dt>Show an internal information dialog with the message, 'information':
  * <dd><pre>
  * JOptionPane.showInternalMessageDialog(frame, "information",
  *             "information", JOptionPane.INFORMATION_MESSAGE);
  * </pre>

@@ -245,24 +245,24 @@
  * JOptionPane.showOptionDialog(null, "Click OK to continue", "Warning",
  *             JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,
  *             null, options, options[0]);
  * </pre>
  * <dt>Show a dialog asking the user to type in a String:
- * <dd><code>
+ * <dd>{@code
  * String inputValue = JOptionPane.showInputDialog("Please input a value");
- * </code>
+ * }
  * <dt>Show a dialog asking the user to select a String:
  * <dd><pre>
  * Object[] possibleValues = { "First", "Second", "Third" };<br>
  * Object selectedValue = JOptionPane.showInputDialog(null,
  *             "Choose one", "Input",
  *             JOptionPane.INFORMATION_MESSAGE, null,
  *             possibleValues, possibleValues[0]);
  * </pre>
  * </dl>
  * <b>Direct Use:</b><br>
- * To create and use an <code>JOptionPane</code> directly, the
+ * To create and use an {@code JOptionPane} directly, the
  * standard pattern is roughly as follows:
  * <pre>
  *     JOptionPane pane = new JOptionPane(<i>arguments</i>);
  *     pane.set<i>.Xxxx(...); // Configure</i>
  *     JDialog dialog = pane.createDialog(<i>parentComponent, title</i>);

@@ -294,11 +294,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}.
  *
  * @see JInternalFrame
  *
  * @beaninfo

@@ -327,18 +327,18 @@
     // Option types
     //
 
     /**
      * Type meaning Look and Feel should not supply any options -- only
-     * use the options from the <code>JOptionPane</code>.
+     * use the options from the {@code JOptionPane}.
      */
     public static final int         DEFAULT_OPTION = -1;
-    /** Type used for <code>showConfirmDialog</code>. */
+    /** Type used for {@code showConfirmDialog}. */
     public static final int         YES_NO_OPTION = 0;
-    /** Type used for <code>showConfirmDialog</code>. */
+    /** Type used for {@code showConfirmDialog}. */
     public static final int         YES_NO_CANCEL_OPTION = 1;
-    /** Type used for <code>showConfirmDialog</code>. */
+    /** Type used for {@code showConfirmDialog}. */
     public static final int         OK_CANCEL_OPTION = 2;
 
     //
     // Return values.
     //

@@ -350,11 +350,11 @@
     public static final int         CANCEL_OPTION = 2;
     /** Return value form class method if OK is chosen. */
     public static final int         OK_OPTION = 0;
     /** Return value from class method if user closes window without selecting
      * anything, more than likely this should be treated as either a
-     * <code>CANCEL_OPTION</code> or <code>NO_OPTION</code>. */
+     * {@code CANCEL_OPTION} or {@code NO_OPTION}. */
     public static final int         CLOSED_OPTION = -1;
 
     //
     // Message types. Used by the UI to determine what icon to display,
     // and possibly what behavior to give based on the type.

@@ -368,88 +368,88 @@
     /** Used for questions. */
     public static final int  QUESTION_MESSAGE = 3;
     /** No icon is used. */
     public static final int   PLAIN_MESSAGE = -1;
 
-    /** Bound property name for <code>icon</code>. */
+    /** Bound property name for {@code icon}. */
     public static final String      ICON_PROPERTY = "icon";
-    /** Bound property name for <code>message</code>. */
+    /** Bound property name for {@code message}. */
     public static final String      MESSAGE_PROPERTY = "message";
-    /** Bound property name for <code>value</code>. */
+    /** Bound property name for {@code value}. */
     public static final String      VALUE_PROPERTY = "value";
-    /** Bound property name for <code>option</code>. */
+    /** Bound property name for {@code option}. */
     public static final String      OPTIONS_PROPERTY = "options";
-    /** Bound property name for <code>initialValue</code>. */
+    /** Bound property name for {@code initialValue}. */
     public static final String      INITIAL_VALUE_PROPERTY = "initialValue";
-    /** Bound property name for <code>type</code>. */
+    /** Bound property name for {@code type}. */
     public static final String      MESSAGE_TYPE_PROPERTY = "messageType";
-    /** Bound property name for <code>optionType</code>. */
+    /** Bound property name for {@code optionType}. */
     public static final String      OPTION_TYPE_PROPERTY = "optionType";
-    /** Bound property name for <code>selectionValues</code>. */
+    /** Bound property name for {@code selectionValues}. */
     public static final String      SELECTION_VALUES_PROPERTY = "selectionValues";
-    /** Bound property name for <code>initialSelectionValue</code>. */
+    /** Bound property name for {@code initialSelectionValue}. */
     public static final String      INITIAL_SELECTION_VALUE_PROPERTY = "initialSelectionValue";
-    /** Bound property name for <code>inputValue</code>. */
+    /** Bound property name for {@code inputValue}. */
     public static final String      INPUT_VALUE_PROPERTY = "inputValue";
-    /** Bound property name for <code>wantsInput</code>. */
+    /** Bound property name for {@code wantsInput}. */
     public static final String      WANTS_INPUT_PROPERTY = "wantsInput";
 
     /** Icon used in pane. */
     protected transient Icon                  icon;
     /** Message to display. */
     protected transient Object                message;
     /** Options to display to the user. */
     protected transient Object[]              options;
-    /** Value that should be initially selected in <code>options</code>. */
+    /** Value that should be initially selected in {@code options}. */
     protected transient Object                initialValue;
     /** Message type. */
     protected int                   messageType;
     /**
-     * Option type, one of <code>DEFAULT_OPTION</code>,
-     * <code>YES_NO_OPTION</code>,
-     * <code>YES_NO_CANCEL_OPTION</code> or
-     * <code>OK_CANCEL_OPTION</code>.
+     * Option type, one of {@code DEFAULT_OPTION},
+     * {@code YES_NO_OPTION},
+     * {@code YES_NO_CANCEL_OPTION} or
+     * {@code OK_CANCEL_OPTION}.
      */
     protected int                   optionType;
     /** Currently selected value, will be a valid option, or
-     * <code>UNINITIALIZED_VALUE</code> or <code>null</code>. */
+     * {@code UNINITIALIZED_VALUE} or {@code null}. */
     protected transient Object                value;
     /** Array of values the user can choose from. Look and feel will
      * provide the UI component to choose this from. */
     protected transient Object[]              selectionValues;
     /** Value the user has input. */
     protected transient Object                inputValue;
-    /** Initial value to select in <code>selectionValues</code>. */
+    /** Initial value to select in {@code selectionValues}. */
     protected transient Object                initialSelectionValue;
     /** If true, a UI widget will be provided to the user to get input. */
     protected boolean                         wantsInput;
 
 
     /**
      * Shows a question-message dialog requesting input from the user. The
      * dialog uses the default frame, which usually means it is centered on
      * the screen.
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @return user's input
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static String showInputDialog(Object message)
         throws HeadlessException {
         return showInputDialog(null, message);
     }
 
     /**
      * Shows a question-message dialog requesting input from the user, with
-     * the input value initialized to <code>initialSelectionValue</code>. The
+     * the input value initialized to {@code initialSelectionValue}. The
      * dialog uses the default frame, which usually means it is centered on
      * the screen.
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @param initialSelectionValue the value used to initialize the input
      *                 field
      * @return user's input
      * @since 1.4
      */

@@ -457,20 +457,20 @@
         return showInputDialog(null, message, initialSelectionValue);
     }
 
     /**
      * Shows a question-message dialog requesting input from the user
-     * parented to <code>parentComponent</code>.
-     * The dialog is displayed on top of the <code>Component</code>'s
-     * frame, and is usually positioned below the <code>Component</code>.
+     * parented to {@code parentComponent}.
+     * The dialog is displayed on top of the {@code Component}'s
+     * frame, and is usually positioned below the {@code Component}.
      *
-     * @param parentComponent  the parent <code>Component</code> for the
+     * @param parentComponent  the parent {@code Component} for the
      *          dialog
-     * @param message  the <code>Object</code> to display
+     * @param message  the {@code Object} to display
      * @exception HeadlessException if
-     *    <code>GraphicsEnvironment.isHeadless</code> returns
-     *    <code>true</code>
+     *    {@code GraphicsEnvironment.isHeadless} returns
+     *    {@code true}
      * @return user's input
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static String showInputDialog(Component parentComponent,
         Object message) throws HeadlessException {

@@ -478,18 +478,18 @@
             "OptionPane.inputDialogTitle", parentComponent), QUESTION_MESSAGE);
     }
 
     /**
      * Shows a question-message dialog requesting input from the user and
-     * parented to <code>parentComponent</code>. The input value will be
-     * initialized to <code>initialSelectionValue</code>.
-     * The dialog is displayed on top of the <code>Component</code>'s
-     * frame, and is usually positioned below the <code>Component</code>.
+     * parented to {@code parentComponent}. The input value will be
+     * initialized to {@code initialSelectionValue}.
+     * The dialog is displayed on top of the {@code Component}'s
+     * frame, and is usually positioned below the {@code Component}.
      *
-     * @param parentComponent  the parent <code>Component</code> for the
+     * @param parentComponent  the parent {@code Component} for the
      *          dialog
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @param initialSelectionValue the value used to initialize the input
      *                 field
      * @return user's input
      * @since 1.4
      */

@@ -501,28 +501,28 @@
                       initialSelectionValue);
     }
 
     /**
      * Shows a dialog requesting input from the user parented to
-     * <code>parentComponent</code> with the dialog having the title
-     * <code>title</code> and message type <code>messageType</code>.
+     * {@code parentComponent} with the dialog having the title
+     * {@code title} and message type {@code messageType}.
      *
-     * @param parentComponent  the parent <code>Component</code> for the
+     * @param parentComponent  the parent {@code Component} for the
      *                  dialog
-     * @param message  the <code>Object</code> to display
-     * @param title    the <code>String</code> to display in the dialog
+     * @param message  the {@code Object} to display
+     * @param title    the {@code String} to display in the dialog
      *                  title bar
      * @param messageType the type of message that is to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @return user's input
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static String showInputDialog(Component parentComponent,
         Object message, String title, int messageType)
         throws HeadlessException {

@@ -532,40 +532,40 @@
 
     /**
      * Prompts the user for input in a blocking dialog where the
      * initial selection, possible selections, and all other options can
      * be specified. The user will able to choose from
-     * <code>selectionValues</code>, where <code>null</code> implies the
+     * {@code selectionValues}, where {@code null} implies the
      * user can input
-     * whatever they wish, usually by means of a <code>JTextField</code>.
-     * <code>initialSelectionValue</code> is the initial value to prompt
+     * whatever they wish, usually by means of a {@code JTextField}.
+     * {@code initialSelectionValue} is the initial value to prompt
      * the user with. It is up to the UI to decide how best to represent
-     * the <code>selectionValues</code>, but usually a
-     * <code>JComboBox</code>, <code>JList</code>, or
-     * <code>JTextField</code> will be used.
+     * the {@code selectionValues}, but usually a
+     * {@code JComboBox}, {@code JList}, or
+     * {@code JTextField} will be used.
      *
-     * @param parentComponent  the parent <code>Component</code> for the
+     * @param parentComponent  the parent {@code Component} for the
      *                  dialog
-     * @param message  the <code>Object</code> to display
-     * @param title    the <code>String</code> to display in the
+     * @param message  the {@code Object} to display
+     * @param title    the {@code String} to display in the
      *                  dialog title bar
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
-     * @param icon     the <code>Icon</code> image to display
-     * @param selectionValues an array of <code>Object</code>s that
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
+     * @param icon     the {@code Icon} image to display
+     * @param selectionValues an array of {@code Object}s that
      *                  gives the possible selections
      * @param initialSelectionValue the value used to initialize the input
      *                 field
-     * @return user's input, or <code>null</code> meaning the user
+     * @return user's input, or {@code null} meaning the user
      *                  canceled the input
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     @SuppressWarnings("deprecation")
     public static Object showInputDialog(Component parentComponent,
         Object message, String title, int messageType, Icon icon,

@@ -597,18 +597,18 @@
     }
 
     /**
      * Brings up an information-message dialog titled "Message".
      *
-     * @param parentComponent determines the <code>Frame</code> in
-     *          which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame} in
+     *          which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static void showMessageDialog(Component parentComponent,
         Object message) throws HeadlessException {
         showMessageDialog(parentComponent, message, UIManager.getString(

@@ -616,27 +616,27 @@
                     INFORMATION_MESSAGE);
     }
 
     /**
      * Brings up a dialog that displays a message using a default
-     * icon determined by the <code>messageType</code> parameter.
+     * icon determined by the {@code messageType} parameter.
      *
-     * @param parentComponent determines the <code>Frame</code>
-     *          in which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame}
+     *          in which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @param title     the title string for the dialog
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static void showMessageDialog(Component parentComponent,
         Object message, String title, int messageType)
         throws HeadlessException {

@@ -644,28 +644,28 @@
     }
 
     /**
      * Brings up a dialog displaying a message, specifying all parameters.
      *
-     * @param parentComponent determines the <code>Frame</code> in which the
-     *                  dialog is displayed; if <code>null</code>,
-     *                  or if the <code>parentComponent</code> has no
-     *                  <code>Frame</code>, a
-     *                  default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame} in which the
+     *                  dialog is displayed; if {@code null},
+     *                  or if the {@code parentComponent} has no
+     *                  {@code Frame}, a
+     *                  default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @param title     the title string for the dialog
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param icon      an icon to display in the dialog that helps the user
      *                  identify the kind of message that is being displayed
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static void showMessageDialog(Component parentComponent,
         Object message, String title, int messageType, Icon icon)
         throws HeadlessException {

@@ -676,20 +676,20 @@
     /**
      * Brings up a dialog with the options <i>Yes</i>,
      * <i>No</i> and <i>Cancel</i>; with the
      * title, <b>Select an Option</b>.
      *
-     * @param parentComponent determines the <code>Frame</code> in which the
-     *                  dialog is displayed; if <code>null</code>,
-     *                  or if the <code>parentComponent</code> has no
-     *                  <code>Frame</code>, a
-     *                  default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame} in which the
+     *                  dialog is displayed; if {@code null},
+     *                  or if the {@code parentComponent} has no
+     *                  {@code Frame}, a
+     *                  default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @return an integer indicating the option selected by the user
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static int showConfirmDialog(Component parentComponent,
         Object message) throws HeadlessException {
         return showConfirmDialog(parentComponent, message,

@@ -697,27 +697,27 @@
                                  YES_NO_CANCEL_OPTION);
     }
 
     /**
      * Brings up a dialog where the number of choices is determined
-     * by the <code>optionType</code> parameter.
+     * by the {@code optionType} parameter.
      *
-     * @param parentComponent determines the <code>Frame</code> in which the
-     *                  dialog is displayed; if <code>null</code>,
-     *                  or if the <code>parentComponent</code> has no
-     *                  <code>Frame</code>, a
-     *                  default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame} in which the
+     *                  dialog is displayed; if {@code null},
+     *                  or if the {@code parentComponent} has no
+     *                  {@code Frame}, a
+     *                  default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @param title     the title string for the dialog
      * @param optionType an int designating the options available on the dialog:
-     *                  <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  or <code>OK_CANCEL_OPTION</code>
+     *                  {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  or {@code OK_CANCEL_OPTION}
      * @return an int indicating the option selected by the user
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static int showConfirmDialog(Component parentComponent,
         Object message, String title, int optionType)
         throws HeadlessException {

@@ -725,38 +725,38 @@
                                  QUESTION_MESSAGE);
     }
 
     /**
      * Brings up a dialog where the number of choices is determined
-     * by the <code>optionType</code> parameter, where the
-     * <code>messageType</code>
+     * by the {@code optionType} parameter, where the
+     * {@code messageType}
      * parameter determines the icon to display.
-     * The <code>messageType</code> parameter is primarily used to supply
+     * The {@code messageType} parameter is primarily used to supply
      * a default icon from the Look and Feel.
      *
-     * @param parentComponent determines the <code>Frame</code> in
-     *                  which the dialog is displayed; if <code>null</code>,
-     *                  or if the <code>parentComponent</code> has no
-     *                  <code>Frame</code>, a
-     *                  default <code>Frame</code> is used.
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame} in
+     *                  which the dialog is displayed; if {@code null},
+     *                  or if the {@code parentComponent} has no
+     *                  {@code Frame}, a
+     *                  default {@code Frame} is used.
+     * @param message   the {@code Object} to display
      * @param title     the title string for the dialog
      * @param optionType an integer designating the options available
-     *                   on the dialog: <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  or <code>OK_CANCEL_OPTION</code>
+     *                   on the dialog: {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  or {@code OK_CANCEL_OPTION}
      * @param messageType an integer designating the kind of message this is;
      *                  primarily used to determine the icon from the pluggable
-     *                  Look and Feel: <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  Look and Feel: {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @return an integer indicating the option selected by the user
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static int showConfirmDialog(Component parentComponent,
         Object message, String title, int optionType, int messageType)
         throws HeadlessException {

@@ -764,37 +764,37 @@
                                 messageType, null);
     }
 
     /**
      * Brings up a dialog with a specified icon, where the number of
-     * choices is determined by the <code>optionType</code> parameter.
-     * The <code>messageType</code> parameter is primarily used to supply
+     * choices is determined by the {@code optionType} parameter.
+     * The {@code messageType} parameter is primarily used to supply
      * a default icon from the look and feel.
      *
-     * @param parentComponent determines the <code>Frame</code> in which the
-     *                  dialog is displayed; if <code>null</code>,
-     *                  or if the <code>parentComponent</code> has no
-     *                  <code>Frame</code>, a
-     *                  default <code>Frame</code> is used
+     * @param parentComponent determines the {@code Frame} in which the
+     *                  dialog is displayed; if {@code null},
+     *                  or if the {@code parentComponent} has no
+     *                  {@code Frame}, a
+     *                  default {@code Frame} is used
      * @param message   the Object to display
      * @param title     the title string for the dialog
      * @param optionType an int designating the options available on the dialog:
-     *                  <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  or <code>OK_CANCEL_OPTION</code>
+     *                  {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  or {@code OK_CANCEL_OPTION}
      * @param messageType an int designating the kind of message this is,
      *                  primarily used to determine the icon from the pluggable
-     *                  Look and Feel: <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  Look and Feel: {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param icon      the icon to display in the dialog
      * @return an int indicating the option selected by the user
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static int showConfirmDialog(Component parentComponent,
         Object message, String title, int optionType,
         int messageType, Icon icon) throws HeadlessException {

@@ -802,60 +802,60 @@
                                 messageType, icon, null, null);
     }
 
     /**
      * Brings up a dialog with a specified icon, where the initial
-     * choice is determined by the <code>initialValue</code> parameter and
-     * the number of choices is determined by the <code>optionType</code>
+     * choice is determined by the {@code initialValue} parameter and
+     * the number of choices is determined by the {@code optionType}
      * parameter.
      * <p>
-     * If <code>optionType</code> is <code>YES_NO_OPTION</code>,
-     * or <code>YES_NO_CANCEL_OPTION</code>
-     * and the <code>options</code> parameter is <code>null</code>,
+     * If {@code optionType} is {@code YES_NO_OPTION},
+     * or {@code YES_NO_CANCEL_OPTION}
+     * and the {@code options} parameter is {@code null},
      * then the options are
      * supplied by the look and feel.
      * <p>
-     * The <code>messageType</code> parameter is primarily used to supply
+     * The {@code messageType} parameter is primarily used to supply
      * a default icon from the look and feel.
      *
-     * @param parentComponent determines the <code>Frame</code>
+     * @param parentComponent determines the {@code Frame}
      *                  in which the dialog is displayed;  if
-     *                  <code>null</code>, or if the
-     *                  <code>parentComponent</code> has no
-     *                  <code>Frame</code>, a
-     *                  default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     *                  {@code null}, or if the
+     *                  {@code parentComponent} has no
+     *                  {@code Frame}, a
+     *                  default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @param title     the title string for the dialog
      * @param optionType an integer designating the options available on the
-     *                  dialog: <code>DEFAULT_OPTION</code>,
-     *                  <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  or <code>OK_CANCEL_OPTION</code>
+     *                  dialog: {@code DEFAULT_OPTION},
+     *                  {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  or {@code OK_CANCEL_OPTION}
      * @param messageType an integer designating the kind of message this is,
      *                  primarily used to determine the icon from the
-     *                  pluggable Look and Feel: <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  pluggable Look and Feel: {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param icon      the icon to display in the dialog
      * @param options   an array of objects indicating the possible choices
      *                  the user can make; if the objects are components, they
-     *                  are rendered properly; non-<code>String</code>
+     *                  are rendered properly; non-{@code String}
      *                  objects are
-     *                  rendered using their <code>toString</code> methods;
-     *                  if this parameter is <code>null</code>,
+     *                  rendered using their {@code toString} methods;
+     *                  if this parameter is {@code null},
      *                  the options are determined by the Look and Feel
      * @param initialValue the object that represents the default selection
-     *                  for the dialog; only meaningful if <code>options</code>
-     *                  is used; can be <code>null</code>
+     *                  for the dialog; only meaningful if {@code options}
+     *                  is used; can be {@code null}
      * @return an integer indicating the option chosen by the user,
-     *                  or <code>CLOSED_OPTION</code> if the user closed
+     *                  or {@code CLOSED_OPTION} if the user closed
      *                  the dialog
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     @SuppressWarnings("deprecation")
     public static int showOptionDialog(Component parentComponent,
         Object message, String title, int optionType, int messageType,

@@ -892,60 +892,60 @@
         }
         return CLOSED_OPTION;
     }
 
     /**
-     * Creates and returns a new <code>JDialog</code> wrapping
-     * <code>this</code> centered on the <code>parentComponent</code>
-     * in the <code>parentComponent</code>'s frame.
-     * <code>title</code> is the title of the returned dialog.
-     * The returned <code>JDialog</code> will not be resizable by the
-     * user, however programs can invoke <code>setResizable</code> on
-     * the <code>JDialog</code> instance to change this property.
-     * The returned <code>JDialog</code> will be set up such that
+     * Creates and returns a new {@code JDialog} wrapping
+     * {@code this} centered on the {@code parentComponent}
+     * in the {@code parentComponent}'s frame.
+     * {@code title} is the title of the returned dialog.
+     * The returned {@code JDialog} will not be resizable by the
+     * user, however programs can invoke {@code setResizable} on
+     * the {@code JDialog} instance to change this property.
+     * The returned {@code JDialog} will be set up such that
      * once it is closed, or the user clicks on one of the buttons,
      * the optionpane's value property will be set accordingly and
      * the dialog will be closed.  Each time the dialog is made visible,
      * it will reset the option pane's value property to
-     * <code>JOptionPane.UNINITIALIZED_VALUE</code> to ensure the
+     * {@code JOptionPane.UNINITIALIZED_VALUE} to ensure the
      * user's subsequent action closes the dialog properly.
      *
      * @param parentComponent determines the frame in which the dialog
-     *          is displayed; if the <code>parentComponent</code> has
-     *          no <code>Frame</code>, a default <code>Frame</code> is used
+     *          is displayed; if the {@code parentComponent} has
+     *          no {@code Frame}, a default {@code Frame} is used
      * @param title     the title string for the dialog
-     * @return a new <code>JDialog</code> containing this instance
+     * @return a new {@code JDialog} containing this instance
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public JDialog createDialog(Component parentComponent, String title)
         throws HeadlessException {
         int style = styleFromMessageType(getMessageType());
         return createDialog(parentComponent, title, style);
     }
 
     /**
-     * Creates and returns a new parentless <code>JDialog</code>
+     * Creates and returns a new parentless {@code JDialog}
      * with the specified title.
-     * The returned <code>JDialog</code> will not be resizable by the
-     * user, however programs can invoke <code>setResizable</code> on
-     * the <code>JDialog</code> instance to change this property.
-     * The returned <code>JDialog</code> will be set up such that
+     * The returned {@code JDialog} will not be resizable by the
+     * user, however programs can invoke {@code setResizable} on
+     * the {@code JDialog} instance to change this property.
+     * The returned {@code JDialog} will be set up such that
      * once it is closed, or the user clicks on one of the buttons,
      * the optionpane's value property will be set accordingly and
      * the dialog will be closed.  Each time the dialog is made visible,
      * it will reset the option pane's value property to
-     * <code>JOptionPane.UNINITIALIZED_VALUE</code> to ensure the
+     * {@code JOptionPane.UNINITIALIZED_VALUE} to ensure the
      * user's subsequent action closes the dialog properly.
      *
      * @param title     the title string for the dialog
-     * @return a new <code>JDialog</code> containing this instance
+     * @return a new {@code JDialog} containing this instance
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      * @since 1.6
      */
     public JDialog createDialog(String title) throws HeadlessException {
         int style = styleFromMessageType(getMessageType());

@@ -1041,14 +1041,14 @@
 
     /**
      * Brings up an internal confirmation dialog panel. The dialog
      * is a information-message dialog titled "Message".
      *
-     * @param parentComponent determines the <code>Frame</code>
-     *          in which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
+     * @param parentComponent determines the {@code Frame}
+     *          in which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
      * @param message   the object to display
      */
     public static void showInternalMessageDialog(Component parentComponent,
                                                  Object message) {
         showInternalMessageDialog(parentComponent, message, UIManager.

@@ -1056,25 +1056,25 @@
                                  parentComponent), INFORMATION_MESSAGE);
     }
 
     /**
      * Brings up an internal dialog panel that displays a message
-     * using a default icon determined by the <code>messageType</code>
+     * using a default icon determined by the {@code messageType}
      * parameter.
      *
-     * @param parentComponent determines the <code>Frame</code>
-     *          in which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame}
+     *          in which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @param title     the title string for the dialog
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      */
     public static void showInternalMessageDialog(Component parentComponent,
                                                  Object message, String title,
                                                  int messageType) {
         showInternalMessageDialog(parentComponent, message, title, messageType,null);

@@ -1082,22 +1082,22 @@
 
     /**
      * Brings up an internal dialog panel displaying a message,
      * specifying all parameters.
      *
-     * @param parentComponent determines the <code>Frame</code>
-     *          in which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame}
+     *          in which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @param title     the title string for the dialog
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param icon      an icon to display in the dialog that helps the user
      *                  identify the kind of message that is being displayed
      */
     public static void showInternalMessageDialog(Component parentComponent,
                                          Object message,

@@ -1109,15 +1109,15 @@
 
     /**
      * Brings up an internal dialog panel with the options <i>Yes</i>, <i>No</i>
      * and <i>Cancel</i>; with the title, <b>Select an Option</b>.
      *
-     * @param parentComponent determines the <code>Frame</code> in
-     *          which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
-     * @param message   the <code>Object</code> to display
+     * @param parentComponent determines the {@code Frame} in
+     *          which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
+     * @param message   the {@code Object} to display
      * @return an integer indicating the option selected by the user
      */
     public static int showInternalConfirmDialog(Component parentComponent,
                                                 Object message) {
         return showInternalConfirmDialog(parentComponent, message,

@@ -1125,26 +1125,26 @@
                                  YES_NO_CANCEL_OPTION);
     }
 
     /**
      * Brings up a internal dialog panel where the number of choices
-     * is determined by the <code>optionType</code> parameter.
+     * is determined by the {@code optionType} parameter.
      *
-     * @param parentComponent determines the <code>Frame</code>
-     *          in which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
+     * @param parentComponent determines the {@code Frame}
+     *          in which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
      * @param message   the object to display in the dialog; a
-     *          <code>Component</code> object is rendered as a
-     *          <code>Component</code>; a <code>String</code>
+     *          {@code Component} object is rendered as a
+     *          {@code Component}; a {@code String}
      *          object is rendered as a string; other objects
-     *          are converted to a <code>String</code> using the
-     *          <code>toString</code> method
+     *          are converted to a {@code String} using the
+     *          {@code toString} method
      * @param title     the title string for the dialog
      * @param optionType an integer designating the options
-     *          available on the dialog: <code>YES_NO_OPTION</code>,
-     *          or <code>YES_NO_CANCEL_OPTION</code>
+     *          available on the dialog: {@code YES_NO_OPTION},
+     *          or {@code YES_NO_CANCEL_OPTION}
      * @return an integer indicating the option selected by the user
      */
     public static int showInternalConfirmDialog(Component parentComponent,
                                                 Object message, String title,
                                                 int optionType) {

@@ -1152,35 +1152,35 @@
                                          QUESTION_MESSAGE);
     }
 
     /**
      * Brings up an internal dialog panel where the number of choices
-     * is determined by the <code>optionType</code> parameter, where
-     * the <code>messageType</code> parameter determines the icon to display.
-     * The <code>messageType</code> parameter is primarily used to supply
+     * is determined by the {@code optionType} parameter, where
+     * the {@code messageType} parameter determines the icon to display.
+     * The {@code messageType} parameter is primarily used to supply
      * a default icon from the Look and Feel.
      *
-     * @param parentComponent determines the <code>Frame</code> in
-     *          which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
+     * @param parentComponent determines the {@code Frame} in
+     *          which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
      * @param message   the object to display in the dialog; a
-     *          <code>Component</code> object is rendered as a
-     *          <code>Component</code>; a <code>String</code>
+     *          {@code Component} object is rendered as a
+     *          {@code Component}; a {@code String}
      *          object is rendered as a string; other objects are
-     *          converted to a <code>String</code> using the
-     *          <code>toString</code> method
+     *          converted to a {@code String} using the
+     *          {@code toString} method
      * @param title     the title string for the dialog
      * @param optionType an integer designating the options
      *          available on the dialog:
-     *          <code>YES_NO_OPTION</code>, or <code>YES_NO_CANCEL_OPTION</code>
+     *          {@code YES_NO_OPTION}, or {@code YES_NO_CANCEL_OPTION}
      * @param messageType an integer designating the kind of message this is,
      *          primarily used to determine the icon from the
-     *          pluggable Look and Feel: <code>ERROR_MESSAGE</code>,
-     *          <code>INFORMATION_MESSAGE</code>,
-     *          <code>WARNING_MESSAGE</code>, <code>QUESTION_MESSAGE</code>,
-     *          or <code>PLAIN_MESSAGE</code>
+     *          pluggable Look and Feel: {@code ERROR_MESSAGE},
+     *          {@code INFORMATION_MESSAGE},
+     *          {@code WARNING_MESSAGE}, {@code QUESTION_MESSAGE},
+     *          or {@code PLAIN_MESSAGE}
      * @return an integer indicating the option selected by the user
      */
     public static int showInternalConfirmDialog(Component parentComponent,
                                         Object message,
                                         String title, int optionType,

@@ -1189,36 +1189,36 @@
                                          messageType, null);
     }
 
     /**
      * Brings up an internal dialog panel with a specified icon, where
-     * the number of choices is determined by the <code>optionType</code>
+     * the number of choices is determined by the {@code optionType}
      * parameter.
-     * The <code>messageType</code> parameter is primarily used to supply
+     * The {@code messageType} parameter is primarily used to supply
      * a default icon from the look and feel.
      *
-     * @param parentComponent determines the <code>Frame</code>
-     *          in which the dialog is displayed; if <code>null</code>,
+     * @param parentComponent determines the {@code Frame}
+     *          in which the dialog is displayed; if {@code null},
      *          or if the parentComponent has no Frame, a
-     *          default <code>Frame</code> is used
+     *          default {@code Frame} is used
      * @param message   the object to display in the dialog; a
-     *          <code>Component</code> object is rendered as a
-     *          <code>Component</code>; a <code>String</code>
+     *          {@code Component} object is rendered as a
+     *          {@code Component}; a {@code String}
      *          object is rendered as a string; other objects are
-     *          converted to a <code>String</code> using the
-     *          <code>toString</code> method
+     *          converted to a {@code String} using the
+     *          {@code toString} method
      * @param title     the title string for the dialog
      * @param optionType an integer designating the options available
      *          on the dialog:
-     *          <code>YES_NO_OPTION</code>, or
-     *          <code>YES_NO_CANCEL_OPTION</code>.
+     *          {@code YES_NO_OPTION}, or
+     *          {@code YES_NO_CANCEL_OPTION}.
      * @param messageType an integer designating the kind of message this is,
      *          primarily used to determine the icon from the pluggable
-     *          Look and Feel: <code>ERROR_MESSAGE</code>,
-     *          <code>INFORMATION_MESSAGE</code>,
-     *          <code>WARNING_MESSAGE</code>, <code>QUESTION_MESSAGE</code>,
-     *          or <code>PLAIN_MESSAGE</code>
+     *          Look and Feel: {@code ERROR_MESSAGE},
+     *          {@code INFORMATION_MESSAGE},
+     *          {@code WARNING_MESSAGE}, {@code QUESTION_MESSAGE},
+     *          or {@code PLAIN_MESSAGE}
      * @param icon      the icon to display in the dialog
      * @return an integer indicating the option selected by the user
      */
     public static int showInternalConfirmDialog(Component parentComponent,
                                         Object message,

@@ -1228,54 +1228,54 @@
                                         messageType, icon, null, null);
     }
 
     /**
      * Brings up an internal dialog panel with a specified icon, where
-     * the initial choice is determined by the <code>initialValue</code>
+     * the initial choice is determined by the {@code initialValue}
      * parameter and the number of choices is determined by the
-     * <code>optionType</code> parameter.
+     * {@code optionType} parameter.
      * <p>
-     * If <code>optionType</code> is <code>YES_NO_OPTION</code>, or
-     * <code>YES_NO_CANCEL_OPTION</code>
-     * and the <code>options</code> parameter is <code>null</code>,
+     * If {@code optionType} is {@code YES_NO_OPTION}, or
+     * {@code YES_NO_CANCEL_OPTION}
+     * and the {@code options} parameter is {@code null},
      * then the options are supplied by the Look and Feel.
      * <p>
-     * The <code>messageType</code> parameter is primarily used to supply
+     * The {@code messageType} parameter is primarily used to supply
      * a default icon from the look and feel.
      *
-     * @param parentComponent determines the <code>Frame</code>
-     *          in which the dialog is displayed; if <code>null</code>,
-     *          or if the <code>parentComponent</code> has no
-     *          <code>Frame</code>, a default <code>Frame</code> is used
+     * @param parentComponent determines the {@code Frame}
+     *          in which the dialog is displayed; if {@code null},
+     *          or if the {@code parentComponent} has no
+     *          {@code Frame}, a default {@code Frame} is used
      * @param message   the object to display in the dialog; a
-     *          <code>Component</code> object is rendered as a
-     *          <code>Component</code>; a <code>String</code>
+     *          {@code Component} object is rendered as a
+     *          {@code Component}; a {@code String}
      *          object is rendered as a string. Other objects are
-     *          converted to a <code>String</code> using the
-     *          <code>toString</code> method
+     *          converted to a {@code String} using the
+     *          {@code toString} method
      * @param title     the title string for the dialog
      * @param optionType an integer designating the options available
-     *          on the dialog: <code>YES_NO_OPTION</code>,
-     *          or <code>YES_NO_CANCEL_OPTION</code>
+     *          on the dialog: {@code YES_NO_OPTION},
+     *          or {@code YES_NO_CANCEL_OPTION}
      * @param messageType an integer designating the kind of message this is;
      *          primarily used to determine the icon from the
-     *          pluggable Look and Feel: <code>ERROR_MESSAGE</code>,
-     *          <code>INFORMATION_MESSAGE</code>,
-     *          <code>WARNING_MESSAGE</code>, <code>QUESTION_MESSAGE</code>,
-     *          or <code>PLAIN_MESSAGE</code>
+     *          pluggable Look and Feel: {@code ERROR_MESSAGE},
+     *          {@code INFORMATION_MESSAGE},
+     *          {@code WARNING_MESSAGE}, {@code QUESTION_MESSAGE},
+     *          or {@code PLAIN_MESSAGE}
      * @param icon      the icon to display in the dialog
      * @param options   an array of objects indicating the possible choices
      *          the user can make; if the objects are components, they
-     *          are rendered properly; non-<code>String</code>
-     *          objects are rendered using their <code>toString</code>
-     *          methods; if this parameter is <code>null</code>,
+     *          are rendered properly; non-{@code String}
+     *          objects are rendered using their {@code toString}
+     *          methods; if this parameter is {@code null},
      *          the options are determined by the Look and Feel
      * @param initialValue the object that represents the default selection
-     *          for the dialog; only meaningful if <code>options</code>
-     *          is used; can be <code>null</code>
+     *          for the dialog; only meaningful if {@code options}
+     *          is used; can be {@code null}
      * @return an integer indicating the option chosen by the user,
-     *          or <code>CLOSED_OPTION</code> if the user closed the Dialog
+     *          or {@code CLOSED_OPTION} if the user closed the Dialog
      */
     public static int showInternalOptionDialog(Component parentComponent,
                                        Object message,
                                        String title, int optionType,
                                        int messageType, Icon icon,

@@ -1344,17 +1344,17 @@
         return CLOSED_OPTION;
     }
 
     /**
      * Shows an internal question-message dialog requesting input from
-     * the user parented to <code>parentComponent</code>. The dialog
-     * is displayed in the <code>Component</code>'s frame,
-     * and is usually positioned below the <code>Component</code>.
+     * the user parented to {@code parentComponent}. The dialog
+     * is displayed in the {@code Component}'s frame,
+     * and is usually positioned below the {@code Component}.
      *
-     * @param parentComponent  the parent <code>Component</code>
+     * @param parentComponent  the parent {@code Component}
      *          for the dialog
-     * @param message  the <code>Object</code> to display
+     * @param message  the {@code Object} to display
      * @return user's input
      */
     public static String showInternalInputDialog(Component parentComponent,
                                                  Object message) {
         return showInternalInputDialog(parentComponent, message, UIManager.

@@ -1362,16 +1362,16 @@
                QUESTION_MESSAGE);
     }
 
     /**
      * Shows an internal dialog requesting input from the user parented
-     * to <code>parentComponent</code> with the dialog having the title
-     * <code>title</code> and message type <code>messageType</code>.
+     * to {@code parentComponent} with the dialog having the title
+     * {@code title} and message type {@code messageType}.
      *
-     * @param parentComponent the parent <code>Component</code> for the dialog
-     * @param message  the <code>Object</code> to display
-     * @param title    the <code>String</code> to display in the
+     * @param parentComponent the parent {@code Component} for the dialog
+     * @param message  the {@code Object} to display
+     * @param title    the {@code String} to display in the
      *          dialog title bar
      * @param messageType the type of message that is to be displayed:
      *                    ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE,
      *                    QUESTION_MESSAGE, or PLAIN_MESSAGE
      * @return user's input

@@ -1384,33 +1384,33 @@
 
     /**
      * Prompts the user for input in a blocking internal dialog where
      * the initial selection, possible selections, and all other
      * options can be specified. The user will able to choose from
-     * <code>selectionValues</code>, where <code>null</code>
+     * {@code selectionValues}, where {@code null}
      * implies the user can input
-     * whatever they wish, usually by means of a <code>JTextField</code>.
-     * <code>initialSelectionValue</code> is the initial value to prompt
+     * whatever they wish, usually by means of a {@code JTextField}.
+     * {@code initialSelectionValue} is the initial value to prompt
      * the user with. It is up to the UI to decide how best to represent
-     * the <code>selectionValues</code>, but usually a
-     * <code>JComboBox</code>, <code>JList</code>, or
-     * <code>JTextField</code> will be used.
-     *
-     * @param parentComponent the parent <code>Component</code> for the dialog
-     * @param message  the <code>Object</code> to display
-     * @param title    the <code>String</code> to display in the dialog
+     * the {@code selectionValues}, but usually a
+     * {@code JComboBox}, {@code JList}, or
+     * {@code JTextField} will be used.
+     *
+     * @param parentComponent the parent {@code Component} for the dialog
+     * @param message  the {@code Object} to display
+     * @param title    the {@code String} to display in the dialog
      *          title bar
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>, <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>, or <code>PLAIN_MESSAGE</code>
-     * @param icon     the <code>Icon</code> image to display
-     * @param selectionValues an array of <code>Objects</code> that
+     *                  {@code ERROR_MESSAGE}, {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE}, or {@code PLAIN_MESSAGE}
+     * @param icon     the {@code Icon} image to display
+     * @param selectionValues an array of {@code Objects} that
      *                  gives the possible selections
      * @param initialSelectionValue the value used to initialize the input
      *                  field
-     * @return user's input, or <code>null</code> meaning the user
+     * @return user's input, or {@code null} meaning the user
      *          canceled the input
      */
     public static Object showInternalInputDialog(Component parentComponent,
             Object message, String title, int messageType, Icon icon,
             Object[] selectionValues, Object initialSelectionValue) {

@@ -1468,27 +1468,27 @@
         }
         return value;
     }
 
     /**
-     * Creates and returns an instance of <code>JInternalFrame</code>.
+     * Creates and returns an instance of {@code JInternalFrame}.
      * The internal frame is created with the specified title,
-     * and wrapping the <code>JOptionPane</code>.
-     * The returned <code>JInternalFrame</code> is
-     * added to the <code>JDesktopPane</code> ancestor of
-     * <code>parentComponent</code>, or components
-     * parent if one its ancestors isn't a <code>JDesktopPane</code>,
-     * or if <code>parentComponent</code>
-     * doesn't have a parent then a <code>RuntimeException</code> is thrown.
+     * and wrapping the {@code JOptionPane}.
+     * The returned {@code JInternalFrame} is
+     * added to the {@code JDesktopPane} ancestor of
+     * {@code parentComponent}, or components
+     * parent if one its ancestors isn't a {@code JDesktopPane},
+     * or if {@code parentComponent}
+     * doesn't have a parent then a {@code RuntimeException} is thrown.
      *
-     * @param parentComponent  the parent <code>Component</code> for
+     * @param parentComponent  the parent {@code Component} for
      *          the internal frame
-     * @param title    the <code>String</code> to display in the
+     * @param title    the {@code String} to display in the
      *          frame's title bar
-     * @return a <code>JInternalFrame</code> containing a
-     *          <code>JOptionPane</code>
-     * @exception RuntimeException if <code>parentComponent</code> does
+     * @return a {@code JInternalFrame} containing a
+     *          {@code JOptionPane}
+     * @exception RuntimeException if {@code parentComponent} does
      *          not have a valid parent
      */
     public JInternalFrame createInternalFrame(Component parentComponent,
                                  String title) {
         Container parent =

@@ -1568,21 +1568,21 @@
 
         return iFrame;
     }
 
     /**
-     * Returns the specified component's <code>Frame</code>.
+     * Returns the specified component's {@code Frame}.
      *
-     * @param parentComponent the <code>Component</code> to check for a
-     *          <code>Frame</code>
-     * @return the <code>Frame</code> that contains the component,
-     *          or <code>getRootFrame</code>
-     *          if the component is <code>null</code>,
-     *          or does not have a valid <code>Frame</code> parent
+     * @param parentComponent the {@code Component} to check for a
+     *          {@code Frame}
+     * @return the {@code Frame} that contains the component,
+     *          or {@code getRootFrame}
+     *          if the component is {@code null},
+     *          or does not have a valid {@code Frame} parent
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see #getRootFrame
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static Frame getFrameForComponent(Component parentComponent)
         throws HeadlessException {

@@ -1592,23 +1592,23 @@
             return (Frame)parentComponent;
         return JOptionPane.getFrameForComponent(parentComponent.getParent());
     }
 
     /**
-     * Returns the specified component's toplevel <code>Frame</code> or
-     * <code>Dialog</code>.
+     * Returns the specified component's toplevel {@code Frame} or
+     * {@code Dialog}.
      *
-     * @param parentComponent the <code>Component</code> to check for a
-     *          <code>Frame</code> or <code>Dialog</code>
-     * @return the <code>Frame</code> or <code>Dialog</code> that
+     * @param parentComponent the {@code Component} to check for a
+     *          {@code Frame} or {@code Dialog}
+     * @return the {@code Frame} or {@code Dialog} that
      *          contains the component, or the default
-     *          frame if the component is <code>null</code>,
+     *          frame if the component is {@code null},
      *          or does not have a valid
-     *          <code>Frame</code> or <code>Dialog</code> parent
+     *          {@code Frame} or {@code Dialog} parent
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     static Window getWindowForComponent(Component parentComponent)
         throws HeadlessException {
         if (parentComponent == null)

@@ -1620,16 +1620,16 @@
 
 
     /**
      * Returns the specified component's desktop pane.
      *
-     * @param parentComponent the <code>Component</code> to check for a
+     * @param parentComponent the {@code Component} to check for a
      *          desktop
-     * @return the <code>JDesktopPane</code> that contains the component,
-     *          or <code>null</code> if the component is <code>null</code>
+     * @return the {@code JDesktopPane} that contains the component,
+     *          or {@code null} if the component is {@code null}
      *          or does not have an ancestor that is a
-     *          <code>JInternalFrame</code>
+     *          {@code JInternalFrame}
      */
     public static JDesktopPane getDesktopPaneForComponent(Component parentComponent) {
         if(parentComponent == null)
             return null;
         if(parentComponent instanceof JDesktopPane)

@@ -1644,28 +1644,28 @@
      * not provided.
      * <p>
      * <strong>Note:</strong>
      * It is recommended that rather than using this method you supply a valid parent.
      *
-     * @param newRootFrame the default <code>Frame</code> to use
+     * @param newRootFrame the default {@code Frame} to use
      */
     public static void setRootFrame(Frame newRootFrame) {
         if (newRootFrame != null) {
             SwingUtilities.appContextPut(sharedFrameKey, newRootFrame);
         } else {
             SwingUtilities.appContextRemove(sharedFrameKey);
         }
     }
 
     /**
-     * Returns the <code>Frame</code> to use for the class methods in
+     * Returns the {@code Frame} to use for the class methods in
      * which a frame is not provided.
      *
-     * @return the default <code>Frame</code> to use
+     * @return the default {@code Frame} to use
      * @exception HeadlessException if
-     *   <code>GraphicsEnvironment.isHeadless</code> returns
-     *   <code>true</code>
+     *   {@code GraphicsEnvironment.isHeadless} returns
+     *   {@code true}
      * @see #setRootFrame
      * @see java.awt.GraphicsEnvironment#isHeadless
      */
     public static Frame getRootFrame() throws HeadlessException {
         Frame sharedFrame =

@@ -1676,140 +1676,140 @@
         }
         return sharedFrame;
     }
 
     /**
-     * Creates a <code>JOptionPane</code> with a test message.
+     * Creates a {@code JOptionPane} with a test message.
      */
     public JOptionPane() {
         this("JOptionPane message");
     }
 
     /**
-     * Creates a instance of <code>JOptionPane</code> to display a
+     * Creates a instance of {@code JOptionPane} to display a
      * message using the
      * plain-message message type and the default options delivered by
      * the UI.
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      */
     public JOptionPane(Object message) {
         this(message, PLAIN_MESSAGE);
     }
 
     /**
-     * Creates an instance of <code>JOptionPane</code> to display a message
+     * Creates an instance of {@code JOptionPane} to display a message
      * with the specified message type and the default options,
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      */
     public JOptionPane(Object message, int messageType) {
         this(message, messageType, DEFAULT_OPTION);
     }
 
     /**
-     * Creates an instance of <code>JOptionPane</code> to display a message
+     * Creates an instance of {@code JOptionPane} to display a message
      * with the specified message type and options.
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param optionType the options to display in the pane:
-     *                  <code>DEFAULT_OPTION</code>, <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  <code>OK_CANCEL_OPTION</code>
+     *                  {@code DEFAULT_OPTION}, {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  {@code OK_CANCEL_OPTION}
      */
     public JOptionPane(Object message, int messageType, int optionType) {
         this(message, messageType, optionType, null);
     }
 
     /**
-     * Creates an instance of <code>JOptionPane</code> to display a message
+     * Creates an instance of {@code JOptionPane} to display a message
      * with the specified message type, options, and icon.
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param optionType the options to display in the pane:
-     *                  <code>DEFAULT_OPTION</code>, <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  <code>OK_CANCEL_OPTION</code>
-     * @param icon the <code>Icon</code> image to display
+     *                  {@code DEFAULT_OPTION}, {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  {@code OK_CANCEL_OPTION}
+     * @param icon the {@code Icon} image to display
      */
     public JOptionPane(Object message, int messageType, int optionType,
                        Icon icon) {
         this(message, messageType, optionType, icon, null);
     }
 
     /**
-     * Creates an instance of <code>JOptionPane</code> to display a message
+     * Creates an instance of {@code JOptionPane} to display a message
      * with the specified message type, icon, and options.
      * None of the options is initially selected.
      * <p>
      * The options objects should contain either instances of
-     * <code>Component</code>s, (which are added directly) or
-     * <code>Strings</code> (which are wrapped in a <code>JButton</code>).
-     * If you provide <code>Component</code>s, you must ensure that when the
-     * <code>Component</code> is clicked it messages <code>setValue</code>
-     * in the created <code>JOptionPane</code>.
+     * {@code Component}s, (which are added directly) or
+     * {@code Strings} (which are wrapped in a {@code JButton}).
+     * If you provide {@code Component}s, you must ensure that when the
+     * {@code Component} is clicked it messages {@code setValue}
+     * in the created {@code JOptionPane}.
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param optionType the options to display in the pane:
-     *                  <code>DEFAULT_OPTION</code>,
-     *                  <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  <code>OK_CANCEL_OPTION</code>
-     * @param icon the <code>Icon</code> image to display
+     *                  {@code DEFAULT_OPTION},
+     *                  {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  {@code OK_CANCEL_OPTION}
+     * @param icon the {@code Icon} image to display
      * @param options  the choices the user can select
      */
     public JOptionPane(Object message, int messageType, int optionType,
                        Icon icon, Object[] options) {
         this(message, messageType, optionType, icon, options, null);
     }
 
     /**
-     * Creates an instance of <code>JOptionPane</code> to display a message
+     * Creates an instance of {@code JOptionPane} to display a message
      * with the specified message type, icon, and options, with the
      * initially-selected option specified.
      *
-     * @param message the <code>Object</code> to display
+     * @param message the {@code Object} to display
      * @param messageType the type of message to be displayed:
-     *                  <code>ERROR_MESSAGE</code>,
-     *                  <code>INFORMATION_MESSAGE</code>,
-     *                  <code>WARNING_MESSAGE</code>,
-     *                  <code>QUESTION_MESSAGE</code>,
-     *                  or <code>PLAIN_MESSAGE</code>
+     *                  {@code ERROR_MESSAGE},
+     *                  {@code INFORMATION_MESSAGE},
+     *                  {@code WARNING_MESSAGE},
+     *                  {@code QUESTION_MESSAGE},
+     *                  or {@code PLAIN_MESSAGE}
      * @param optionType the options to display in the pane:
-     *                  <code>DEFAULT_OPTION</code>,
-     *                  <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  <code>OK_CANCEL_OPTION</code>
+     *                  {@code DEFAULT_OPTION},
+     *                  {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  {@code OK_CANCEL_OPTION}
      * @param icon the Icon image to display
      * @param options  the choices the user can select
      * @param initialValue the choice that is initially selected; if
-     *                  <code>null</code>, then nothing will be initially selected;
-     *                  only meaningful if <code>options</code> is used
+     *                  {@code null}, then nothing will be initially selected;
+     *                  only meaningful if {@code options} is used
      */
     public JOptionPane(Object message, int messageType, int optionType,
                        Icon icon, Object[] options, Object initialValue) {
 
         this.message = message;

@@ -1824,11 +1824,11 @@
     }
 
     /**
      * Sets the UI object which implements the {@literal L&F} for this component.
      *
-     * @param ui  the <code>OptionPaneUI</code> {@literal L&F} object
+     * @param ui  the {@code OptionPaneUI} {@literal L&F} object
      * @see UIDefaults#getUI
      * @beaninfo
      *       bound: true
      *      hidden: true
      * description: The UI object that implements the optionpane's LookAndFeel

@@ -1841,20 +1841,20 @@
     }
 
     /**
      * Returns the UI object which implements the {@literal L&F} for this component.
      *
-     * @return the <code>OptionPaneUI</code> object
+     * @return the {@code OptionPaneUI} object
      */
     public OptionPaneUI getUI() {
         return (OptionPaneUI)ui;
     }
 
     /**
-     * Notification from the <code>UIManager</code> that the {@literal L&F} has changed.
+     * Notification from the {@code UIManager} that the {@literal L&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() {
         setUI((OptionPaneUI)UIManager.getUI(this));

@@ -1874,11 +1874,11 @@
     }
 
 
     /**
      * Sets the option pane's message-object.
-     * @param newMessage the <code>Object</code> to display
+     * @param newMessage the {@code Object} to display
      * @see #getMessage
      *
      * @beaninfo
      *   preferred: true
      *   bound: true

@@ -1893,20 +1893,20 @@
 
     /**
      * Returns the message-object this pane displays.
      * @see #setMessage
      *
-     * @return the <code>Object</code> that is displayed
+     * @return the {@code Object} that is displayed
      */
     public Object getMessage() {
         return message;
     }
 
     /**
-     * Sets the icon to display. If non-<code>null</code>, the look and feel
+     * Sets the icon to display. If non-{@code null}, the look and feel
      * does not provide an icon.
-     * @param newIcon the <code>Icon</code> to display
+     * @param newIcon the {@code Icon} to display
      *
      * @see #getIcon
      * @beaninfo
      *   preferred: true
      *       bound: true

@@ -1919,11 +1919,11 @@
         firePropertyChange(ICON_PROPERTY, oldIcon, icon);
     }
 
     /**
      * Returns the icon this pane displays.
-     * @return the <code>Icon</code> that is displayed
+     * @return the {@code Icon} that is displayed
      *
      * @see #setIcon
      */
     public Icon getIcon() {
         return icon;

@@ -1945,36 +1945,36 @@
         value = newValue;
         firePropertyChange(VALUE_PROPERTY, oldValue, value);
     }
 
     /**
-     * Returns the value the user has selected. <code>UNINITIALIZED_VALUE</code>
-     * implies the user has not yet made a choice, <code>null</code> means the
+     * Returns the value the user has selected. {@code UNINITIALIZED_VALUE}
+     * implies the user has not yet made a choice, {@code null} means the
      * user closed the window with out choosing anything. Otherwise
      * the returned value will be one of the options defined in this
      * object.
      *
-     * @return the <code>Object</code> chosen by the user,
-     *         <code>UNINITIALIZED_VALUE</code>
-     *         if the user has not yet made a choice, or <code>null</code> if
+     * @return the {@code Object} chosen by the user,
+     *         {@code UNINITIALIZED_VALUE}
+     *         if the user has not yet made a choice, or {@code null} if
      *         the user closed the window without making a choice
      *
      * @see #setValue
      */
     public Object getValue() {
         return value;
     }
 
     /**
      * Sets the options this pane displays. If an element in
-     * <code>newOptions</code> is a <code>Component</code>
+     * {@code newOptions} is a {@code Component}
      * it is added directly to the pane,
      * otherwise a button is created for the element.
      *
-     * @param newOptions an array of <code>Objects</code> that create the
+     * @param newOptions an array of {@code Objects} that create the
      *          buttons the user can click on, or arbitrary
-     *          <code>Components</code> to add to the pane
+     *          {@code Components} to add to the pane
      *
      * @see #getOptions
      * @beaninfo
      *       bound: true
      * description: The option pane's options objects.

@@ -1986,11 +1986,11 @@
         firePropertyChange(OPTIONS_PROPERTY, oldOptions, options);
     }
 
     /**
      * Returns the choices the user can make.
-     * @return the array of <code>Objects</code> that give the user's choices
+     * @return the array of {@code Objects} that give the user's choices
      *
      * @see #setOptions
      */
     public Object[] getOptions() {
         if(options != null) {

@@ -2003,14 +2003,14 @@
         return options;
     }
 
     /**
      * Sets the initial value that is to be enabled -- the
-     * <code>Component</code>
+     * {@code Component}
      * that has the focus when the pane is initially displayed.
      *
-     * @param newInitialValue the <code>Object</code> that gets the initial
+     * @param newInitialValue the {@code Object} that gets the initial
      *                         keyboard focus
      *
      * @see #getInitialValue
      * @beaninfo
      *   preferred: true

@@ -2025,11 +2025,11 @@
     }
 
     /**
      * Returns the initial value.
      *
-     * @return the <code>Object</code> that gets the initial keyboard focus
+     * @return the {@code Object} that gets the initial keyboard focus
      *
      * @see #setInitialValue
      */
     public Object getInitialValue() {
         return initialValue;

@@ -2037,16 +2037,16 @@
 
     /**
      * Sets the option pane's message type.
      * The message type is used by the Look and Feel to determine the
      * icon to display (if not supplied) as well as potentially how to
-     * lay out the <code>parentComponent</code>.
+     * lay out the {@code parentComponent}.
      * @param newType an integer specifying the kind of message to display:
-     *                <code>ERROR_MESSAGE</code>, <code>INFORMATION_MESSAGE</code>,
-     *                <code>WARNING_MESSAGE</code>,
-     *                <code>QUESTION_MESSAGE</code>, or <code>PLAIN_MESSAGE</code>
-     * @exception RuntimeException if <code>newType</code> is not one of the
+     *                {@code ERROR_MESSAGE}, {@code INFORMATION_MESSAGE},
+     *                {@code WARNING_MESSAGE},
+     *                {@code QUESTION_MESSAGE}, or {@code PLAIN_MESSAGE}
+     * @exception RuntimeException if {@code newType} is not one of the
      *          legal values listed above
 
      * @see #getMessageType
      * @beaninfo
      *   preferred: true

@@ -2086,15 +2086,15 @@
     /**
      * Sets the options to display.
      * The option type is used by the Look and Feel to
      * determine what buttons to show (unless options are supplied).
      * @param newType an integer specifying the options the {@literal L&F} is to display:
-     *                  <code>DEFAULT_OPTION</code>,
-     *                  <code>YES_NO_OPTION</code>,
-     *                  <code>YES_NO_CANCEL_OPTION</code>,
-     *                  or <code>OK_CANCEL_OPTION</code>
-     * @exception RuntimeException if <code>newType</code> is not one of
+     *                  {@code DEFAULT_OPTION},
+     *                  {@code YES_NO_OPTION},
+     *                  {@code YES_NO_CANCEL_OPTION},
+     *                  or {@code OK_CANCEL_OPTION}
+     * @exception RuntimeException if {@code newType} is not one of
      *          the legal values listed above
      *
      * @see #getOptionType
      * @see #setOptions
      * @beaninfo

@@ -2132,19 +2132,19 @@
     }
 
     /**
      * Sets the input selection values for a pane that provides the user
      * with a list of items to choose from. (The UI provides a widget
-     * for choosing one of the values.)  A <code>null</code> value
+     * for choosing one of the values.)  A {@code null} value
      * implies the user can input whatever they wish, usually by means
-     * of a <code>JTextField</code>.
+     * of a {@code JTextField}.
      * <p>
-     * Sets <code>wantsInput</code> to true. Use
-     * <code>setInitialSelectionValue</code> to specify the initially-chosen
-     * value. After the pane as been enabled, <code>inputValue</code> is
+     * Sets {@code wantsInput} to true. Use
+     * {@code setInitialSelectionValue} to specify the initially-chosen
+     * value. After the pane as been enabled, {@code inputValue} is
      * set to the value the user has selected.
-     * @param newValues an array of <code>Objects</code> the user to be
+     * @param newValues an array of {@code Objects} the user to be
      *                  displayed
      *                  (usually in a list or combo-box) from which
      *                  the user can make a selection
      * @see #setWantsInput
      * @see #setInitialSelectionValue

@@ -2163,20 +2163,20 @@
     }
 
     /**
      * Returns the input selection values.
      *
-     * @return the array of <code>Objects</code> the user can select
+     * @return the array of {@code Objects} the user can select
      * @see #setSelectionValues
      */
     public Object[] getSelectionValues() {
         return selectionValues;
     }
 
     /**
      * Sets the input value that is initially displayed as selected to the user.
-     * Only used if <code>wantsInput</code> is true.
+     * Only used if {@code wantsInput} is true.
      * @param newValue the initially selected value
      * @see #setSelectionValues
      * @see #getInitialSelectionValue
      * @beaninfo
      *       bound: true

@@ -2201,17 +2201,17 @@
         return initialSelectionValue;
     }
 
     /**
      * Sets the input value that was selected or input by the user.
-     * Only used if <code>wantsInput</code> is true.  Note that this method
+     * Only used if {@code wantsInput} is true.  Note that this method
      * is invoked internally by the option pane (in response to user action)
      * and should generally not be called by client programs.  To set the
      * input value initially displayed as selected to the user, use
-     * <code>setInitialSelectionValue</code>.
+     * {@code setInitialSelectionValue}.
      *
-     * @param newValue the <code>Object</code> used to set the
+     * @param newValue the {@code Object} used to set the
      *          value that the user specified (usually in a text field)
      * @see #setSelectionValues
      * @see #setInitialSelectionValue
      * @see #setWantsInput
      * @see #getInputValue

@@ -2226,16 +2226,16 @@
         inputValue = newValue;
         firePropertyChange(INPUT_VALUE_PROPERTY, oldValue, newValue);
     }
 
     /**
-     * Returns the value the user has input, if <code>wantsInput</code>
+     * Returns the value the user has input, if {@code wantsInput}
      * is true.
      *
-     * @return the <code>Object</code> the user specified,
+     * @return the {@code Object} the user specified,
      *          if it was one of the objects, or a
-     *          <code>String</code> if it was a value typed into a
+     *          {@code String} if it was a value typed into a
      *          field
      * @see #setSelectionValues
      * @see #setWantsInput
      * @see #setInputValue
      */

@@ -2243,27 +2243,27 @@
         return inputValue;
     }
 
     /**
      * Returns the maximum number of characters to place on a line in a
-     * message. Default is to return <code>Integer.MAX_VALUE</code>.
+     * message. Default is to return {@code Integer.MAX_VALUE}.
      * The value can be
      * changed by overriding this method in a subclass.
      *
      * @return an integer giving the maximum number of characters on a line
      */
     public int getMaxCharactersPerLineCount() {
         return Integer.MAX_VALUE;
     }
 
     /**
-     * Sets the <code>wantsInput</code> property.
-     * If <code>newValue</code> is true, an input component
+     * Sets the {@code wantsInput} property.
+     * If {@code newValue} is true, an input component
      * (such as a text field or combo box) whose parent is
-     * <code>parentComponent</code> is provided to
-     * allow the user to input a value. If <code>getSelectionValues</code>
-     * returns a non-<code>null</code> array, the input value is one of the
+     * {@code parentComponent} is provided to
+     * allow the user to input a value. If {@code getSelectionValues}
+     * returns a non-{@code null} array, the input value is one of the
      * objects in that array. Otherwise the input value is whatever
      * the user inputs.
      * <p>
      * This is a bound property.
      *

@@ -2282,11 +2282,11 @@
         wantsInput = newValue;
         firePropertyChange(WANTS_INPUT_PROPERTY, oldValue, newValue);
     }
 
     /**
-     * Returns the value of the <code>wantsInput</code> property.
+     * Returns the value of the {@code wantsInput} property.
      *
      * @return true if an input component will be provided
      * @see #setWantsInput
      */
     public boolean getWantsInput() {

@@ -2461,18 +2461,18 @@
         }
     }
 
 
     /**
-     * Returns a string representation of this <code>JOptionPane</code>.
+     * Returns a string representation of this {@code JOptionPane}.
      * 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 <code>JOptionPane</code>
+     * @return  a string representation of this {@code JOptionPane}
      */
     protected String paramString() {
         String iconString = (icon != null ?
                              icon.toString() : "");
         String initialValueString = (initialValue != null ?

@@ -2516,14 +2516,14 @@
 ///////////////////
 // Accessibility support
 ///////////////////
 
     /**
-     * Returns the <code>AccessibleContext</code> associated with this JOptionPane.
-     * For option panes, the <code>AccessibleContext</code> takes the form of an
-     * <code>AccessibleJOptionPane</code>.
-     * A new <code>AccessibleJOptionPane</code> instance is created if necessary.
+     * Returns the {@code AccessibleContext} associated with this JOptionPane.
+     * For option panes, the {@code AccessibleContext} takes the form of an
+     * {@code AccessibleJOptionPane}.
+     * A new {@code AccessibleJOptionPane} instance is created if necessary.
      *
      * @return an AccessibleJOptionPane that serves as the
      *         AccessibleContext of this AccessibleJOptionPane
      * @beaninfo
      *       expert: true

@@ -2536,21 +2536,21 @@
         return accessibleContext;
     }
 
     /**
      * This class implements accessibility support for the
-     * <code>JOptionPane</code> class.  It provides an implementation of the
+     * {@code JOptionPane} class.  It provides an implementation of the
      * Java Accessibility API appropriate to option pane 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 AccessibleJOptionPane extends AccessibleJComponent {
 
< prev index next >