1 /*

     2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

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

     4  *

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

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

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

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

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

    10  *

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

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

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

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    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.Window;

    38 import java.beans.PropertyChangeEvent;

    39 import java.beans.PropertyChangeListener;

    40 import java.awt.event.WindowListener;

    41 import java.awt.event.WindowAdapter;

    42 import java.awt.event.WindowEvent;

    43 import java.awt.event.ComponentAdapter;

    44 import java.awt.event.ComponentEvent;

    45 import java.io.IOException;

    46 import java.io.ObjectInputStream;

    47 import java.io.ObjectOutputStream;

    48 import java.io.Serializable;

    49 import java.lang.reflect.Method;

    50 import java.lang.reflect.InvocationTargetException;

    51 import java.security.AccessController;

    52 import java.security.PrivilegedAction;

    53 import java.util.Vector;

    54 import javax.swing.plaf.OptionPaneUI;

    55 import javax.swing.event.InternalFrameEvent;

    56 import javax.swing.event.InternalFrameAdapter;

    57 import javax.accessibility.*;

    58 import static javax.swing.ClientPropertyKey.PopupFactory_FORCE_HEAVYWEIGHT_POPUP;

    59 import sun.awt.AWTAccessor;

    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://docs.oracle.com/javase/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  *

   111  * <table cellspacing=6 cellpadding=4 border=0 style="float:right" summary="layout">

   112  * <tr>

   113  *  <td style="background-color:#FFe0d0" rowspan=2>icon</td>

   114  *  <td style="background-color:#FFe0d0">message</td>

   115  * </tr>

   116  * <tr>

   117  *  <td style="background-color:#FFe0d0">input value</td>

   118  * </tr>

   119  * <tr>

   120  *   <td style="background-color:#FFe0d0" colspan=2>option buttons</td>

   121  * </tr>

   122  * </table>

   123  *

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

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

   126  * look-and-feels are

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

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

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

   130  * <br style="clear:all">

   131  * <p>

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

   133  * The parameters to these methods follow consistent patterns:

   134  * <blockquote>

   135  * <dl>

   136  * <dt>parentComponent<dd>

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

   138  * dialog box.

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

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

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

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

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

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

   145  * and the dialog will be

   146  * centered on the screen (depending on the {@literal L&F}).

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

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

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

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

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

   152  * interpretation depends on its type:

   153  * <dl>

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

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

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

   157  *                 array is interpreted according to its type.

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

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

   160  *               and displayed in the dialog.

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

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

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

   164  * </dl>

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

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

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

   168  * <ul>

   169  * <li><code>ERROR_MESSAGE</code>

   170  * <li><code>INFORMATION_MESSAGE</code>

   171  * <li><code>WARNING_MESSAGE</code>

   172  * <li><code>QUESTION_MESSAGE</code>

   173  * <li><code>PLAIN_MESSAGE</code>

   174  * </ul>

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

   176  * the bottom of the dialog box:

   177  * <ul>

   178  * <li><code>DEFAULT_OPTION</code>

   179  * <li><code>YES_NO_OPTION</code>

   180  * <li><code>YES_NO_CANCEL_OPTION</code>

   181  * <li><code>OK_CANCEL_OPTION</code>

   182  * </ul>

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

   184  * buttons you want using the options parameter.

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

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

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

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

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

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

   191  * <dl>

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

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

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

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

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

   197  * </dl>

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

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

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

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

   202  * </dl>

   203  * </blockquote>

   204  * <p>

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

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

   207  * <p>

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

   209  * <code>setWantsInput</code>

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

   211  *  can also be listened

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

   213  * <p>

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

   215  * the possible values are:

   216  * <ul>

   217  * <li><code>YES_OPTION</code>

   218  * <li><code>NO_OPTION</code>

   219  * <li><code>CANCEL_OPTION</code>

   220  * <li><code>OK_OPTION</code>

   221  * <li><code>CLOSED_OPTION</code>

   222  * </ul>

   223  * <b>Examples:</b>

   224  * <dl>

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

   226  * <dd><code>

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

   228  * </code>

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

   230  * <dd><pre>

   231  * JOptionPane.showInternalMessageDialog(frame, "information",

   232  *             "information", JOptionPane.INFORMATION_MESSAGE);

   233  * </pre>

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

   235  * <dd><pre>JOptionPane.showConfirmDialog(null,

   236  *             "choose one", "choose one", JOptionPane.YES_NO_OPTION);

   237  * </pre>

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

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

   240  * <dd><pre>JOptionPane.showInternalConfirmDialog(frame,

   241  *             "please choose one", "information",

   242  *             JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);

   243  * </pre>

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

   245  * message 'Click OK to continue':

   246  * <dd><pre>

   247  * Object[] options = { "OK", "CANCEL" };

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

   249  *             JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,

   250  *             null, options, options[0]);

   251  * </pre>

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

   253  * <dd><code>

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

   255  * </code>

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

   257  * <dd><pre>

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

   259  * Object selectedValue = JOptionPane.showInputDialog(null,

   260  *             "Choose one", "Input",

   261  *             JOptionPane.INFORMATION_MESSAGE, null,

   262  *             possibleValues, possibleValues[0]);

   263  * </pre>

   264  * </dl>

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

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

   267  * standard pattern is roughly as follows:

   268  * <pre>

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

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

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

   272  *     dialog.show();

   273  *     Object selectedValue = pane.getValue();

   274  *     if(selectedValue == null)

   275  *       return CLOSED_OPTION;

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

   277  *     if(options == null) {

   278  *       if(selectedValue instanceof Integer)

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

   280  *       return CLOSED_OPTION;

   281  *     }

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

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

   284  *        counter < maxCounter; counter++) {

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

   286  *        return counter;

   287  *     }

   288  *     return CLOSED_OPTION;

   289  * </pre>

   290  * <p>

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

   292  * information see <a

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

   294  * Policy</a>.

   295  * <p>

   296  * <strong>Warning:</strong>

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

   298  * future Swing releases. The current serialization support is

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

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

   301  * of all JavaBeans™

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

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

   304  *

   305  * @see JInternalFrame

   306  *

   307  * @beaninfo

   308  *      attribute: isContainer true

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

   310  *

   311  * @author James Gosling

   312  * @author Scott Violet

   313  * @since 1.2

   314  */

   315 @SuppressWarnings("serial") // Same-version serialization only

   316 public class JOptionPane extends JComponent implements Accessible

   317 {

   318     /**

   319      * @see #getUIClassID

   320      * @see #readObject

   321      */

   322     private static final String uiClassID = "OptionPaneUI";

   323 

   324     /**

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

   326      */

   327     public static final Object      UNINITIALIZED_VALUE = "uninitializedValue";

   328 

   329     //

   330     // Option types

   331     //

   332 

   333     /**

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

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

   336      */

   337     public static final int         DEFAULT_OPTION = -1;

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

   339     public static final int         YES_NO_OPTION = 0;

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

   341     public static final int         YES_NO_CANCEL_OPTION = 1;

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

   343     public static final int         OK_CANCEL_OPTION = 2;

   344 

   345     //

   346     // Return values.

   347     //

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

   349     public static final int         YES_OPTION = 0;

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

   351     public static final int         NO_OPTION = 1;

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

   353     public static final int         CANCEL_OPTION = 2;

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

   355     public static final int         OK_OPTION = 0;

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

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

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

   359     public static final int         CLOSED_OPTION = -1;

   360 

   361     //

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

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

   364     //

   365     /** Used for error messages. */

   366     public static final int  ERROR_MESSAGE = 0;

   367     /** Used for information messages. */

   368     public static final int  INFORMATION_MESSAGE = 1;

   369     /** Used for warning messages. */

   370     public static final int  WARNING_MESSAGE = 2;

   371     /** Used for questions. */

   372     public static final int  QUESTION_MESSAGE = 3;

   373     /** No icon is used. */

   374     public static final int   PLAIN_MESSAGE = -1;

   375 

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

   377     public static final String      ICON_PROPERTY = "icon";

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

   379     public static final String      MESSAGE_PROPERTY = "message";

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

   381     public static final String      VALUE_PROPERTY = "value";

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

   383     public static final String      OPTIONS_PROPERTY = "options";

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

   385     public static final String      INITIAL_VALUE_PROPERTY = "initialValue";

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

   387     public static final String      MESSAGE_TYPE_PROPERTY = "messageType";

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

   389     public static final String      OPTION_TYPE_PROPERTY = "optionType";

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

   391     public static final String      SELECTION_VALUES_PROPERTY = "selectionValues";

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

   393     public static final String      INITIAL_SELECTION_VALUE_PROPERTY = "initialSelectionValue";

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

   395     public static final String      INPUT_VALUE_PROPERTY = "inputValue";

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

   397     public static final String      WANTS_INPUT_PROPERTY = "wantsInput";

   398 

   399     /** Icon used in pane. */

   400     transient protected Icon                  icon;

   401     /** Message to display. */

   402     transient protected Object                message;

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

   404     transient protected Object[]              options;

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

   406     transient protected Object                initialValue;

   407     /** Message type. */

   408     protected int                   messageType;

   409     /**

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

   411      * <code>YES_NO_OPTION</code>,

   412      * <code>YES_NO_CANCEL_OPTION</code> or

   413      * <code>OK_CANCEL_OPTION</code>.

   414      */

   415     protected int                   optionType;

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

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

   418     transient protected Object                value;

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

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

   421     protected transient Object[]              selectionValues;

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

   423     protected transient Object                inputValue;

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

   425     protected transient Object                initialSelectionValue;

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

   427     protected boolean                         wantsInput;

   428 

   429 

   430     /**

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

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

   433      * the screen.

   434      *

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

   436      * @exception HeadlessException if

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

   438      *   <code>true</code>

   439      * @return user's input

   440      * @see java.awt.GraphicsEnvironment#isHeadless

   441      */

   442     public static String showInputDialog(Object message)

   443         throws HeadlessException {

   444         return showInputDialog(null, message);

   445     }

   446 

   447     /**

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

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

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

   451      * the screen.

   452      *

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

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

   455      *                 field

   456      * @return user's input

   457      * @since 1.4

   458      */

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

   460         return showInputDialog(null, message, initialSelectionValue);

   461     }

   462 

   463     /**

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

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

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

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

   468      *

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

   470      *          dialog

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

   472      * @exception HeadlessException if

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

   474      *    <code>true</code>

   475      * @return user's input

   476      * @see java.awt.GraphicsEnvironment#isHeadless

   477      */

   478     public static String showInputDialog(Component parentComponent,

   479         Object message) throws HeadlessException {

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

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

   482     }

   483 

   484     /**

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

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

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

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

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

   490      *

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

   492      *          dialog

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

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

   495      *                 field

   496      * @return user's input

   497      * @since 1.4

   498      */

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

   500                                          Object initialSelectionValue) {

   501         return (String)showInputDialog(parentComponent, message,

   502                       UIManager.getString("OptionPane.inputDialogTitle",

   503                       parentComponent), QUESTION_MESSAGE, null, null,

   504                       initialSelectionValue);

   505     }

   506 

   507     /**

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

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

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

   511      *

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

   513      *                  dialog

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

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

   516      *                  title bar

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

   518      *                  <code>ERROR_MESSAGE</code>,

   519      *                  <code>INFORMATION_MESSAGE</code>,

   520      *                  <code>WARNING_MESSAGE</code>,

   521      *                  <code>QUESTION_MESSAGE</code>,

   522      *                  or <code>PLAIN_MESSAGE</code>

   523      * @return user's input

   524      * @exception HeadlessException if

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

   526      *   <code>true</code>

   527      * @see java.awt.GraphicsEnvironment#isHeadless

   528      */

   529     public static String showInputDialog(Component parentComponent,

   530         Object message, String title, int messageType)

   531         throws HeadlessException {

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

   533                                        messageType, null, null, null);

   534     }

   535 

   536     /**

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

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

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

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

   541      * user can input

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

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

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

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

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

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

   548      *

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

   550      *                  dialog

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

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

   553      *                  dialog title bar

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

   555      *                  <code>ERROR_MESSAGE</code>,

   556      *                  <code>INFORMATION_MESSAGE</code>,

   557      *                  <code>WARNING_MESSAGE</code>,

   558      *                  <code>QUESTION_MESSAGE</code>,

   559      *                  or <code>PLAIN_MESSAGE</code>

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

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

   562      *                  gives the possible selections

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

   564      *                 field

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

   566      *                  canceled the input

   567      * @exception HeadlessException if

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

   569      *   <code>true</code>

   570      * @see java.awt.GraphicsEnvironment#isHeadless

   571      */

   572     public static Object showInputDialog(Component parentComponent,

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

   574         Object[] selectionValues, Object initialSelectionValue)

   575         throws HeadlessException {

   576         JOptionPane    pane = new JOptionPane(message, messageType,

   577                                               OK_CANCEL_OPTION, icon,

   578                                               null, null);

   579 

   580         pane.setWantsInput(true);

   581         pane.setSelectionValues(selectionValues);

   582         pane.setInitialSelectionValue(initialSelectionValue);

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

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

   585 

   586         int style = styleFromMessageType(messageType);

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

   588 

   589         pane.selectInitialValue();

   590         dialog.show();

   591         dialog.dispose();

   592 

   593         Object value = pane.getInputValue();

   594 

   595         if (value == UNINITIALIZED_VALUE) {

   596             return null;

   597         }

   598         return value;

   599     }

   600 

   601     /**

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

   603      *

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

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

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

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

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

   609      * @exception HeadlessException if

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

   611      *   <code>true</code>

   612      * @see java.awt.GraphicsEnvironment#isHeadless

   613      */

   614     public static void showMessageDialog(Component parentComponent,

   615         Object message) throws HeadlessException {

   616         showMessageDialog(parentComponent, message, UIManager.getString(

   617                     "OptionPane.messageDialogTitle", parentComponent),

   618                     INFORMATION_MESSAGE);

   619     }

   620 

   621     /**

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

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

   624      *

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

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

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

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

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

   630      * @param title     the title string for the dialog

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

   632      *                  <code>ERROR_MESSAGE</code>,

   633      *                  <code>INFORMATION_MESSAGE</code>,

   634      *                  <code>WARNING_MESSAGE</code>,

   635      *                  <code>QUESTION_MESSAGE</code>,

   636      *                  or <code>PLAIN_MESSAGE</code>

   637      * @exception HeadlessException if

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

   639      *   <code>true</code>

   640      * @see java.awt.GraphicsEnvironment#isHeadless

   641      */

   642     public static void showMessageDialog(Component parentComponent,

   643         Object message, String title, int messageType)

   644         throws HeadlessException {

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

   646     }

   647 

   648     /**

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

   650      *

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

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

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

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

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

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

   657      * @param title     the title string for the dialog

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

   659      *                  <code>ERROR_MESSAGE</code>,

   660      *                  <code>INFORMATION_MESSAGE</code>,

   661      *                  <code>WARNING_MESSAGE</code>,

   662      *                  <code>QUESTION_MESSAGE</code>,

   663      *                  or <code>PLAIN_MESSAGE</code>

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

   665      *                  identify the kind of message that is being displayed

   666      * @exception HeadlessException if

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

   668      *   <code>true</code>

   669      * @see java.awt.GraphicsEnvironment#isHeadless

   670      */

   671     public static void showMessageDialog(Component parentComponent,

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

   673         throws HeadlessException {

   674         showOptionDialog(parentComponent, message, title, DEFAULT_OPTION,

   675                          messageType, icon, null, null);

   676     }

   677 

   678     /**

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

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

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

   682      *

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

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

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

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

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

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

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

   690      * @exception HeadlessException if

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

   692      *   <code>true</code>

   693      * @see java.awt.GraphicsEnvironment#isHeadless

   694      */

   695     public static int showConfirmDialog(Component parentComponent,

   696         Object message) throws HeadlessException {

   697         return showConfirmDialog(parentComponent, message,

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

   699                                  YES_NO_CANCEL_OPTION);

   700     }

   701 

   702     /**

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

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

   705      *

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

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

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

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

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

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

   712      * @param title     the title string for the dialog

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

   714      *                  <code>YES_NO_OPTION</code>,

   715      *                  <code>YES_NO_CANCEL_OPTION</code>,

   716      *                  or <code>OK_CANCEL_OPTION</code>

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

   718      * @exception HeadlessException if

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

   720      *   <code>true</code>

   721      * @see java.awt.GraphicsEnvironment#isHeadless

   722      */

   723     public static int showConfirmDialog(Component parentComponent,

   724         Object message, String title, int optionType)

   725         throws HeadlessException {

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

   727                                  QUESTION_MESSAGE);

   728     }

   729 

   730     /**

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

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

   733      * <code>messageType</code>

   734      * parameter determines the icon to display.

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

   736      * a default icon from the Look and Feel.

   737      *

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

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

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

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

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

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

   744      * @param title     the title string for the dialog

   745      * @param optionType an integer designating the options available

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

   747      *                  <code>YES_NO_CANCEL_OPTION</code>,

   748      *                  or <code>OK_CANCEL_OPTION</code>

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

   750      *                  primarily used to determine the icon from the pluggable

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

   752      *                  <code>INFORMATION_MESSAGE</code>,

   753      *                  <code>WARNING_MESSAGE</code>,

   754      *                  <code>QUESTION_MESSAGE</code>,

   755      *                  or <code>PLAIN_MESSAGE</code>

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

   757      * @exception HeadlessException if

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

   759      *   <code>true</code>

   760      * @see java.awt.GraphicsEnvironment#isHeadless

   761      */

   762     public static int showConfirmDialog(Component parentComponent,

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

   764         throws HeadlessException {

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

   766                                 messageType, null);

   767     }

   768 

   769     /**

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

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

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

   773      * a default icon from the look and feel.

   774      *

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

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

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

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

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

   780      * @param message   the Object to display

   781      * @param title     the title string for the dialog

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

   783      *                  <code>YES_NO_OPTION</code>,

   784      *                  <code>YES_NO_CANCEL_OPTION</code>,

   785      *                  or <code>OK_CANCEL_OPTION</code>

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

   787      *                  primarily used to determine the icon from the pluggable

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

   789      *                  <code>INFORMATION_MESSAGE</code>,

   790      *                  <code>WARNING_MESSAGE</code>,

   791      *                  <code>QUESTION_MESSAGE</code>,

   792      *                  or <code>PLAIN_MESSAGE</code>

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

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

   795      * @exception HeadlessException if

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

   797      *   <code>true</code>

   798      * @see java.awt.GraphicsEnvironment#isHeadless

   799      */

   800     public static int showConfirmDialog(Component parentComponent,

   801         Object message, String title, int optionType,

   802         int messageType, Icon icon) throws HeadlessException {

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

   804                                 messageType, icon, null, null);

   805     }

   806 

   807     /**

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

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

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

   811      * parameter.

   812      * <p>

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

   814      * or <code>YES_NO_CANCEL_OPTION</code>

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

   816      * then the options are

   817      * supplied by the look and feel.

   818      * <p>

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

   820      * a default icon from the look and feel.

   821      *

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

   823      *                  in which the dialog is displayed;  if

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

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

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

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

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

   829      * @param title     the title string for the dialog

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

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

   832      *                  <code>YES_NO_OPTION</code>,

   833      *                  <code>YES_NO_CANCEL_OPTION</code>,

   834      *                  or <code>OK_CANCEL_OPTION</code>

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

   836      *                  primarily used to determine the icon from the

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

   838      *                  <code>INFORMATION_MESSAGE</code>,

   839      *                  <code>WARNING_MESSAGE</code>,

   840      *                  <code>QUESTION_MESSAGE</code>,

   841      *                  or <code>PLAIN_MESSAGE</code>

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

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

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

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

   846      *                  objects are

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

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

   849      *                  the options are determined by the Look and Feel

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

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

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

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

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

   855      *                  the dialog

   856      * @exception HeadlessException if

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

   858      *   <code>true</code>

   859      * @see java.awt.GraphicsEnvironment#isHeadless

   860      */

   861     public static int showOptionDialog(Component parentComponent,

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

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

   864         throws HeadlessException {

   865         JOptionPane             pane = new JOptionPane(message, messageType,

   866                                                        optionType, icon,

   867                                                        options, initialValue);

   868 

   869         pane.setInitialValue(initialValue);

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

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

   872 

   873         int style = styleFromMessageType(messageType);

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

   875 

   876         pane.selectInitialValue();

   877         dialog.show();

   878         dialog.dispose();

   879 

   880         Object        selectedValue = pane.getValue();

   881 

   882         if(selectedValue == null)

   883             return CLOSED_OPTION;

   884         if(options == null) {

   885             if(selectedValue instanceof Integer)

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

   887             return CLOSED_OPTION;

   888         }

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

   890             counter < maxCounter; counter++) {

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

   892                 return counter;

   893         }

   894         return CLOSED_OPTION;

   895     }

   896 

   897     /**

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   912      *

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

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

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

   916      * @param title     the title string for the dialog

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

   918      * @exception HeadlessException if

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

   920      *   <code>true</code>

   921      * @see java.awt.GraphicsEnvironment#isHeadless

   922      */

   923     public JDialog createDialog(Component parentComponent, String title)

   924         throws HeadlessException {

   925         int style = styleFromMessageType(getMessageType());

   926         return createDialog(parentComponent, title, style);

   927     }

   928 

   929     /**

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

   931      * with the specified title.

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

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

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

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

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

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

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

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

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

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

   942      *

   943      * @param title     the title string for the dialog

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

   945      * @exception HeadlessException if

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

   947      *   <code>true</code>

   948      * @see java.awt.GraphicsEnvironment#isHeadless

   949      * @since 1.6

   950      */

   951     public JDialog createDialog(String title) throws HeadlessException {

   952         int style = styleFromMessageType(getMessageType());

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

   954         initDialog(dialog, style, null);

   955         return dialog;

   956     }

   957 

   958     private JDialog createDialog(Component parentComponent, String title,

   959             int style)

   960             throws HeadlessException {

   961 

   962         final JDialog dialog;

   963 

   964         Window window = JOptionPane.getWindowForComponent(parentComponent);

   965         if (window instanceof Frame) {

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

   967         } else {

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

   969         }

   970         if (window instanceof SwingUtilities.SharedOwnerFrame) {

   971             WindowListener ownerShutdownListener =

   972                     SwingUtilities.getSharedOwnerFrameShutdownListener();

   973             dialog.addWindowListener(ownerShutdownListener);

   974         }

   975         initDialog(dialog, style, parentComponent);

   976         return dialog;

   977     }

   978 

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

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

   981         Container contentPane = dialog.getContentPane();

   982 

   983         contentPane.setLayout(new BorderLayout());

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

   985         dialog.setResizable(false);

   986         if (JDialog.isDefaultLookAndFeelDecorated()) {

   987             boolean supportsWindowDecorations =

   988               UIManager.getLookAndFeel().getSupportsWindowDecorations();

   989             if (supportsWindowDecorations) {

   990                 dialog.setUndecorated(true);

   991                 getRootPane().setWindowDecorationStyle(style);

   992             }

   993         }

   994         dialog.pack();

   995         dialog.setLocationRelativeTo(parentComponent);

   996 

   997         final PropertyChangeListener listener = new PropertyChangeListener() {

   998             public void propertyChange(PropertyChangeEvent event) {

   999                 // Let the defaultCloseOperation handle the closing

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

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

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

  1003                         (event.getPropertyName().equals(VALUE_PROPERTY)) &&

  1004                         event.getNewValue() != null &&

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

  1006                     dialog.setVisible(false);

  1007                 }

  1008             }

  1009         };

  1010 

  1011         WindowAdapter adapter = new WindowAdapter() {

  1012             private boolean gotFocus = false;

  1013             public void windowClosing(WindowEvent we) {

  1014                 setValue(null);

  1015             }

  1016 

  1017             public void windowClosed(WindowEvent e) {

  1018                 removePropertyChangeListener(listener);

  1019                 dialog.getContentPane().removeAll();

  1020             }

  1021 

  1022             public void windowGainedFocus(WindowEvent we) {

  1023                 // Once window gets focus, set initial focus

  1024                 if (!gotFocus) {

  1025                     selectInitialValue();

  1026                     gotFocus = true;

  1027                 }

  1028             }

  1029         };

  1030         dialog.addWindowListener(adapter);

  1031         dialog.addWindowFocusListener(adapter);

  1032         dialog.addComponentListener(new ComponentAdapter() {

  1033             public void componentShown(ComponentEvent ce) {

  1034                 // reset value to ensure closing works properly

  1035                 setValue(JOptionPane.UNINITIALIZED_VALUE);

  1036             }

  1037         });

  1038 

  1039         addPropertyChangeListener(listener);

  1040     }

  1041 

  1042 

  1043     /**

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

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

  1046      *

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

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

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

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

  1051      * @param message   the object to display

  1052      */

  1053     public static void showInternalMessageDialog(Component parentComponent,

  1054                                                  Object message) {

  1055         showInternalMessageDialog(parentComponent, message, UIManager.

  1056                                  getString("OptionPane.messageDialogTitle",

  1057                                  parentComponent), INFORMATION_MESSAGE);

  1058     }

  1059 

  1060     /**

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

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

  1063      * parameter.

  1064      *

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

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

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

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

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

  1070      * @param title     the title string for the dialog

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

  1072      *                  <code>ERROR_MESSAGE</code>,

  1073      *                  <code>INFORMATION_MESSAGE</code>,

  1074      *                  <code>WARNING_MESSAGE</code>,

  1075      *                  <code>QUESTION_MESSAGE</code>,

  1076      *                  or <code>PLAIN_MESSAGE</code>

  1077      */

  1078     public static void showInternalMessageDialog(Component parentComponent,

  1079                                                  Object message, String title,

  1080                                                  int messageType) {

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

  1082     }

  1083 

  1084     /**

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

  1086      * specifying all parameters.

  1087      *

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

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

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

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

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

  1093      * @param title     the title string for the dialog

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

  1095      *                  <code>ERROR_MESSAGE</code>,

  1096      *                  <code>INFORMATION_MESSAGE</code>,

  1097      *                  <code>WARNING_MESSAGE</code>,

  1098      *                  <code>QUESTION_MESSAGE</code>,

  1099      *                  or <code>PLAIN_MESSAGE</code>

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

  1101      *                  identify the kind of message that is being displayed

  1102      */

  1103     public static void showInternalMessageDialog(Component parentComponent,

  1104                                          Object message,

  1105                                          String title, int messageType,

  1106                                          Icon icon){

  1107         showInternalOptionDialog(parentComponent, message, title, DEFAULT_OPTION,

  1108                                  messageType, icon, null, null);

  1109     }

  1110 

  1111     /**

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

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

  1114      *

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

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

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

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

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

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

  1121      */

  1122     public static int showInternalConfirmDialog(Component parentComponent,

  1123                                                 Object message) {

  1124         return showInternalConfirmDialog(parentComponent, message,

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

  1126                                  YES_NO_CANCEL_OPTION);

  1127     }

  1128 

  1129     /**

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

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

  1132      *

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

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