1 /*

     2  * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package javax.swing;

    27 

    28 import java.awt.BorderLayout;

    29 import java.awt.Component;

    30 import java.awt.Container;

    31 import java.awt.Dialog;

    32 import java.awt.Dimension;

    33 import java.awt.KeyboardFocusManager;

    34 import java.awt.Frame;

    35 import java.awt.Point;

    36 import java.awt.HeadlessException;

    37 import java.awt.Toolkit;

    38 import java.awt.Window;

    39 import java.beans.PropertyChangeEvent;

    40 import java.beans.PropertyChangeListener;

    41 import java.awt.event.WindowListener;

    42 import java.awt.event.WindowAdapter;

    43 import java.awt.event.WindowEvent;

    44 import java.awt.event.ComponentAdapter;

    45 import java.awt.event.ComponentEvent;

    46 import java.io.IOException;

    47 import java.io.ObjectInputStream;

    48 import java.io.ObjectOutputStream;

    49 import java.io.Serializable;

    50 import java.lang.reflect.Method;

    51 import java.lang.reflect.InvocationTargetException;

    52 import java.security.AccessController;

    53 import java.security.PrivilegedAction;

    54 import java.util.Vector;

    55 import javax.swing.plaf.OptionPaneUI;

    56 import javax.swing.event.InternalFrameEvent;

    57 import javax.swing.event.InternalFrameAdapter;

    58 import javax.accessibility.*;

    59 import static javax.swing.ClientPropertyKey.PopupFactory_FORCE_HEAVYWEIGHT_POPUP;

    60 

    61 /**

    62  * <code>JOptionPane</code> makes it easy to pop up a standard dialog box that

    63  * prompts users for a value or informs them of something.

    64  * For information about using <code>JOptionPane</code>, see

    65  * <a

    66  href="http://java.sun.com/docs/books/tutorial/uiswing/components/dialog.html">How to Make Dialogs</a>,

    67  * a section in <em>The Java Tutorial</em>.

    68  *

    69  * <p>

    70  *

    71  * While the <code>JOptionPane</code>

    72  * class may appear complex because of the large number of methods, almost

    73  * all uses of this class are one-line calls to one of the static

    74  * <code>showXxxDialog</code> methods shown below:

    75  * <blockquote>

    76  *

    77  *

    78  * <table border=1 summary="Common JOptionPane method names and their descriptions">

    79  * <tr>

    80  *    <th>Method Name</th>

    81  *    <th>Description</th>

    82  * </tr>

    83  * <tr>

    84  *    <td>showConfirmDialog</td>

    85  *    <td>Asks a confirming question, like yes/no/cancel.</td>

    86  * </tr>

    87  * <tr>

    88  *    <td>showInputDialog</td>

    89  *    <td>Prompt for some input.</td>

    90  * </tr>

    91  * <tr>

    92  *   <td>showMessageDialog</td>

    93  *   <td>Tell the user about something that has happened.</td>

    94  * </tr>

    95  * <tr>

    96  *   <td>showOptionDialog</td>

    97  *   <td>The Grand Unification of the above three.</td>

    98  * </tr>

    99  * </table>

   100  *

   101  * </blockquote>

   102  * Each of these methods also comes in a <code>showInternalXXX</code>

   103  * flavor, which uses an internal frame to hold the dialog box (see

   104  * {@link JInternalFrame}).

   105  * Multiple convenience methods have also been defined -- overloaded

   106  * versions of the basic methods that use different parameter lists.

   107  * <p>

   108  * All dialogs are modal. Each <code>showXxxDialog</code> method blocks

   109  * the caller until the user's interaction is complete.

   110  * <p>

   111  *

   112  * <table cellspacing=6 cellpadding=4 border=0 align=right summary="layout">

   113  * <tr>

   114  *  <td bgcolor=#FFe0d0 rowspan=2>icon</td>

   115  *  <td bgcolor=#FFe0d0>message</td>

   116  * </tr>

   117  * <tr>

   118  *  <td bgcolor=#FFe0d0>input value</td>

   119  * </tr>

   120  * <tr>

   121  *   <td bgcolor=#FFe0d0 colspan=2>option buttons</td>

   122  * </tr>

   123  * </table>

   124  *

   125  * The basic appearance of one of these dialog boxes is generally

   126  * similar to the picture at the right, although the various

   127  * look-and-feels are

   128  * ultimately responsible for the final result.  In particular, the

   129  * look-and-feels will adjust the layout to accommodate the option pane's

   130  * <code>ComponentOrientation</code> property.

   131  * <br clear=all>

   132  * <p>

   133  * <b>Parameters:</b><br>

   134  * The parameters to these methods follow consistent patterns:

   135  * <blockquote>

   136  * <dl compact>

   137  * <dt>parentComponent<dd>

   138  * Defines the <code>Component</code> that is to be the parent of this

   139  * dialog box.

   140  * It is used in two ways: the <code>Frame</code> that contains

   141  * it is used as the <code>Frame</code>

   142  * parent for the dialog box, and its screen coordinates are used in

   143  * the placement of the dialog box. In general, the dialog box is placed

   144  * just below the component. This parameter may be <code>null</code>,

   145  * in which case a default <code>Frame</code> is used as the parent,

   146  * and the dialog will be

   147  * centered on the screen (depending on the L&F).

   148  * <dt><a name=message>message</a><dd>

   149  * A descriptive message to be placed in the dialog box.

   150  * In the most common usage, message is just a <code>String</code> or

   151  * <code>String</code> constant.

   152  * However, the type of this parameter is actually <code>Object</code>. Its

   153  * interpretation depends on its type:

   154  * <dl compact>

   155  * <dt>Object[]<dd>An array of objects is interpreted as a series of

   156  *                 messages (one per object) arranged in a vertical stack.

   157  *                 The interpretation is recursive -- each object in the

   158  *                 array is interpreted according to its type.

   159  * <dt>Component<dd>The <code>Component</code> is displayed in the dialog.

   160  * <dt>Icon<dd>The <code>Icon</code> is wrapped in a <code>JLabel</code>

   161  *               and displayed in the dialog.

   162  * <dt>others<dd>The object is converted to a <code>String</code> by calling

   163  *               its <code>toString</code> method. The result is wrapped in a

   164  *               <code>JLabel</code> and displayed.

   165  * </dl>

   166  * <dt>messageType<dd>Defines the style of the message. The Look and Feel

   167  * manager may lay out the dialog differently depending on this value, and

   168  * will often provide a default icon. The possible values are:

   169  * <ul>

   170  * <li><code>ERROR_MESSAGE</code>

   171  * <li><code>INFORMATION_MESSAGE</code>

   172  * <li><code>WARNING_MESSAGE</code>

   173  * <li><code>QUESTION_MESSAGE</code>

   174  * <li><code>PLAIN_MESSAGE</code>

   175  * </ul>

   176  * <dt>optionType<dd>Defines the set of option buttons that appear at

   177  * the bottom of the dialog box:

   178  * <ul>

   179  * <li><code>DEFAULT_OPTION</code>

   180  * <li><code>YES_NO_OPTION</code>

   181  * <li><code>YES_NO_CANCEL_OPTION</code>

   182  * <li><code>OK_CANCEL_OPTION</code>

   183  * </ul>

   184  * You aren't limited to this set of option buttons.  You can provide any

   185  * buttons you want using the options parameter.

   186  * <dt>options<dd>A more detailed description of the set of option buttons

   187  * that will appear at the bottom of the dialog box.

   188  * The usual value for the options parameter is an array of

   189  * <code>String</code>s. But

   190  * the parameter type is an array of <code>Objects</code>.

   191  * A button is created for each object depending on its type:

   192  * <dl compact>

   193  * <dt>Component<dd>The component is added to the button row directly.

   194  * <dt>Icon<dd>A <code>JButton</code> is created with this as its label.

   195  * <dt>other<dd>The <code>Object</code> is converted to a string using its

   196  *              <code>toString</code> method and the result is used to

   197  *              label a <code>JButton</code>.

   198  * </dl>

   199  * <dt>icon<dd>A decorative icon to be placed in the dialog box. A default

   200  * value for this is determined by the <code>messageType</code> parameter.

   201  * <dt>title<dd>The title for the dialog box.

   202  * <dt>initialValue<dd>The default selection (input value).

   203  * </dl>

   204  * </blockquote>

   205  * <p>

   206  * When the selection is changed, <code>setValue</code> is invoked,

   207  * which generates a <code>PropertyChangeEvent</code>.

   208  * <p>

   209  * If a <code>JOptionPane</code> has configured to all input

   210  * <code>setWantsInput</code>

   211  * the bound property <code>JOptionPane.INPUT_VALUE_PROPERTY</code>

   212  *  can also be listened

   213  * to, to determine when the user has input or selected a value.

   214  * <p>

   215  * When one of the <code>showXxxDialog</code> methods returns an integer,

   216  * the possible values are:

   217  * <ul>

   218  * <li><code>YES_OPTION</code>

   219  * <li><code>NO_OPTION</code>

   220  * <li><code>CANCEL_OPTION</code>

   221  * <li><code>OK_OPTION</code>

   222  * <li><code>CLOSED_OPTION</code>

   223  * </ul>

   224  * <b>Examples:</b>

   225  * <dl>

   226  * <dt>Show an error dialog that displays the message, 'alert':

   227  * <dd><code>

   228  * JOptionPane.showMessageDialog(null, "alert", "alert", JOptionPane.ERROR_MESSAGE);

   229  * </code><p>

   230  * <dt>Show an internal information dialog with the message, 'information':

   231  * <dd><code>

   232  * JOptionPane.showInternalMessageDialog(frame, "information",<br>

   233  *             <ul><ul>"information", JOptionPane.INFORMATION_MESSAGE);</ul></ul>

   234  * </code><p>

   235  * <dt>Show an information panel with the options yes/no and message 'choose one':

   236  * <dd><code>JOptionPane.showConfirmDialog(null,

   237  *             <ul><ul>"choose one", "choose one", JOptionPane.YES_NO_OPTION);</ul></ul>

   238  * </code><p>

   239  * <dt>Show an internal information dialog with the options yes/no/cancel and

   240  * message 'please choose one' and title information:

   241  * <dd><code>JOptionPane.showInternalConfirmDialog(frame,

   242  *             <ul><ul>"please choose one", "information",</ul></ul>

   243  *             <ul><ul>JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);</ul></ul>

   244  * </code><p>

   245  * <dt>Show a warning dialog with the options OK, CANCEL, title 'Warning', and

   246  * message 'Click OK to continue':

   247  * <dd><code>

   248  * Object[] options = { "OK", "CANCEL" };<br>

   249  * JOptionPane.showOptionDialog(null, "Click OK to continue", "Warning",

   250  *             <ul><ul>JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,</ul></ul>

   251  *             <ul><ul>null, options, options[0]);</ul></ul>

   252  * </code><p>

   253  * <dt>Show a dialog asking the user to type in a String:

   254  * <dd><code>

   255  * String inputValue = JOptionPane.showInputDialog("Please input a value");

   256  * </code><p>

   257  * <dt>Show a dialog asking the user to select a String:

   258  * <dd><code>

   259  * Object[] possibleValues = { "First", "Second", "Third" };<br>

   260  * Object selectedValue = JOptionPane.showInputDialog(null,

   261  *             <ul><ul>"Choose one", "Input",</ul></ul>

   262  *             <ul><ul>JOptionPane.INFORMATION_MESSAGE, null,</ul></ul>

   263  *             <ul><ul>possibleValues, possibleValues[0]);</ul></ul>

   264  * </code><p>

   265  * </dl>

   266  * <b>Direct Use:</b><br>

   267  * To create and use an <code>JOptionPane</code> directly, the

   268  * standard pattern is roughly as follows:

   269  * <pre>

   270  *     JOptionPane pane = new JOptionPane(<i>arguments</i>);

   271  *     pane.set<i>.Xxxx(...); // Configure</i>

   272  *     JDialog dialog = pane.createDialog(<i>parentComponent, title</i>);

   273  *     dialog.show();

   274  *     Object selectedValue = pane.getValue();

   275  *     if(selectedValue == null)

   276  *       return CLOSED_OPTION;

   277  *     <i>//If there is <b>not</b> an array of option buttons:</i>

   278  *     if(options == null) {

   279  *       if(selectedValue instanceof Integer)

   280  *          return ((Integer)selectedValue).intValue();

   281  *       return CLOSED_OPTION;

   282  *     }

   283  *     <i>//If there is an array of option buttons:</i>

   284  *     for(int counter = 0, maxCounter = options.length;

   285  *        counter < maxCounter; counter++) {

   286  *        if(options[counter].equals(selectedValue))

   287  *        return counter;

   288  *     }

   289  *     return CLOSED_OPTION;

   290  * </pre>

   291  * <p>

   292  * <strong>Warning:</strong> Swing is not thread safe. For more

   293  * information see <a

   294  * href="package-summary.html#threading">Swing's Threading

   295  * Policy</a>.

   296  * <p>

   297  * <strong>Warning:</strong>

   298  * Serialized objects of this class will not be compatible with

   299  * future Swing releases. The current serialization support is

   300  * appropriate for short term storage or RMI between applications running

   301  * the same version of Swing.  As of 1.4, support for long term storage

   302  * of all JavaBeans<sup><font size="-2">TM</font></sup>

   303  * has been added to the <code>java.beans</code> package.

   304  * Please see {@link java.beans.XMLEncoder}.

   305  *

   306  * @see JInternalFrame

   307  *

   308  * @beaninfo

   309  *      attribute: isContainer true

   310  *    description: A component which implements standard dialog box controls.

   311  *

   312  * @author James Gosling

   313  * @author Scott Violet

   314  */

   315 public class JOptionPane extends JComponent implements Accessible

   316 {

   317     /**

   318      * @see #getUIClassID

   319      * @see #readObject

   320      */

   321     private static final String uiClassID = "OptionPaneUI";

   322 

   323     /**

   324      * Indicates that the user has not yet selected a value.

   325      */

   326     public static final Object      UNINITIALIZED_VALUE = "uninitializedValue";

   327 

   328     //

   329     // Option types

   330     //

   331 

   332     /**

   333      * Type meaning Look and Feel should not supply any options -- only

   334      * use the options from the <code>JOptionPane</code>.

   335      */

   336     public static final int         DEFAULT_OPTION = -1;

   337     /** Type used for <code>showConfirmDialog</code>. */

   338     public static final int         YES_NO_OPTION = 0;

   339     /** Type used for <code>showConfirmDialog</code>. */

   340     public static final int         YES_NO_CANCEL_OPTION = 1;

   341     /** Type used for <code>showConfirmDialog</code>. */

   342     public static final int         OK_CANCEL_OPTION = 2;

   343 

   344     //

   345     // Return values.

   346     //

   347     /** Return value from class method if YES is chosen. */

   348     public static final int         YES_OPTION = 0;

   349     /** Return value from class method if NO is chosen. */

   350     public static final int         NO_OPTION = 1;

   351     /** Return value from class method if CANCEL is chosen. */

   352     public static final int         CANCEL_OPTION = 2;

   353     /** Return value form class method if OK is chosen. */

   354     public static final int         OK_OPTION = 0;

   355     /** Return value from class method if user closes window without selecting

   356      * anything, more than likely this should be treated as either a

   357      * <code>CANCEL_OPTION</code> or <code>NO_OPTION</code>. */

   358     public static final int         CLOSED_OPTION = -1;

   359 

   360     //

   361     // Message types. Used by the UI to determine what icon to display,

   362     // and possibly what behavior to give based on the type.

   363     //

   364     /** Used for error messages. */

   365     public static final int  ERROR_MESSAGE = 0;

   366     /** Used for information messages. */

   367     public static final int  INFORMATION_MESSAGE = 1;

   368     /** Used for warning messages. */

   369     public static final int  WARNING_MESSAGE = 2;

   370     /** Used for questions. */

   371     public static final int  QUESTION_MESSAGE = 3;

   372     /** No icon is used. */

   373     public static final int   PLAIN_MESSAGE = -1;

   374 

   375     /** Bound property name for <code>icon</code>. */

   376     public static final String      ICON_PROPERTY = "icon";

   377     /** Bound property name for <code>message</code>. */

   378     public static final String      MESSAGE_PROPERTY = "message";

   379     /** Bound property name for <code>value</code>. */

   380     public static final String      VALUE_PROPERTY = "value";

   381     /** Bound property name for <code>option</code>. */

   382     public static final String      OPTIONS_PROPERTY = "options";

   383     /** Bound property name for <code>initialValue</code>. */

   384     public static final String      INITIAL_VALUE_PROPERTY = "initialValue";

   385     /** Bound property name for <code>type</code>. */

   386     public static final String      MESSAGE_TYPE_PROPERTY = "messageType";

   387     /** Bound property name for <code>optionType</code>. */

   388     public static final String      OPTION_TYPE_PROPERTY = "optionType";

   389     /** Bound property name for <code>selectionValues</code>. */

   390     public static final String      SELECTION_VALUES_PROPERTY = "selectionValues";

   391     /** Bound property name for <code>initialSelectionValue</code>. */

   392     public static final String      INITIAL_SELECTION_VALUE_PROPERTY = "initialSelectionValue";

   393     /** Bound property name for <code>inputValue</code>. */

   394     public static final String      INPUT_VALUE_PROPERTY = "inputValue";

   395     /** Bound property name for <code>wantsInput</code>. */

   396     public static final String      WANTS_INPUT_PROPERTY = "wantsInput";

   397 

   398     /** Icon used in pane. */

   399     transient protected Icon                  icon;

   400     /** Message to display. */

   401     transient protected Object                message;

   402     /** Options to display to the user. */

   403     transient protected Object[]              options;

   404     /** Value that should be initially selected in <code>options</code>. */

   405     transient protected Object                initialValue;

   406     /** Message type. */

   407     protected int                   messageType;

   408     /**

   409      * Option type, one of <code>DEFAULT_OPTION</code>,

   410      * <code>YES_NO_OPTION</code>,

   411      * <code>YES_NO_CANCEL_OPTION</code> or

   412      * <code>OK_CANCEL_OPTION</code>.

   413      */

   414     protected int                   optionType;

   415     /** Currently selected value, will be a valid option, or

   416      * <code>UNINITIALIZED_VALUE</code> or <code>null</code>. */

   417     transient protected Object                value;

   418     /** Array of values the user can choose from. Look and feel will

   419      * provide the UI component to choose this from. */

   420     protected transient Object[]              selectionValues;

   421     /** Value the user has input. */

   422     protected transient Object                inputValue;

   423     /** Initial value to select in <code>selectionValues</code>. */

   424     protected transient Object                initialSelectionValue;

   425     /** If true, a UI widget will be provided to the user to get input. */

   426     protected boolean                         wantsInput;

   427 

   428 

   429     /**

   430      * Shows a question-message dialog requesting input from the user. The

   431      * dialog uses the default frame, which usually means it is centered on

   432      * the screen.

   433      *

   434      * @param message the <code>Object</code> to display

   435      * @exception HeadlessException if

   436      *   <code>GraphicsEnvironment.isHeadless</code> returns

   437      *   <code>true</code>

   438      * @see java.awt.GraphicsEnvironment#isHeadless

   439      */

   440     public static String showInputDialog(Object message)

   441         throws HeadlessException {

   442         return showInputDialog(null, message);

   443     }

   444 

   445     /**

   446      * Shows a question-message dialog requesting input from the user, with

   447      * the input value initialized to <code>initialSelectionValue</code>. The

   448      * dialog uses the default frame, which usually means it is centered on

   449      * the screen.

   450      *

   451      * @param message the <code>Object</code> to display

   452      * @param initialSelectionValue the value used to initialize the input

   453      *                 field

   454      * @since 1.4

   455      */

   456     public static String showInputDialog(Object message, Object initialSelectionValue) {

   457         return showInputDialog(null, message, initialSelectionValue);

   458     }

   459 

   460     /**

   461      * Shows a question-message dialog requesting input from the user

   462      * parented to <code>parentComponent</code>.

   463      * The dialog is displayed on top of the <code>Component</code>'s

   464      * frame, and is usually positioned below the <code>Component</code>.

   465      *

   466      * @param parentComponent  the parent <code>Component</code> for the

   467      *          dialog

   468      * @param message  the <code>Object</code> to display

   469      * @exception HeadlessException if

   470      *    <code>GraphicsEnvironment.isHeadless</code> returns

   471      *    <code>true</code>

   472      * @see java.awt.GraphicsEnvironment#isHeadless

   473      */

   474     public static String showInputDialog(Component parentComponent,

   475         Object message) throws HeadlessException {

   476         return showInputDialog(parentComponent, message, UIManager.getString(

   477             "OptionPane.inputDialogTitle", parentComponent), QUESTION_MESSAGE);

   478     }

   479 

   480     /**

   481      * Shows a question-message dialog requesting input from the user and

   482      * parented to <code>parentComponent</code>. The input value will be

   483      * initialized to <code>initialSelectionValue</code>.

   484      * The dialog is displayed on top of the <code>Component</code>'s

   485      * frame, and is usually positioned below the <code>Component</code>.

   486      *

   487      * @param parentComponent  the parent <code>Component</code> for the

   488      *          dialog

   489      * @param message the <code>Object</code> to display

   490      * @param initialSelectionValue the value used to initialize the input

   491      *                 field

   492      * @since 1.4

   493      */

   494     public static String showInputDialog(Component parentComponent, Object message,

   495                                          Object initialSelectionValue) {

   496         return (String)showInputDialog(parentComponent, message,

   497                       UIManager.getString("OptionPane.inputDialogTitle",

   498                       parentComponent), QUESTION_MESSAGE, null, null,

   499                       initialSelectionValue);

   500     }

   501 

   502     /**

   503      * Shows a dialog requesting input from the user parented to

   504      * <code>parentComponent</code> with the dialog having the title

   505      * <code>title</code> and message type <code>messageType</code>.

   506      *

   507      * @param parentComponent  the parent <code>Component</code> for the

   508      *                  dialog

   509      * @param message  the <code>Object</code> to display

   510      * @param title    the <code>String</code> to display in the dialog

   511      *                  title bar

   512      * @param messageType the type of message that is to be displayed:

   513      *                  <code>ERROR_MESSAGE</code>,

   514      *                  <code>INFORMATION_MESSAGE</code>,

   515      *                  <code>WARNING_MESSAGE</code>,

   516      *                  <code>QUESTION_MESSAGE</code>,

   517      *                  or <code>PLAIN_MESSAGE</code>

   518      * @exception HeadlessException if

   519      *   <code>GraphicsEnvironment.isHeadless</code> returns

   520      *   <code>true</code>

   521      * @see java.awt.GraphicsEnvironment#isHeadless

   522      */

   523     public static String showInputDialog(Component parentComponent,

   524         Object message, String title, int messageType)

   525         throws HeadlessException {

   526         return (String)showInputDialog(parentComponent, message, title,

   527                                        messageType, null, null, null);

   528     }

   529 

   530     /**

   531      * Prompts the user for input in a blocking dialog where the

   532      * initial selection, possible selections, and all other options can

   533      * be specified. The user will able to choose from

   534      * <code>selectionValues</code>, where <code>null</code> implies the

   535      * user can input

   536      * whatever they wish, usually by means of a <code>JTextField</code>.

   537      * <code>initialSelectionValue</code> is the initial value to prompt

   538      * the user with. It is up to the UI to decide how best to represent

   539      * the <code>selectionValues</code>, but usually a

   540      * <code>JComboBox</code>, <code>JList</code>, or

   541      * <code>JTextField</code> will be used.

   542      *

   543      * @param parentComponent  the parent <code>Component</code> for the

   544      *                  dialog

   545      * @param message  the <code>Object</code> to display

   546      * @param title    the <code>String</code> to display in the

   547      *                  dialog title bar

   548      * @param messageType the type of message to be displayed:

   549      *                  <code>ERROR_MESSAGE</code>,

   550      *                  <code>INFORMATION_MESSAGE</code>,

   551      *                  <code>WARNING_MESSAGE</code>,

   552      *                  <code>QUESTION_MESSAGE</code>,

   553      *                  or <code>PLAIN_MESSAGE</code>

   554      * @param icon     the <code>Icon</code> image to display

   555      * @param selectionValues an array of <code>Object</code>s that

   556      *                  gives the possible selections

   557      * @param initialSelectionValue the value used to initialize the input

   558      *                 field

   559      * @return user's input, or <code>null</code> meaning the user

   560      *                  canceled the input

   561      * @exception HeadlessException if

   562      *   <code>GraphicsEnvironment.isHeadless</code> returns

   563      *   <code>true</code>

   564      * @see java.awt.GraphicsEnvironment#isHeadless

   565      */

   566     public static Object showInputDialog(Component parentComponent,

   567         Object message, String title, int messageType, Icon icon,

   568         Object[] selectionValues, Object initialSelectionValue)

   569         throws HeadlessException {

   570         JOptionPane    pane = new JOptionPane(message, messageType,

   571                                               OK_CANCEL_OPTION, icon,

   572                                               null, null);

   573 

   574         pane.setWantsInput(true);

   575         pane.setSelectionValues(selectionValues);

   576         pane.setInitialSelectionValue(initialSelectionValue);

   577         pane.setComponentOrientation(((parentComponent == null) ?

   578             getRootFrame() : parentComponent).getComponentOrientation());

   579 

   580         int style = styleFromMessageType(messageType);

   581         JDialog dialog = pane.createDialog(parentComponent, title, style);

   582 

   583         pane.selectInitialValue();

   584         dialog.show();

   585         dialog.dispose();

   586 

   587         Object value = pane.getInputValue();

   588 

   589         if (value == UNINITIALIZED_VALUE) {

   590             return null;

   591         }

   592         return value;

   593     }

   594 

   595     /**

   596      * Brings up an information-message dialog titled "Message".

   597      *

   598      * @param parentComponent determines the <code>Frame</code> in

   599      *          which the dialog is displayed; if <code>null</code>,

   600      *          or if the <code>parentComponent</code> has no

   601      *          <code>Frame</code>, a default <code>Frame</code> is used

   602      * @param message   the <code>Object</code> to display

   603      * @exception HeadlessException if

   604      *   <code>GraphicsEnvironment.isHeadless</code> returns

   605      *   <code>true</code>

   606      * @see java.awt.GraphicsEnvironment#isHeadless

   607      */

   608     public static void showMessageDialog(Component parentComponent,

   609         Object message) throws HeadlessException {

   610         showMessageDialog(parentComponent, message, UIManager.getString(

   611                     "OptionPane.messageDialogTitle", parentComponent),

   612                     INFORMATION_MESSAGE);

   613     }

   614 

   615     /**

   616      * Brings up a dialog that displays a message using a default

   617      * icon determined by the <code>messageType</code> parameter.

   618      *

   619      * @param parentComponent determines the <code>Frame</code>

   620      *          in which the dialog is displayed; if <code>null</code>,

   621      *          or if the <code>parentComponent</code> has no

   622      *          <code>Frame</code>, a default <code>Frame</code> is used

   623      * @param message   the <code>Object</code> to display

   624      * @param title     the title string for the dialog

   625      * @param messageType the type of message to be displayed:

   626      *                  <code>ERROR_MESSAGE</code>,

   627      *                  <code>INFORMATION_MESSAGE</code>,

   628      *                  <code>WARNING_MESSAGE</code>,

   629      *                  <code>QUESTION_MESSAGE</code>,

   630      *                  or <code>PLAIN_MESSAGE</code>

   631      * @exception HeadlessException if

   632      *   <code>GraphicsEnvironment.isHeadless</code> returns

   633      *   <code>true</code>

   634      * @see java.awt.GraphicsEnvironment#isHeadless

   635      */

   636     public static void showMessageDialog(Component parentComponent,

   637         Object message, String title, int messageType)

   638         throws HeadlessException {

   639         showMessageDialog(parentComponent, message, title, messageType, null);

   640     }

   641 

   642     /**

   643      * Brings up a dialog displaying a message, specifying all parameters.

   644      *

   645      * @param parentComponent determines the <code>Frame</code> in which the

   646      *                  dialog is displayed; if <code>null</code>,

   647      *                  or if the <code>parentComponent</code> has no

   648      *                  <code>Frame</code>, a

   649      *                  default <code>Frame</code> is used

   650      * @param message   the <code>Object</code> to display

   651      * @param title     the title string for the dialog

   652      * @param messageType the type of message to be displayed:

   653      *                  <code>ERROR_MESSAGE</code>,

   654      *                  <code>INFORMATION_MESSAGE</code>,

   655      *                  <code>WARNING_MESSAGE</code>,

   656      *                  <code>QUESTION_MESSAGE</code>,

   657      *                  or <code>PLAIN_MESSAGE</code>

   658      * @param icon      an icon to display in the dialog that helps the user

   659      *                  identify the kind of message that is being displayed

   660      * @exception HeadlessException if

   661      *   <code>GraphicsEnvironment.isHeadless</code> returns

   662      *   <code>true</code>

   663      * @see java.awt.GraphicsEnvironment#isHeadless

   664      */

   665     public static void showMessageDialog(Component parentComponent,

   666         Object message, String title, int messageType, Icon icon)

   667         throws HeadlessException {

   668         showOptionDialog(parentComponent, message, title, DEFAULT_OPTION,

   669                          messageType, icon, null, null);

   670     }

   671 

   672     /**

   673      * Brings up a dialog with the options <i>Yes</i>,

   674      * <i>No</i> and <i>Cancel</i>; with the

   675      * title, <b>Select an Option</b>.

   676      *

   677      * @param parentComponent determines the <code>Frame</code> in which the

   678      *                  dialog is displayed; if <code>null</code>,

   679      *                  or if the <code>parentComponent</code> has no

   680      *                  <code>Frame</code>, a

   681      *                  default <code>Frame</code> is used

   682      * @param message   the <code>Object</code> to display

   683      * @return an integer indicating the option selected by the user

   684      * @exception HeadlessException if

   685      *   <code>GraphicsEnvironment.isHeadless</code> returns

   686      *   <code>true</code>

   687      * @see java.awt.GraphicsEnvironment#isHeadless

   688      */

   689     public static int showConfirmDialog(Component parentComponent,

   690         Object message) throws HeadlessException {

   691         return showConfirmDialog(parentComponent, message,

   692                                  UIManager.getString("OptionPane.titleText"),

   693                                  YES_NO_CANCEL_OPTION);

   694     }

   695 

   696     /**

   697      * Brings up a dialog where the number of choices is determined

   698      * by the <code>optionType</code> parameter.

   699      *

   700      * @param parentComponent determines the <code>Frame</code> in which the

   701      *                  dialog is displayed; if <code>null</code>,

   702      *                  or if the <code>parentComponent</code> has no

   703      *                  <code>Frame</code>, a

   704      *                  default <code>Frame</code> is used

   705      * @param message   the <code>Object</code> to display

   706      * @param title     the title string for the dialog

   707      * @param optionType an int designating the options available on the dialog:

   708      *                  <code>YES_NO_OPTION</code>,

   709      *                  <code>YES_NO_CANCEL_OPTION</code>,

   710      *                  or <code>OK_CANCEL_OPTION</code>

   711      * @return an int indicating the option selected by the user

   712      * @exception HeadlessException if

   713      *   <code>GraphicsEnvironment.isHeadless</code> returns

   714      *   <code>true</code>

   715      * @see java.awt.GraphicsEnvironment#isHeadless

   716      */

   717     public static int showConfirmDialog(Component parentComponent,

   718         Object message, String title, int optionType)

   719         throws HeadlessException {

   720         return showConfirmDialog(parentComponent, message, title, optionType,

   721                                  QUESTION_MESSAGE);

   722     }

   723 

   724     /**

   725      * Brings up a dialog where the number of choices is determined

   726      * by the <code>optionType</code> parameter, where the

   727      * <code>messageType</code>

   728      * parameter determines the icon to display.

   729      * The <code>messageType</code> parameter is primarily used to supply

   730      * a default icon from the Look and Feel.

   731      *

   732      * @param parentComponent determines the <code>Frame</code> in

   733      *                  which the dialog is displayed; if <code>null</code>,

   734      *                  or if the <code>parentComponent</code> has no

   735      *                  <code>Frame</code>, a

   736      *                  default <code>Frame</code> is used.

   737      * @param message   the <code>Object</code> to display

   738      * @param title     the title string for the dialog

   739      * @param optionType an integer designating the options available

   740      *                   on the dialog: <code>YES_NO_OPTION</code>,

   741      *                  <code>YES_NO_CANCEL_OPTION</code>,

   742      *                  or <code>OK_CANCEL_OPTION</code>

   743      * @param messageType an integer designating the kind of message this is;

   744      *                  primarily used to determine the icon from the pluggable

   745      *                  Look and Feel: <code>ERROR_MESSAGE</code>,

   746      *                  <code>INFORMATION_MESSAGE</code>,

   747      *                  <code>WARNING_MESSAGE</code>,

   748      *                  <code>QUESTION_MESSAGE</code>,

   749      *                  or <code>PLAIN_MESSAGE</code>

   750      * @return an integer indicating the option selected by the user

   751      * @exception HeadlessException if

   752      *   <code>GraphicsEnvironment.isHeadless</code> returns

   753      *   <code>true</code>

   754      * @see java.awt.GraphicsEnvironment#isHeadless

   755      */

   756     public static int showConfirmDialog(Component parentComponent,

   757         Object message, String title, int optionType, int messageType)

   758         throws HeadlessException {

   759         return showConfirmDialog(parentComponent, message, title, optionType,

   760                                 messageType, null);

   761     }

   762 

   763     /**

   764      * Brings up a dialog with a specified icon, where the number of

   765      * choices is determined by the <code>optionType</code> parameter.

   766      * The <code>messageType</code> parameter is primarily used to supply

   767      * a default icon from the look and feel.

   768      *

   769      * @param parentComponent determines the <code>Frame</code> in which the

   770      *                  dialog is displayed; if <code>null</code>,

   771      *                  or if the <code>parentComponent</code> has no

   772      *                  <code>Frame</code>, a

   773      *                  default <code>Frame</code> is used

   774      * @param message   the Object to display

   775      * @param title     the title string for the dialog

   776      * @param optionType an int designating the options available on the dialog:

   777      *                  <code>YES_NO_OPTION</code>,

   778      *                  <code>YES_NO_CANCEL_OPTION</code>,

   779      *                  or <code>OK_CANCEL_OPTION</code>

   780      * @param messageType an int designating the kind of message this is,

   781      *                  primarily used to determine the icon from the pluggable

   782      *                  Look and Feel: <code>ERROR_MESSAGE</code>,

   783      *                  <code>INFORMATION_MESSAGE</code>,

   784      *                  <code>WARNING_MESSAGE</code>,

   785      *                  <code>QUESTION_MESSAGE</code>,

   786      *                  or <code>PLAIN_MESSAGE</code>

   787      * @param icon      the icon to display in the dialog

   788      * @return an int indicating the option selected by the user

   789      * @exception HeadlessException if

   790      *   <code>GraphicsEnvironment.isHeadless</code> returns

   791      *   <code>true</code>

   792      * @see java.awt.GraphicsEnvironment#isHeadless

   793      */

   794     public static int showConfirmDialog(Component parentComponent,

   795         Object message, String title, int optionType,

   796         int messageType, Icon icon) throws HeadlessException {

   797         return showOptionDialog(parentComponent, message, title, optionType,

   798                                 messageType, icon, null, null);

   799     }

   800 

   801     /**

   802      * Brings up a dialog with a specified icon, where the initial

   803      * choice is determined by the <code>initialValue</code> parameter and

   804      * the number of choices is determined by the <code>optionType</code>

   805      * parameter.

   806      * <p>

   807      * If <code>optionType</code> is <code>YES_NO_OPTION</code>,

   808      * or <code>YES_NO_CANCEL_OPTION</code>

   809      * and the <code>options</code> parameter is <code>null</code>,

   810      * then the options are

   811      * supplied by the look and feel.

   812      * <p>

   813      * The <code>messageType</code> parameter is primarily used to supply

   814      * a default icon from the look and feel.

   815      *

   816      * @param parentComponent determines the <code>Frame</code>

   817      *                  in which the dialog is displayed;  if

   818      *                  <code>null</code>, or if the

   819      *                  <code>parentComponent</code> has no

   820      *                  <code>Frame</code>, a

   821      *                  default <code>Frame</code> is used

   822      * @param message   the <code>Object</code> to display

   823      * @param title     the title string for the dialog

   824      * @param optionType an integer designating the options available on the

   825      *                  dialog: <code>DEFAULT_OPTION</code>,

   826      *                  <code>YES_NO_OPTION</code>,

   827      *                  <code>YES_NO_CANCEL_OPTION</code>,

   828      *                  or <code>OK_CANCEL_OPTION</code>

   829      * @param messageType an integer designating the kind of message this is,

   830      *                  primarily used to determine the icon from the

   831      *                  pluggable Look and Feel: <code>ERROR_MESSAGE</code>,

   832      *                  <code>INFORMATION_MESSAGE</code>,

   833      *                  <code>WARNING_MESSAGE</code>,

   834      *                  <code>QUESTION_MESSAGE</code>,

   835      *                  or <code>PLAIN_MESSAGE</code>

   836      * @param icon      the icon to display in the dialog

   837      * @param options   an array of objects indicating the possible choices

   838      *                  the user can make; if the objects are components, they

   839      *                  are rendered properly; non-<code>String</code>

   840      *                  objects are

   841      *                  rendered using their <code>toString</code> methods;

   842      *                  if this parameter is <code>null</code>,

   843      *                  the options are determined by the Look and Feel

   844      * @param initialValue the object that represents the default selection

   845      *                  for the dialog; only meaningful if <code>options</code>

   846      *                  is used; can be <code>null</code>

   847      * @return an integer indicating the option chosen by the user,

   848      *                  or <code>CLOSED_OPTION</code> if the user closed

   849      *                  the dialog

   850      * @exception HeadlessException if

   851      *   <code>GraphicsEnvironment.isHeadless</code> returns

   852      *   <code>true</code>

   853      * @see java.awt.GraphicsEnvironment#isHeadless

   854      */

   855     public static int showOptionDialog(Component parentComponent,

   856         Object message, String title, int optionType, int messageType,

   857         Icon icon, Object[] options, Object initialValue)

   858         throws HeadlessException {

   859         JOptionPane             pane = new JOptionPane(message, messageType,

   860                                                        optionType, icon,

   861                                                        options, initialValue);

   862 

   863         pane.setInitialValue(initialValue);

   864         pane.setComponentOrientation(((parentComponent == null) ?

   865             getRootFrame() : parentComponent).getComponentOrientation());

   866 

   867         int style = styleFromMessageType(messageType);

   868         JDialog dialog = pane.createDialog(parentComponent, title, style);

   869 

   870         pane.selectInitialValue();

   871         dialog.show();

   872         dialog.dispose();

   873 

   874         Object        selectedValue = pane.getValue();

   875 

   876         if(selectedValue == null)

   877             return CLOSED_OPTION;

   878         if(options == null) {

   879             if(selectedValue instanceof Integer)

   880                 return ((Integer)selectedValue).intValue();

   881             return CLOSED_OPTION;

   882         }

   883         for(int counter = 0, maxCounter = options.length;

   884             counter < maxCounter; counter++) {

   885             if(options[counter].equals(selectedValue))

   886                 return counter;

   887         }

   888         return CLOSED_OPTION;

   889     }

   890 

   891     /**

   892      * Creates and returns a new <code>JDialog</code> wrapping

   893      * <code>this</code> centered on the <code>parentComponent</code>

   894      * in the <code>parentComponent</code>'s frame.

   895      * <code>title</code> is the title of the returned dialog.

   896      * The returned <code>JDialog</code> will not be resizable by the

   897      * user, however programs can invoke <code>setResizable</code> on

   898      * the <code>JDialog</code> instance to change this property.

   899      * The returned <code>JDialog</code> will be set up such that

   900      * once it is closed, or the user clicks on one of the buttons,

   901      * the optionpane's value property will be set accordingly and

   902      * the dialog will be closed.  Each time the dialog is made visible,

   903      * it will reset the option pane's value property to

   904      * <code>JOptionPane.UNINITIALIZED_VALUE</code> to ensure the

   905      * user's subsequent action closes the dialog properly.

   906      *

   907      * @param parentComponent determines the frame in which the dialog

   908      *          is displayed; if the <code>parentComponent</code> has

   909      *          no <code>Frame</code>, a default <code>Frame</code> is used

   910      * @param title     the title string for the dialog

   911      * @return a new <code>JDialog</code> containing this instance

   912      * @exception HeadlessException if

   913      *   <code>GraphicsEnvironment.isHeadless</code> returns

   914      *   <code>true</code>

   915      * @see java.awt.GraphicsEnvironment#isHeadless

   916      */

   917     public JDialog createDialog(Component parentComponent, String title)

   918         throws HeadlessException {

   919         int style = styleFromMessageType(getMessageType());

   920         return createDialog(parentComponent, title, style);

   921     }

   922 

   923     /**

   924      * Creates and returns a new parentless <code>JDialog</code>

   925      * with the specified title.

   926      * The returned <code>JDialog</code> will not be resizable by the

   927      * user, however programs can invoke <code>setResizable</code> on

   928      * the <code>JDialog</code> instance to change this property.

   929      * The returned <code>JDialog</code> will be set up such that

   930      * once it is closed, or the user clicks on one of the buttons,

   931      * the optionpane's value property will be set accordingly and

   932      * the dialog will be closed.  Each time the dialog is made visible,

   933      * it will reset the option pane's value property to

   934      * <code>JOptionPane.UNINITIALIZED_VALUE</code> to ensure the

   935      * user's subsequent action closes the dialog properly.

   936      *

   937      * @param title     the title string for the dialog

   938      * @return a new <code>JDialog</code> containing this instance

   939      * @exception HeadlessException if

   940      *   <code>GraphicsEnvironment.isHeadless</code> returns

   941      *   <code>true</code>

   942      * @see java.awt.GraphicsEnvironment#isHeadless

   943      * @since 1.6

   944      */

   945     public JDialog createDialog(String title) throws HeadlessException {

   946         int style = styleFromMessageType(getMessageType());

   947         JDialog dialog = new JDialog((Dialog) null, title, true);

   948         initDialog(dialog, style, null);

   949         return dialog;

   950     }

   951 

   952     private JDialog createDialog(Component parentComponent, String title,

   953             int style)

   954             throws HeadlessException {

   955 

   956         final JDialog dialog;

   957 

   958         Window window = JOptionPane.getWindowForComponent(parentComponent);

   959         if (window instanceof Frame) {

   960             dialog = new JDialog((Frame)window, title, true);

   961         } else {

   962             dialog = new JDialog((Dialog)window, title, true);

   963         }

   964         if (window instanceof SwingUtilities.SharedOwnerFrame) {

   965             WindowListener ownerShutdownListener =

   966                 (WindowListener)SwingUtilities.getSharedOwnerFrameShutdownListener();

   967             dialog.addWindowListener(ownerShutdownListener);

   968         }

   969         initDialog(dialog, style, parentComponent);

   970         return dialog;

   971     }

   972 

   973     private void initDialog(final JDialog dialog, int style, Component parentComponent) {

   974         dialog.setComponentOrientation(this.getComponentOrientation());

   975         Container contentPane = dialog.getContentPane();

   976 

   977         contentPane.setLayout(new BorderLayout());

   978         contentPane.add(this, BorderLayout.CENTER);

   979         dialog.setResizable(false);

   980         if (JDialog.isDefaultLookAndFeelDecorated()) {

   981             boolean supportsWindowDecorations =

   982               UIManager.getLookAndFeel().getSupportsWindowDecorations();

   983             if (supportsWindowDecorations) {

   984                 dialog.setUndecorated(true);

   985                 getRootPane().setWindowDecorationStyle(style);

   986             }

   987         }

   988         dialog.pack();

   989         dialog.setLocationRelativeTo(parentComponent);

   990         WindowAdapter adapter = new WindowAdapter() {

   991             private boolean gotFocus = false;

   992             public void windowClosing(WindowEvent we) {

   993                 setValue(null);

   994             }

   995             public void windowGainedFocus(WindowEvent we) {

   996                 // Once window gets focus, set initial focus

   997                 if (!gotFocus) {

   998                     selectInitialValue();

   999                     gotFocus = true;

  1000                 }

  1001             }

  1002         };

  1003         dialog.addWindowListener(adapter);

  1004         dialog.addWindowFocusListener(adapter);

  1005         dialog.addComponentListener(new ComponentAdapter() {

  1006             public void componentShown(ComponentEvent ce) {

  1007                 // reset value to ensure closing works properly

  1008                 setValue(JOptionPane.UNINITIALIZED_VALUE);

  1009             }

  1010         });

  1011         addPropertyChangeListener(new PropertyChangeListener() {

  1012             public void propertyChange(PropertyChangeEvent event) {

  1013                 // Let the defaultCloseOperation handle the closing

  1014                 // if the user closed the window without selecting a button

  1015                 // (newValue = null in that case).  Otherwise, close the dialog.

  1016                 if (dialog.isVisible() && event.getSource() == JOptionPane.this &&

  1017                   (event.getPropertyName().equals(VALUE_PROPERTY) ||

  1018                    event.getPropertyName().equals(INPUT_VALUE_PROPERTY)) &&

  1019                   event.getNewValue() != null &&

  1020                   event.getNewValue() != JOptionPane.UNINITIALIZED_VALUE) {

  1021                     dialog.setVisible(false);

  1022                 }

  1023             }

  1024         });

  1025     }

  1026 

  1027 

  1028     /**

  1029      * Brings up an internal confirmation dialog panel. The dialog

  1030      * is a information-message dialog titled "Message".

  1031      *

  1032      * @param parentComponent determines the <code>Frame</code>

  1033      *          in which the dialog is displayed; if <code>null</code>,

  1034      *          or if the <code>parentComponent</code> has no

  1035      *          <code>Frame</code>, a default <code>Frame</code> is used

  1036      * @param message   the object to display

  1037      */

  1038     public static void showInternalMessageDialog(Component parentComponent,

  1039                                                  Object message) {

  1040         showInternalMessageDialog(parentComponent, message, UIManager.

  1041                                  getString("OptionPane.messageDialogTitle",

  1042                                  parentComponent), INFORMATION_MESSAGE);

  1043     }

  1044 

  1045     /**

  1046      * Brings up an internal dialog panel that displays a message

  1047      * using a default icon determined by the <code>messageType</code>

  1048      * parameter.

  1049      *

  1050      * @param parentComponent determines the <code>Frame</code>

  1051      *          in which the dialog is displayed; if <code>null</code>,

  1052      *          or if the <code>parentComponent</code> has no

  1053      *          <code>Frame</code>, a default <code>Frame</code> is used

  1054      * @param message   the <code>Object</code> to display

  1055      * @param title     the title string for the dialog

  1056      * @param messageType the type of message to be displayed:

  1057      *                  <code>ERROR_MESSAGE</code>,

  1058      *                  <code>INFORMATION_MESSAGE</code>,

  1059      *                  <code>WARNING_MESSAGE</code>,

  1060      *                  <code>QUESTION_MESSAGE</code>,

  1061      *                  or <code>PLAIN_MESSAGE</code>

  1062      */

  1063     public static void showInternalMessageDialog(Component parentComponent,

  1064                                                  Object message, String title,

  1065                                                  int messageType) {

  1066         showInternalMessageDialog(parentComponent, message, title, messageType,null);

  1067     }

  1068 

  1069     /**

  1070      * Brings up an internal dialog panel displaying a message,

  1071      * specifying all parameters.

  1072      *

  1073      * @param parentComponent determines the <code>Frame</code>

  1074      *          in which the dialog is displayed; if <code>null</code>,

  1075      *          or if the <code>parentComponent</code> has no

  1076      *          <code>Frame</code>, a default <code>Frame</code> is used

  1077      * @param message   the <code>Object</code> to display

  1078      * @param title     the title string for the dialog

  1079      * @param messageType the type of message to be displayed:

  1080      *                  <code>ERROR_MESSAGE</code>,

  1081      *                  <code>INFORMATION_MESSAGE</code>,

  1082      *                  <code>WARNING_MESSAGE</code>,

  1083      *                  <code>QUESTION_MESSAGE</code>,

  1084      *                  or <code>PLAIN_MESSAGE</code>

  1085      * @param icon      an icon to display in the dialog that helps the user

  1086      *                  identify the kind of message that is being displayed

  1087      */

  1088     public static void showInternalMessageDialog(Component parentComponent,

  1089                                          Object message,

  1090                                          String title, int messageType,

  1091                                          Icon icon){

  1092         showInternalOptionDialog(parentComponent, message, title, DEFAULT_OPTION,

  1093                                  messageType, icon, null, null);

  1094     }

  1095 

  1096     /**

  1097      * Brings up an internal dialog panel with the options <i>Yes</i>, <i>No</i>

  1098      * and <i>Cancel</i>; with the title, <b>Select an Option</b>.

  1099      *

  1100      * @param parentComponent determines the <code>Frame</code> in

  1101      *          which the dialog is displayed; if <code>null</code>,

  1102      *          or if the <code>parentComponent</code> has no

  1103      *          <code>Frame</code>, a default <code>Frame</code> is used

  1104      * @param message   the <code>Object</code> to display

  1105      * @return an integer indicating the option selected by the user

  1106      */

  1107     public static int showInternalConfirmDialog(Component parentComponent,

  1108                                                 Object message) {

  1109         return showInternalConfirmDialog(parentComponent, message,

  1110                                  UIManager.getString("OptionPane.titleText"),

  1111                                  YES_NO_CANCEL_OPTION);

  1112     }

  1113 

  1114     /**

  1115      * Brings up a internal dialog panel where the number of choices

  1116      * is determined by the <code>optionType</code> parameter.

  1117      *

  1118      * @param parentComponent determines the <code>Frame</code>

  1119      *          in which the dialog is displayed; if <code>null</code>,

  1120      *          or if the <code>parentComponent</code> has no

  1121      *          <code>Frame</code>, a default <code>Frame</code> is used

  1122      * @param message   the object to display in the dialog; a

  1123      *          <code>Component</code> object is rendered as a

  1124      *          <code>Component</code>; a <code>String</code>

  1125      *          object is rendered as a string; other objects

  1126      *          are converted to a <code>String</code> using the

  1127      *          <code>toString</code> method

  1128      * @param title     the title string for the dialog

  1129      * @param optionType an integer designating the options

  1130      *          available on the dialog: <code>YES_NO_OPTION</code>,

  1131      *          or <code>YES_NO_CANCEL_OPTION</code>

  1132      * @return an integer indicating the option selected by the user

  1133      */

  1134     public static int showInternalConfirmDialog(Component parentComponent,

  1135                                                 Object message, String title,