JOptionPane.java

/*
 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

packagejavax.swing;

importjava.awt.BorderLayout;
importjava.awt.Component;
importjava.awt.Container;
importjava.awt.Dialog;
importjava.awt.Dimension;
importjava.awt.Frame;
importjava.awt.HeadlessException;
importjava.awt.KeyboardFocusManager;
importjava.awt.Point;
importjava.awt.Window;
importjava.awt.event.ComponentAdapter;
importjava.awt.event.ComponentEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjava.awt.event.WindowListener;
importjava.beans.BeanProperty;
importjava.beans.JavaBean;
importjava.beans.PropertyChangeEvent;
importjava.beans.PropertyChangeListener;
importjava.io.IOException;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.Serial;
importjava.io.Serializable;
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.Vector;

importjavax.accessibility.Accessible;
importjavax.accessibility.AccessibleContext;
importjavax.accessibility.AccessibleRole;
importjavax.swing.event.InternalFrameAdapter;
importjavax.swing.event.InternalFrameEvent;
importjavax.swing.plaf.OptionPaneUI;

importsun.awt.AWTAccessor;

importstaticjavax.swing.ClientPropertyKey.PopupFactory_FORCE_HEAVYWEIGHT_POPUP;

/**
 * <code>JOptionPane</code> makes it easy to pop up a standard dialog box that
 * prompts users for a value or informs them of something.
 * For information about using <code>JOptionPane</code>, see
 * <a
 href="https://docs.oracle.com/javase/tutorial/uiswing/components/dialog.html">How to Make Dialogs</a>,
 * a section in <em>The Java Tutorial</em>.
 *
 * <p>
 *
 * While the <code>JOptionPane</code>
 * class may appear complex because of the large number of methods, almost
 * all uses of this class are one-line calls to one of the static
 * <code>showXxxDialog</code> methods shown below:
 *
 * <table class="striped">
 * <caption>Common JOptionPane method names and their descriptions</caption>
 * <thead>
 * <tr>
 * <th scope="col">Method Name
 * <th scope="col">Description
 * </thead>
 * <tbody>
 * <tr>
 * <th scope="row">showConfirmDialog
 * <td>Asks a confirming question, like yes/no/cancel.</td>
 * <tr>
 * <th scope="row">showInputDialog
 * <td>Prompt for some input.
 * <tr>
 * <th scope="row">showMessageDialog
 * <td>Tell the user about something that has happened.
 * <tr>
 * <th scope="row">showOptionDialog
 * <td>The Grand Unification of the above three.
 * </tbody>
 * </table>
 *
 * Each of these methods also comes in a <code>showInternalXXX</code>
 * flavor, which uses an internal frame to hold the dialog box (see
 * {@link JInternalFrame}).
 * Multiple convenience methods have also been defined -- overloaded
 * versions of the basic methods that use different parameter lists.
 * <p>
 * All dialogs are modal. Each <code>showXxxDialog</code> method blocks
 * the caller until the user's interaction is complete.
 *
 * <table class="borderless">
 * <caption>Common dialog</caption>
 * <tr>
 * <td style="background-color:#FFe0d0" rowspan=2>icon</td>
 * <td style="background-color:#FFe0d0">message</td>
 * </tr>
 * <tr>
 * <td style="background-color:#FFe0d0">input value</td>
 * </tr>
 * <tr>
 * <td style="background-color:#FFe0d0" colspan=2>option buttons</td>
 * </tr>
 * </table>
 *
 * The basic appearance of one of these dialog boxes is generally
 * similar to the picture above, although the various
 * look-and-feels are
 * ultimately responsible for the final result. In particular, the
 * look-and-feels will adjust the layout to accommodate the option pane's
 * <code>ComponentOrientation</code> property.
 * <br style="clear:all">
 * <p>
 * <b>Parameters:</b><br>
 * The parameters to these methods follow consistent patterns:
 * <blockquote>
 * <dl>
 * <dt>parentComponent<dd>
 * Defines the <code>Component</code> that is to be the parent of this
 * dialog box.
 * It is used in two ways: the <code>Frame</code> that contains
 * it is used as the <code>Frame</code>
 * parent for the dialog box, and its screen coordinates are used in
 * the placement of the dialog box. In general, the dialog box is placed
 * just below the component. This parameter may be <code>null</code>,
 * in which case a default <code>Frame</code> is used as the parent,
 * and the dialog will be
 * centered on the screen (depending on the {@literal L&F}).
 * <dt>message<dd>
 * A descriptive message to be placed in the dialog box.
 * In the most common usage, message is just a <code>String</code> or
 * <code>String</code> constant.
 * However, the type of this parameter is actually <code>Object</code>. Its
 * interpretation depends on its type:
 * <dl>
 * <dt>Object[]<dd>An array of objects is interpreted as a series of
 * messages (one per object) arranged in a vertical stack.
 * The interpretation is recursive -- each object in the
 * array is interpreted according to its type.
 * <dt>Component<dd>The <code>Component</code> is displayed in the dialog.
 * <dt>Icon<dd>The <code>Icon</code> is wrapped in a <code>JLabel</code>
 * and displayed in the dialog.
 * <dt>others<dd>The object is converted to a <code>String</code> by calling
 * its <code>toString</code> method. The result is wrapped in a
 * <code>JLabel</code> and displayed.
 * </dl>
 * <dt>messageType<dd>Defines the style of the message. The Look and Feel
 * manager may lay out the dialog differently depending on this value, and
 * will often provide a default icon. The possible values are:
 * <ul>
 * <li><code>ERROR_MESSAGE</code>
 * <li><code>INFORMATION_MESSAGE</code>
 * <li><code>WARNING_MESSAGE</code>
 * <li><code>QUESTION_MESSAGE</code>
 * <li><code>PLAIN_MESSAGE</code>
 * </ul>
 * <dt>optionType<dd>Defines the set of option buttons that appear at
 * the bottom of the dialog box:
 * <ul>
 * <li><code>DEFAULT_OPTION</code>
 * <li><code>YES_NO_OPTION</code>
 * <li><code>YES_NO_CANCEL_OPTION</code>
 * <li><code>OK_CANCEL_OPTION</code>
 * </ul>
 * You aren't limited to this set of option buttons. You can provide any
 * buttons you want using the options parameter.
 * <dt>options<dd>A more detailed description of the set of option buttons
 * that will appear at the bottom of the dialog box.
 * The usual value for the options parameter is an array of
 * <code>String</code>s. But
 * the parameter type is an array of <code>Objects</code>.
 * A button is created for each object depending on its type:
 * <dl>
 * <dt>Component<dd>The component is added to the button row directly.
 * <dt>Icon<dd>A <code>JButton</code> is created with this as its label.
 * <dt>other<dd>The <code>Object</code> is converted to a string using its
 * <code>toString</code> method and the result is used to
 * label a <code>JButton</code>.
 * </dl>
 * <dt>icon<dd>A decorative icon to be placed in the dialog box. A default
 * value for this is determined by the <code>messageType</code> parameter.
 * <dt>title<dd>The title for the dialog box.
 * <dt>initialValue<dd>The default selection (input value).
 * </dl>
 * </blockquote>
 * <p>
 * When the selection is changed, <code>setValue</code> is invoked,
 * which generates a <code>PropertyChangeEvent</code>.
 * <p>
 * If a <code>JOptionPane</code> has configured to all input
 * <code>setWantsInput</code>
 * the bound property <code>JOptionPane.INPUT_VALUE_PROPERTY</code>
 * can also be listened
 * to, to determine when the user has input or selected a value.
 * <p>
 * When one of the <code>showXxxDialog</code> methods returns an integer,
 * the possible values are:
 * <ul>
 * <li><code>YES_OPTION</code>
 * <li><code>NO_OPTION</code>
 * <li><code>CANCEL_OPTION</code>
 * <li><code>OK_OPTION</code>
 * <li><code>CLOSED_OPTION</code>
 * </ul>
 * <b>Examples:</b>
 * <dl>
 * <dt>Show an error dialog that displays the message, 'alert':
 * <dd><code>
 * JOptionPane.showMessageDialog(null, "alert", "alert", JOptionPane.ERROR_MESSAGE);
 * </code>
 * <dt>Show an internal information dialog with the message, 'information':
 * <dd><pre>
 * JOptionPane.showInternalMessageDialog(frame, "information",
 * "information", JOptionPane.INFORMATION_MESSAGE);
 * </pre>
 * <dt>Show an information panel with the options yes/no and message 'choose one':
 * <dd><pre>JOptionPane.showConfirmDialog(null,
 * "choose one", "choose one", JOptionPane.YES_NO_OPTION);
 * </pre>
 * <dt>Show an internal information dialog with the options yes/no/cancel and
 * message 'please choose one' and title information:
 * <dd><pre>JOptionPane.showInternalConfirmDialog(frame,
 * "please choose one", "information",
 * JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE);
 * </pre>
 * <dt>Show a warning dialog with the options OK, CANCEL, title 'Warning', and
 * message 'Click OK to continue':
 * <dd><pre>
 * Object[] options = { "OK", "CANCEL" };
 * JOptionPane.showOptionDialog(null, "Click OK to continue", "Warning",
 * JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,
 * null, options, options[0]);
 * </pre>
 * <dt>Show a dialog asking the user to type in a String:
 * <dd><code>
 * String inputValue = JOptionPane.showInputDialog("Please input a value");
 * </code>
 * <dt>Show a dialog asking the user to select a String:
 * <dd><pre>
 * Object[] possibleValues = { "First", "Second", "Third" };<br>
 * Object selectedValue = JOptionPane.showInputDialog(null,
 * "Choose one", "Input",
 * JOptionPane.INFORMATION_MESSAGE, null,
 * possibleValues, possibleValues[0]);
 * </pre>
 * </dl>
 * <b>Direct Use:</b><br>
 * To create and use an <code>JOptionPane</code> directly, the
 * standard pattern is roughly as follows:
 * <pre>
 * JOptionPane pane = new JOptionPane(<i>arguments</i>);
 * pane.set<i>.Xxxx(...); // Configure</i>
 * JDialog dialog = pane.createDialog(<i>parentComponent, title</i>);
 * dialog.setVisible(true);
 * Object selectedValue = pane.getValue();
 * if(selectedValue == null)
 * return CLOSED_OPTION;
 * <i>//If there is <b>not</b> an array of option buttons:</i>
 * if(options == null) {
 * if(selectedValue instanceof Integer)
 * return ((Integer)selectedValue).intValue();
 * return CLOSED_OPTION;
 * }
 * <i>//If there is an array of option buttons:</i>
 * for(int counter = 0, maxCounter = options.length;
 * counter &lt; maxCounter; counter++) {
 * if(options[counter].equals(selectedValue))
 * return counter;
 * }
 * return CLOSED_OPTION;
 * </pre>
 * <p>
 * <strong>Warning:</strong> Swing is not thread safe. For more
 * information see <a
 * href="package-summary.html#threading">Swing's Threading
 * Policy</a>.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @see JInternalFrame
 *
 * @author James Gosling
 * @author Scott Violet
 * @since 1.2
 */
@JavaBean(defaultProperty = "UI", description = "A component which implements standard dialog box controls.")
@SwingContainer
@SuppressWarnings("serial") // Same-version serialization only
publicclassJOptionPaneextendsJComponentimplementsAccessible
{
/**
 * @see #getUIClassID
 * @see #readObject
 */
privatestaticfinalStringuiClassID = "OptionPaneUI";

/**
 * Indicates that the user has not yet selected a value.
 */
publicstaticfinalObjectUNINITIALIZED_VALUE = "uninitializedValue";

//
// Option types
//

/**
 * Type meaning Look and Feel should not supply any options -- only
 * use the options from the <code>JOptionPane</code>.
 */
publicstaticfinalintDEFAULT_OPTION = -1;
/** Type used for <code>showConfirmDialog</code>. */
publicstaticfinalintYES_NO_OPTION = 0;
/** Type used for <code>showConfirmDialog</code>. */
publicstaticfinalintYES_NO_CANCEL_OPTION = 1;
/** Type used for <code>showConfirmDialog</code>. */
publicstaticfinalintOK_CANCEL_OPTION = 2;

//
// Return values.
//
/** Return value from class method if YES is chosen. */
publicstaticfinalintYES_OPTION = 0;
/** Return value from class method if NO is chosen. */
publicstaticfinalintNO_OPTION = 1;
/** Return value from class method if CANCEL is chosen. */
publicstaticfinalintCANCEL_OPTION = 2;
/** Return value from class method if OK is chosen. */
publicstaticfinalintOK_OPTION = 0;
/** Return value from class method if user closes window without selecting
 * anything, more than likely this should be treated as either a
 * <code>CANCEL_OPTION</code> or <code>NO_OPTION</code>. */
publicstaticfinalintCLOSED_OPTION = -1;

//
// Message types. Used by the UI to determine what icon to display,
// and possibly what behavior to give based on the type.
//
/** Used for error messages. */
publicstaticfinalintERROR_MESSAGE = 0;
/** Used for information messages. */
publicstaticfinalintINFORMATION_MESSAGE = 1;
/** Used for warning messages. */
publicstaticfinalintWARNING_MESSAGE = 2;
/** Used for questions. */
publicstaticfinalintQUESTION_MESSAGE = 3;
/** No icon is used. */
publicstaticfinalintPLAIN_MESSAGE = -1;

/** Bound property name for <code>icon</code>. */
publicstaticfinalStringICON_PROPERTY = "icon";
/** Bound property name for <code>message</code>. */
publicstaticfinalStringMESSAGE_PROPERTY = "message";
/** Bound property name for <code>value</code>. */
publicstaticfinalStringVALUE_PROPERTY = "value";
/** Bound property name for <code>option</code>. */
publicstaticfinalStringOPTIONS_PROPERTY = "options";
/** Bound property name for <code>initialValue</code>. */
publicstaticfinalStringINITIAL_VALUE_PROPERTY = "initialValue";
/** Bound property name for <code>type</code>. */
publicstaticfinalStringMESSAGE_TYPE_PROPERTY = "messageType";
/** Bound property name for <code>optionType</code>. */
publicstaticfinalStringOPTION_TYPE_PROPERTY = "optionType";
/** Bound property name for <code>selectionValues</code>. */
publicstaticfinalStringSELECTION_VALUES_PROPERTY = "selectionValues";
/** Bound property name for <code>initialSelectionValue</code>. */
publicstaticfinalStringINITIAL_SELECTION_VALUE_PROPERTY = "initialSelectionValue";
/** Bound property name for <code>inputValue</code>. */
publicstaticfinalStringINPUT_VALUE_PROPERTY = "inputValue";
/** Bound property name for <code>wantsInput</code>. */
publicstaticfinalStringWANTS_INPUT_PROPERTY = "wantsInput";

/** Icon used in pane. */
protectedtransientIconicon;
/** Message to display. */
protectedtransientObjectmessage;
/** Options to display to the user. */
protectedtransientObject[] options;
/** Value that should be initially selected in <code>options</code>. */
protectedtransientObjectinitialValue;
/** Message type. */
protectedintmessageType;
/**
 * Option type, one of <code>DEFAULT_OPTION</code>,
 * <code>YES_NO_OPTION</code>,
 * <code>YES_NO_CANCEL_OPTION</code> or
 * <code>OK_CANCEL_OPTION</code>.
 */
protectedintoptionType;
/** Currently selected value, will be a valid option, or
 * <code>UNINITIALIZED_VALUE</code> or <code>null</code>. */
protectedtransientObjectvalue;
/** Array of values the user can choose from. Look and feel will
 * provide the UI component to choose this from. */
protectedtransientObject[] selectionValues;
/** Value the user has input. */
protectedtransientObjectinputValue;
/** Initial value to select in <code>selectionValues</code>. */
protectedtransientObjectinitialSelectionValue;
/** If true, a UI widget will be provided to the user to get input. */
protectedbooleanwantsInput;


/**
 * Shows a question-message dialog requesting input from the user. The
 * dialog uses the default frame, which usually means it is centered on
 * the screen.
 *
 * @param message the <code>Object</code> to display
 * @throws HeadlessException if
 * <code>GraphicsEnvironment.isHeadless</code> returns
 * <code>true</code>
 * @return user's input
 * @see java.awt.GraphicsEnvironment#isHeadless
 */
publicstaticStringshowInputDialog(Objectmessage)
throwsHeadlessException {
returnshowInputDialog(null, message);
 }

/**
 * Shows a question-message dialog requesting input from the user, with
 * the input value initialized to <code>initialSelectionValue</code>. The
 * dialog uses the default frame, which usually means it is centered on
 * the screen.
 *
 * @param message the <code>Object</code> to display
 * @param initialSelectionValue the value used to initialize the input
 * field
 * @return user's input
 * @since 1.4
 */
publicstaticStringshowInputDialog(Objectmessage, ObjectinitialSelectionValue) {
returnshowInputDialog(null, message, initialSelectionValue);
 }

/**
 * Shows a question-message dialog requesting input from the user
 * parented to <code>parentComponent</code>.
 * The dialog is displayed on top of the <code>Component</code>'s
 * frame, and is usually positioned below the <code>Component</code>.
 *
 * @param parentComponent the parent <code>Component</code> for the
 * dialog
 * @param message the <code>Object</code> to display
 * @throws HeadlessException if
 * <code>GraphicsEnvironment.isHeadless</code> returns
 * <code>true</code>
 * @return user's input
 * @see java.awt.GraphicsEnvironment#isHeadless
 */
publicstaticStringshowInputDialog(ComponentparentComponent,
Objectmessage) throwsHeadlessException {
returnshowInputDialog(parentComponent, message, UIManager.getString(
"OptionPane.inputDialogTitle", parentComponent), QUESTION_MESSAGE);
 }

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

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

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

pane.setWantsInput(true);
pane.setSelectionValues(selectionValues);
pane.setInitialSelectionValue(initialSelectionValue);
pane.setComponentOrientation(((parentComponent == null) ?
getRootFrame() : parentComponent).getComponentOrientation());

intstyle = styleFromMessageType(messageType);
JDialogdialog = pane.createDialog(parentComponent, title, style);

pane.selectInitialValue();
dialog.show();
dialog.dispose();

Objectvalue = pane.getInputValue();

if (value == UNINITIALIZED_VALUE) {
returnnull;
 }
returnvalue;
 }

/**
 * Brings up an information-message dialog titled "Message".
 *
 * @param parentComponent determines the <code>Frame</code> in
 * which the dialog is displayed; if <code>null</code>,
 * or if the <code>parentComponent</code> has no
 * <code>Frame</code>, a default <code>Frame</code> is used
 * @param message the <code>Object</code> to display
 * @throws HeadlessException if
 * <code>GraphicsEnvironment.isHeadless</code> returns
 * <code>true</code>
 * @see java.awt.GraphicsEnvironment#isHeadless
 */
publicstaticvoidshowMessageDialog(ComponentparentComponent,
Objectmessage) throwsHeadlessException {
showMessageDialog(parentComponent, message, UIManager.getString(
"OptionPane.messageDialogTitle", parentComponent),
INFORMATION_MESSAGE);
 }

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

/**
 * Brings up a dialog displaying a message, specifying all parameters.
 *
 * @param parentComponent determines the <code>Frame</code> in which the
 * dialog is displayed; if <code>null</code>,
 * or if the <code>parentComponent</code> has no
 * <code>Frame</code>, a
 * default <code>Frame</code> is used
 * @param message the <code>Object</code> to display
 * @param title the title string for the dialog
 * @param messageType the type of message to be displayed:
 * <code>ERROR_MESSAGE</code>,
 * <code>INFORMATION_MESSAGE</code>,
 * <code>WARNING_MESSAGE</code>,
 * <code>QUESTION_MESSAGE</code>,
 * or <code>PLAIN_MESSAGE</code>
 * @param icon an icon to display in the dialog that helps the user
 * identify the kind of message that is being displayed
 * @throws HeadlessException if
 * <code>GraphicsEnvironment.isHeadless</code> returns
 * <code>true</code>
 * @see java.awt.GraphicsEnvironment#isHeadless
 */
publicstaticvoidshowMessageDialog(ComponentparentComponent,
Objectmessage, Stringtitle, intmessageType, Iconicon)
throwsHeadlessException {
showOptionDialog(parentComponent, message, title, DEFAULT_OPTION,
messageType, icon, null, null);
 }

/**
 * Brings up a dialog with the options <i>Yes</i>,
 * <i>No</i> and <i>Cancel</i>; with the
 * title, <b>Select an Option</b>.
 *
 * @param parentComponent determines the <code>Frame</code> in which the
 * dialog is displayed; if <code>null</code>,
 * or if the <code>parentComponent</code> has no
 * <code>Frame</code>, a
 * default <code>Frame</code> is used
 * @param message the <code>Object</code> to display
 * @return an integer indicating the option selected by the user
 * @throws HeadlessException if
 * <code>GraphicsEnvironment.isHeadless</code> returns
 * <code>true</code>
 * @see java.awt.GraphicsEnvironment#isHeadless
 */
publicstaticintshowConfirmDialog(ComponentparentComponent,
Objectmessage) throwsHeadlessException {
returnshowConfirmDialog(parentComponent, message,
UIManager.getString("OptionPane.titleText"),
YES_NO_CANCEL_OPTION);
 }

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

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

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

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

pane.setInitialValue(initialValue);
pane.setComponentOrientation(((parentComponent == null) ?
getRootFrame() : parentComponent).getComponentOrientation());

intstyle = styleFromMessageType(messageType);
JDialogdialog = pane.createDialog(parentComponent, title, style);

pane.selectInitialValue();
dialog.show();
dialog.dispose();

ObjectselectedValue = pane.getValue();

if (parentComponent != null) {
parentComponent.revalidate();
parentComponent.repaint();
 }

if(selectedValue == null)
returnCLOSED_OPTION;
if(options == null) {
if(selectedValueinstanceofInteger)
return ((Integer)selectedValue).intValue();
returnCLOSED_OPTION;
 }
for(intcounter = 0, maxCounter = options.length;
counter < maxCounter; counter++) {
if(options[counter].equals(selectedValue))
returncounter;
 }
returnCLOSED_OPTION;
 }

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

/**
 * Creates and returns a new parentless <code>JDialog</code>
 * with the specified title.
 * The returned <code>JDialog</code> will not be resizable by the
 * user, however programs can invoke <code>setResizable</code> on
 * the <code>JDialog</code> instance to change this property.
 * The returned <code>JDialog</code> will be set up such that
 * once it is closed, or the user clicks on one of the buttons,
 * the optionpane's value property will be set accordingly and
 * the dialog will be closed. Each time the dialog is made visible,
 * it will reset the option pane's value property to
 * <code>JOptionPane.UNINITIALIZED_VALUE</code> to ensure the
 * user's subsequent action closes the dialog properly.
 *
 * @param title the title string for the dialog
 * @return a new <code>JDialog</code> containing this instance
 * @throws HeadlessException if
 * <code>GraphicsEnvironment.isHeadless</code> returns
 * <code>true</code>
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @since 1.6
 */
publicJDialogcreateDialog(Stringtitle) throwsHeadlessException {
intstyle = styleFromMessageType(getMessageType());
JDialogdialog = newJDialog((Dialog) null, title, true);
initDialog(dialog, style, null);
returndialog;
 }

privateJDialogcreateDialog(ComponentparentComponent, Stringtitle,
intstyle)
throwsHeadlessException {

finalJDialogdialog;

Windowwindow = JOptionPane.getWindowForComponent(parentComponent);
if (windowinstanceofFrame) {
dialog = newJDialog((Frame)window, title, true);
 } else {
dialog = newJDialog((Dialog)window, title, true);
 }
if (windowinstanceofSwingUtilities.SharedOwnerFrame) {
WindowListenerownerShutdownListener =
SwingUtilities.getSharedOwnerFrameShutdownListener();
dialog.addWindowListener(ownerShutdownListener);
 }
initDialog(dialog, style, parentComponent);
returndialog;
 }

privatevoidinitDialog(finalJDialogdialog, intstyle, ComponentparentComponent) {
dialog.setComponentOrientation(this.getComponentOrientation());
ContainercontentPane = dialog.getContentPane();

contentPane.setLayout(newBorderLayout());
contentPane.add(this, BorderLayout.CENTER);
dialog.setResizable(false);
if (JDialog.isDefaultLookAndFeelDecorated()) {
booleansupportsWindowDecorations =
UIManager.getLookAndFeel().getSupportsWindowDecorations();
if (supportsWindowDecorations) {
dialog.setUndecorated(true);
getRootPane().setWindowDecorationStyle(style);