/*

* Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

package java.awt;

import java.awt.peer.DialogPeer;

import java.awt.event.*;

import java.io.ObjectInputStream;

import java.io.IOException;

import java.util.Iterator;

import java.util.concurrent.atomic.AtomicLong;

import java.security.AccessController;

import java.security.PrivilegedAction;

import javax.accessibility.*;

import sun.awt.AppContext;

import sun.awt.SunToolkit;

import sun.awt.PeerEvent;

import sun.awt.util.IdentityArrayList;

import sun.awt.util.IdentityLinkedList;

import sun.security.util.SecurityConstants;

import java.security.AccessControlException;

/**

* A Dialog is a top-level window with a title and a border

* that is typically used to take some form of input from the user.

*

* The size of the dialog includes any area designated for the

* border. The dimensions of the border area can be obtained

* using the <code>getInsets</code> method, however, since

* these dimensions are platform-dependent, a valid insets

* value cannot be obtained until the dialog is made displayable

* by either calling <code>pack</code> or <code>show</code>.

* Since the border area is included in the overall size of the

* dialog, the border effectively obscures a portion of the dialog,

* constraining the area available for rendering and/or displaying

* subcomponents to the rectangle which has an upper-left corner

* location of <code>(insets.left, insets.top)</code>, and has a size of

* <code>width - (insets.left + insets.right)</code> by

* <code>height - (insets.top + insets.bottom)</code>.

* <p>

* The default layout for a dialog is <code>BorderLayout</code>.

* <p>

* A dialog may have its native decorations (i.e. Frame & Titlebar) turned off

* with <code>setUndecorated</code>. This can only be done while the dialog

* is not {@link Component#isDisplayable() displayable}.

* <p>

* A dialog may have another window as its owner when it's constructed. When

* the owner window of a visible dialog is minimized, the dialog will

* automatically be hidden from the user. When the owner window is subsequently

* restored, the dialog is made visible to the user again.

* <p>

* In a multi-screen environment, you can create a <code>Dialog</code>

* on a different screen device than its owner. See {@link java.awt.Frame} for

* more information.

* <p>

* A dialog can be either modeless (the default) or modal. A modal

* dialog is one which blocks input to some other top-level windows

* in the application, except for any windows created with the dialog

* as their owner. See <a href="doc-files/Modality.html">AWT Modality</a>

* specification for details.

* <p>

* Dialogs are capable of generating the following

* <code>WindowEvents</code>:

* <code>WindowOpened</code>, <code>WindowClosing</code>,

* <code>WindowClosed</code>, <code>WindowActivated</code>,

* <code>WindowDeactivated</code>, <code>WindowGainedFocus</code>,

* <code>WindowLostFocus</code>.

*

* @see WindowEvent

* @see Window#addWindowListener

*

* @author Sami Shaio

* @author Arthur van Hoff

* @since JDK1.0

*/

public class Dialog extends Window {

static {

/* ensure that the necessary native libraries are loaded */

Toolkit.loadLibraries();

if (!GraphicsEnvironment.isHeadless()) {

initIDs();

}

}

/**

* A dialog's resizable property. Will be true

* if the Dialog is to be resizable, otherwise

* it will be false.

*

* @serial

* @see #setResizable(boolean)

*/

boolean resizable = true;

/**

* This field indicates whether the dialog is undecorated.

* This property can only be changed while the dialog is not displayable.

* <code>undecorated</code> will be true if the dialog is

* undecorated, otherwise it will be false.

*

* @serial

* @see #setUndecorated(boolean)

* @see #isUndecorated()

* @see Component#isDisplayable()

* @since 1.4

*/

boolean undecorated = false;

private transient boolean initialized = false;

/**

* Modal dialogs block all input to some top-level windows.

* Whether a particular window is blocked depends on dialog's type

* of modality; this is called the "scope of blocking". The

* <code>ModalityType</code> enum specifies modal types and their

* associated scopes.

*

* @see Dialog#getModalityType

* @see Dialog#setModalityType

* @see Toolkit#isModalityTypeSupported

*

* @since 1.6

*/

public static enum ModalityType {

/**

* <code>MODELESS</code> dialog doesn't block any top-level windows.

*/

MODELESS,

/**

* A <code>DOCUMENT_MODAL</code> dialog blocks input to all top-level windows

* from the same document except those from its own child hierarchy.

* A document is a top-level window without an owner. It may contain child

* windows that, together with the top-level window are treated as a single

* solid document. Since every top-level window must belong to some

* document, its root can be found as the top-nearest window without an owner.

*/

DOCUMENT_MODAL,

/**

* An <code>APPLICATION_MODAL</code> dialog blocks all top-level windows

* from the same Java application except those from its own child hierarchy.

* If there are several applets launched in a browser, they can be

* treated either as separate applications or a single one. This behavior

* is implementation-dependent.

*/

APPLICATION_MODAL,

/**

* A <code>TOOLKIT_MODAL</code> dialog blocks all top-level windows run

* from the same toolkit except those from its own child hierarchy. If there

* are several applets launched in a browser, all of them run with the same

* toolkit; thus, a toolkit-modal dialog displayed by an applet may affect

* other applets and all windows of the browser instance which embeds the

* Java runtime environment for this toolkit.

* Special <code>AWTPermission</code> "toolkitModality" must be granted to use

* toolkit-modal dialogs. If a <code>TOOLKIT_MODAL</code> dialog is being created

* and this permission is not granted, a <code>SecurityException</code> will be

* thrown, and no dialog will be created. If a modality type is being changed

* to <code>TOOLKIT_MODAL</code> and this permission is not granted, a

* <code>SecurityException</code> will be thrown, and the modality type will

* be left unchanged.

*/

TOOLKIT_MODAL

};

/**

* Default modality type for modal dialogs. The default modality type is

* <code>APPLICATION_MODAL</code>. Calling the oldstyle <code>setModal(true)</code>

* is equal to <code>setModalityType(DEFAULT_MODALITY_TYPE)</code>.

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog#setModal

*

* @since 1.6

*/

public final static ModalityType DEFAULT_MODALITY_TYPE = ModalityType.APPLICATION_MODAL;

/**

* True if this dialog is modal, false is the dialog is modeless.

* A modal dialog blocks user input to some application top-level

* windows. This field is kept only for backwards compatibility. Use the

* {@link Dialog.ModalityType ModalityType} enum instead.

*

* @serial

*

* @see #isModal

* @see #setModal

* @see #getModalityType

* @see #setModalityType

* @see ModalityType

* @see ModalityType#MODELESS

* @see #DEFAULT_MODALITY_TYPE

*/

boolean modal;

/**

* Modality type of this dialog. If the dialog's modality type is not

* {@link Dialog.ModalityType#MODELESS ModalityType.MODELESS}, it blocks all

* user input to some application top-level windows.

*

* @serial

*

* @see ModalityType

* @see #getModalityType

* @see #setModalityType

*

* @since 1.6

*/

ModalityType modalityType;

/**

* Any top-level window can be marked not to be blocked by modal

* dialogs. This is called "modal exclusion". This enum specifies

* the possible modal exclusion types.

*

* @see Window#getModalExclusionType

* @see Window#setModalExclusionType

* @see Toolkit#isModalExclusionTypeSupported

*

* @since 1.6

*/

public static enum ModalExclusionType {

/**

* No modal exclusion.

*/

NO_EXCLUDE,

/**

* <code>APPLICATION_EXCLUDE</code> indicates that a top-level window

* won't be blocked by any application-modal dialogs. Also, it isn't

* blocked by document-modal dialogs from outside of its child hierarchy.

*/

APPLICATION_EXCLUDE,

/**

* <code>TOOLKIT_EXCLUDE</code> indicates that a top-level window

* won't be blocked by application-modal or toolkit-modal dialogs. Also,

* it isn't blocked by document-modal dialogs from outside of its

* child hierarchy.

* The "toolkitModality" <code>AWTPermission</code> must be granted

* for this exclusion. If an exclusion property is being changed to

* <code>TOOLKIT_EXCLUDE</code> and this permission is not granted, a

* <code>SecurityEcxeption</code> will be thrown, and the exclusion

* property will be left unchanged.

*/

TOOLKIT_EXCLUDE

};

/* operations with this list should be synchronized on tree lock*/

transient static IdentityArrayList<Dialog> modalDialogs = new IdentityArrayList<Dialog>();

transient IdentityArrayList<Window> blockedWindows = new IdentityArrayList<Window>();

/**

* Specifies the title of the Dialog.

* This field can be null.

*

* @serial

* @see #getTitle()

* @see #setTitle(String)

*/

String title;

private transient ModalEventFilter modalFilter;

private transient volatile SecondaryLoop secondaryLoop;

/*

* Indicates that this dialog is being hidden. This flag is set to true at

* the beginning of hide() and to false at the end of hide().

*

* @see #hide()

* @see #hideAndDisposePreHandler()

* @see #hideAndDisposeHandler()

* @see #shouldBlock()

*/

transient volatile boolean isInHide = false;

/*

* Indicates that this dialog is being disposed. This flag is set to true at

* the beginning of doDispose() and to false at the end of doDispose().

*

* @see #hide()

* @see #hideAndDisposePreHandler()

* @see #hideAndDisposeHandler()

* @see #doDispose()

*/

transient volatile boolean isInDispose = false;

private static final String base = "dialog";

private static int nameCounter = 0;

/*

* JDK 1.1 serialVersionUID

*/

private static final long serialVersionUID = 5920926903803293709L;

/**

* Constructs an initially invisible, modeless <code>Dialog</code> with

* the specified owner <code>Frame</code> and an empty title.

*

* @param owner the owner of the dialog or <code>null</code> if

* this dialog has no owner

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.GraphicsEnvironment#isHeadless

* @see Component#setSize

* @see Component#setVisible

*/

public Dialog(Frame owner) {

this(owner, "", false);

}

/**

* Constructs an initially invisible <code>Dialog</code> with the specified

* owner <code>Frame</code> and modality and an empty title.

*

* @param owner the owner of the dialog or <code>null</code> if

* this dialog has no owner

* @param modal specifes whether dialog blocks user input to other top-level

* windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>;

* if <code>true</code>, the modality type property is set to

* <code>DEFAULT_MODALITY_TYPE</code>

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog.ModalityType#MODELESS

* @see java.awt.Dialog#DEFAULT_MODALITY_TYPE

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

*/

public Dialog(Frame owner, boolean modal) {

this(owner, "", modal);

}

/**

* Constructs an initially invisible, modeless <code>Dialog</code> with

* the specified owner <code>Frame</code> and title.

*

* @param owner the owner of the dialog or <code>null</code> if

* this dialog has no owner

* @param title the title of the dialog or <code>null</code> if this dialog

* has no title

* @exception IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.GraphicsEnvironment#isHeadless

* @see Component#setSize

* @see Component#setVisible

*/

public Dialog(Frame owner, String title) {

this(owner, title, false);

}

/**

* Constructs an initially invisible <code>Dialog</code> with the

* specified owner <code>Frame</code>, title and modality.

*

* @param owner the owner of the dialog or <code>null</code> if

* this dialog has no owner

* @param title the title of the dialog or <code>null</code> if this dialog

* has no title

* @param modal specifes whether dialog blocks user input to other top-level

* windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>;

* if <code>true</code>, the modality type property is set to

* <code>DEFAULT_MODALITY_TYPE</code>

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog.ModalityType#MODELESS

* @see java.awt.Dialog#DEFAULT_MODALITY_TYPE

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

* @see Component#setSize

* @see Component#setVisible

*/

public Dialog(Frame owner, String title, boolean modal) {

this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS);

}

/**

* Constructs an initially invisible <code>Dialog</code> with the specified owner

* <code>Frame</code>, title, modality, and <code>GraphicsConfiguration</code>.

* @param owner the owner of the dialog or <code>null</code> if this dialog

* has no owner

* @param title the title of the dialog or <code>null</code> if this dialog

* has no title

* @param modal specifes whether dialog blocks user input to other top-level

* windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>;

* if <code>true</code>, the modality type property is set to

* <code>DEFAULT_MODALITY_TYPE</code>

* @param gc the <code>GraphicsConfiguration</code> of the target screen device;

* if <code>null</code>, the default system <code>GraphicsConfiguration</code>

* is assumed

* @exception java.lang.IllegalArgumentException if <code>gc</code>

* is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog.ModalityType#MODELESS

* @see java.awt.Dialog#DEFAULT_MODALITY_TYPE

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

* @see Component#setSize

* @see Component#setVisible

* @since 1.4

*/

public Dialog(Frame owner, String title, boolean modal,

GraphicsConfiguration gc) {

this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS, gc);

}

/**

* Constructs an initially invisible, modeless <code>Dialog</code> with

* the specified owner <code>Dialog</code> and an empty title.

*

* @param owner the owner of the dialog or <code>null</code> if this

* dialog has no owner

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

* @see java.awt.GraphicsEnvironment#isHeadless

* @since 1.2

*/

public Dialog(Dialog owner) {

this(owner, "", false);

}

/**

* Constructs an initially invisible, modeless <code>Dialog</code>

* with the specified owner <code>Dialog</code> and title.

*

* @param owner the owner of the dialog or <code>null</code> if this

* has no owner

* @param title the title of the dialog or <code>null</code> if this dialog

* has no title

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.GraphicsEnvironment#isHeadless

* @since 1.2

*/

public Dialog(Dialog owner, String title) {

this(owner, title, false);

}

/**

* Constructs an initially invisible <code>Dialog</code> with the

* specified owner <code>Dialog</code>, title, and modality.

*

* @param owner the owner of the dialog or <code>null</code> if this

* dialog has no owner

* @param title the title of the dialog or <code>null</code> if this

* dialog has no title

* @param modal specifes whether dialog blocks user input to other top-level

* windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>;

* if <code>true</code>, the modality type property is set to

* <code>DEFAULT_MODALITY_TYPE</code>

* @exception IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog.ModalityType#MODELESS

* @see java.awt.Dialog#DEFAULT_MODALITY_TYPE

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

*

* @since 1.2

*/

public Dialog(Dialog owner, String title, boolean modal) {

this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS);

}

/**

* Constructs an initially invisible <code>Dialog</code> with the

* specified owner <code>Dialog</code>, title, modality and

* <code>GraphicsConfiguration</code>.

*

* @param owner the owner of the dialog or <code>null</code> if this

* dialog has no owner

* @param title the title of the dialog or <code>null</code> if this

* dialog has no title

* @param modal specifes whether dialog blocks user input to other top-level

* windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>;

* if <code>true</code>, the modality type property is set to

* <code>DEFAULT_MODALITY_TYPE</code>

* @param gc the <code>GraphicsConfiguration</code> of the target screen device;

* if <code>null</code>, the default system <code>GraphicsConfiguration</code>

* is assumed

* @exception java.lang.IllegalArgumentException if <code>gc</code>

* is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog.ModalityType#MODELESS

* @see java.awt.Dialog#DEFAULT_MODALITY_TYPE

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

* @see Component#setSize

* @see Component#setVisible

*

* @since 1.4

*/

public Dialog(Dialog owner, String title, boolean modal,

GraphicsConfiguration gc) {

this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS, gc);

}

/**

* Constructs an initially invisible, modeless <code>Dialog</code> with the

* specified owner <code>Window</code> and an empty title.

*

* @param owner the owner of the dialog. The owner must be an instance of

* {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any

* of their descendents or <code>null</code>

*

* @exception java.lang.IllegalArgumentException if the <code>owner</code>

* is not an instance of {@link java.awt.Dialog Dialog} or {@link

* java.awt.Frame Frame}

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.GraphicsEnvironment#isHeadless

*

* @since 1.6

*/

public Dialog(Window owner) {

this(owner, "", ModalityType.MODELESS);

}

/**

* Constructs an initially invisible, modeless <code>Dialog</code> with

* the specified owner <code>Window</code> and title.

*

* @param owner the owner of the dialog. The owner must be an instance of

* {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any

* of their descendents or <code>null</code>

* @param title the title of the dialog or <code>null</code> if this dialog

* has no title

*

* @exception java.lang.IllegalArgumentException if the <code>owner</code>

* is not an instance of {@link java.awt.Dialog Dialog} or {@link

* java.awt.Frame Frame}

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

*

* @see java.awt.GraphicsEnvironment#isHeadless

*

* @since 1.6

*/

public Dialog(Window owner, String title) {

this(owner, title, ModalityType.MODELESS);

}

/**

* Constructs an initially invisible <code>Dialog</code> with the

* specified owner <code>Window</code> and modality and an empty title.

*

* @param owner the owner of the dialog. The owner must be an instance of

* {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any

* of their descendents or <code>null</code>

* @param modalityType specifies whether dialog blocks input to other

* windows when shown. <code>null</code> value and unsupported modality

* types are equivalent to <code>MODELESS</code>

*

* @exception java.lang.IllegalArgumentException if the <code>owner</code>

* is not an instance of {@link java.awt.Dialog Dialog} or {@link

* java.awt.Frame Frame}

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

* @exception SecurityException if the calling thread does not have permission

* to create modal dialogs with the given <code>modalityType</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

* @see java.awt.Toolkit#isModalityTypeSupported

*

* @since 1.6

*/

public Dialog(Window owner, ModalityType modalityType) {

this(owner, "", modalityType);

}

/**

* Constructs an initially invisible <code>Dialog</code> with the

* specified owner <code>Window</code>, title and modality.

*

* @param owner the owner of the dialog. The owner must be an instance of

* {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any

* of their descendents or <code>null</code>

* @param title the title of the dialog or <code>null</code> if this dialog

* has no title

* @param modalityType specifies whether dialog blocks input to other

* windows when shown. <code>null</code> value and unsupported modality

* types are equivalent to <code>MODELESS</code>

*

* @exception java.lang.IllegalArgumentException if the <code>owner</code>

* is not an instance of {@link java.awt.Dialog Dialog} or {@link

* java.awt.Frame Frame}

* @exception java.lang.IllegalArgumentException if the <code>owner</code>'s

* <code>GraphicsConfiguration</code> is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

* @exception SecurityException if the calling thread does not have permission

* to create modal dialogs with the given <code>modalityType</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

* @see java.awt.Toolkit#isModalityTypeSupported

*

* @since 1.6

*/

public Dialog(Window owner, String title, ModalityType modalityType) {

super(owner);

if ((owner != null) &&

!(owner instanceof Frame) &&

!(owner instanceof Dialog))

{

throw new IllegalArgumentException("Wrong parent window");

}

this.title = title;

setModalityType(modalityType);

SunToolkit.checkAndSetPolicy(this);

initialized = true;

}

/**

* Constructs an initially invisible <code>Dialog</code> with the

* specified owner <code>Window</code>, title, modality and

* <code>GraphicsConfiguration</code>.

*

* @param owner the owner of the dialog. The owner must be an instance of

* {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any

* of their descendents or <code>null</code>

* @param title the title of the dialog or <code>null</code> if this dialog

* has no title

* @param modalityType specifies whether dialog blocks input to other

* windows when shown. <code>null</code> value and unsupported modality

* types are equivalent to <code>MODELESS</code>

* @param gc the <code>GraphicsConfiguration</code> of the target screen device;

* if <code>null</code>, the default system <code>GraphicsConfiguration</code>

* is assumed

*

* @exception java.lang.IllegalArgumentException if the <code>owner</code>

* is not an instance of {@link java.awt.Dialog Dialog} or {@link

* java.awt.Frame Frame}

* @exception java.lang.IllegalArgumentException if <code>gc</code>

* is not from a screen device

* @exception HeadlessException when

* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>

* @exception SecurityException if the calling thread does not have permission

* to create modal dialogs with the given <code>modalityType</code>

*

* @see java.awt.Dialog.ModalityType

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#setModalityType

* @see java.awt.GraphicsEnvironment#isHeadless

* @see java.awt.Toolkit#isModalityTypeSupported

*

* @since 1.6

*/

public Dialog(Window owner, String title, ModalityType modalityType,

GraphicsConfiguration gc) {

super(owner, gc);

if ((owner != null) &&

!(owner instanceof Frame) &&

!(owner instanceof Dialog))

{

throw new IllegalArgumentException("wrong owner window");

}

this.title = title;

setModalityType(modalityType);

SunToolkit.checkAndSetPolicy(this);

initialized = true;

}

/**

* Construct a name for this component. Called by getName() when the

* name is null.

*/

String constructComponentName() {

synchronized (Dialog.class) {

return base + nameCounter++;

}

}

/**

* Makes this Dialog displayable by connecting it to

* a native screen resource. Making a dialog displayable will

* cause any of its children to be made displayable.

* This method is called internally by the toolkit and should

* not be called directly by programs.

* @see Component#isDisplayable

* @see #removeNotify

*/

public void addNotify() {

synchronized (getTreeLock()) {

if (parent != null && parent.getPeer() == null) {

parent.addNotify();

}

if (peer == null) {

peer = getToolkit().createDialog(this);

}

super.addNotify();

}

}

/**

* Indicates whether the dialog is modal.

* <p>

* This method is obsolete and is kept for backwards compatiblity only.

* Use {@link #getModalityType getModalityType()} instead.

*

* @return <code>true</code> if this dialog window is modal;

* <code>false</code> otherwise

*

* @see java.awt.Dialog#DEFAULT_MODALITY_TYPE

* @see java.awt.Dialog.ModalityType#MODELESS

* @see java.awt.Dialog#setModal

* @see java.awt.Dialog#getModalityType

* @see java.awt.Dialog#setModalityType

*/

public boolean isModal() {

return isModal_NoClientCode();

}

final boolean isModal_NoClientCode() {

return modalityType != ModalityType.MODELESS;

}

/**

* Specifies whether this dialog should be modal.

* <p>

* This method is obsolete and is kept for backwards compatibility only.

* Use {@link #setModalityType setModalityType()} instead.

* <p>

* Note: changing modality of the visible dialog may have no effect

* until it is hidden and then shown again.

*

* @param modal specifies whether dialog blocks input to other windows

* when shown; calling to <code>setModal(true)</code> is equivalent to

* <code>setModalityType(Dialog.DEFAULT_MODALITY_TYPE)</code>, and

* calling to <code>setModal(false)</code> is equvivalent to

* <code>setModalityType(Dialog.ModalityType.MODELESS)</code>

*

* @see java.awt.Dialog#DEFAULT_MODALITY_TYPE

* @see java.awt.Dialog.ModalityType#MODELESS

* @see java.awt.Dialog#isModal

* @see java.awt.Dialog#getModalityType

* @see java.awt.Dialog#setModalityType

*

* @since 1.1

*/

public void setModal(boolean modal) {

this.modal = modal;

setModalityType(modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS);

}

/**

* Returns the modality type of this dialog.

*

* @return modality type of this dialog

*

* @see java.awt.Dialog#setModalityType

*

* @since 1.6

*/

public ModalityType getModalityType() {

return modalityType;

}

/**

* Sets the modality type for this dialog. See {@link

* java.awt.Dialog.ModalityType ModalityType} for possible modality types.

* <p>

* If the given modality type is not supported, <code>MODELESS</code>

* is used. You may want to call <code>getModalityType()</code> after calling

* this method to ensure that the modality type has been set.

* <p>

* Note: changing modality of the visible dialog may have no effect

* until it is hidden and then shown again.

*

* @param type specifies whether dialog blocks input to other

* windows when shown. <code>null</code> value and unsupported modality

* types are equivalent to <code>MODELESS</code>

* @exception SecurityException if the calling thread does not have permission

* to create modal dialogs with the given <code>modalityType</code>

*

* @see java.awt.Dialog#getModalityType

* @see java.awt.Toolkit#isModalityTypeSupported

*

* @since 1.6

*/

public void setModalityType(ModalityType type) {

if (type == null) {

type = Dialog.ModalityType.MODELESS;

}

if (!Toolkit.getDefaultToolkit().isModalityTypeSupported(type)) {

type = Dialog.ModalityType.MODELESS;

}

if (modalityType == type) {

return;

}

checkModalityPermission(type);

modalityType = type;

modal = (modalityType != ModalityType.MODELESS);

}

/**

* Gets the title of the dialog. The title is displayed in the

* dialog's border.

* @return the title of this dialog window. The title may be

* <code>null</code>.

* @see java.awt.Dialog#setTitle

*/

public String getTitle() {

return title;

}

/**

* Sets the title of the Dialog.

* @param title the title displayed in the dialog's border;

* a null value results in an empty title

* @see #getTitle

*/

public void setTitle(String title) {

String oldTitle = this.title;

synchronized(this) {

this.title = title;

DialogPeer peer = (DialogPeer)this.peer;

if (peer != null) {

peer.setTitle(title);

}

}

firePropertyChange("title", oldTitle, title);

}

/**

* @return true if we actually showed, false if we just called toFront()

*/

private boolean conditionalShow(Component toFocus, AtomicLong time) {

boolean retval;

closeSplashScreen();

synchronized (getTreeLock()) {

if (peer == null) {

addNotify();

}

validateUnconditionally();

if (visible) {

toFront();

retval = false;

} else {

visible = retval = true;

// check if this dialog should be modal blocked BEFORE calling peer.show(),

// otherwise, a pair of FOCUS_GAINED and FOCUS_LOST may be mistakenly

// generated for the dialog

if (!isModal()) {

checkShouldBeBlocked(this);

} else {

modalDialogs.add(this);

modalShow();

}

if (toFocus != null && time != null && isFocusable() &&

isEnabled() && !isModalBlocked()) {

// keep the KeyEvents from being dispatched

// until the focus has been transfered

time.set(Toolkit.getEventQueue().getMostRecentEventTimeEx());

KeyboardFocusManager.getCurrentKeyboardFocusManager().

enqueueKeyEvents(time.get(), toFocus);

}

// This call is required as the show() method of the Dialog class

// does not invoke the super.show(). So wried... :(

mixOnShowing();

peer.setVisible(true); // now guaranteed never to block

if (isModalBlocked()) {

modalBlocker.toFront();

}

setLocationByPlatform(false);

for (int i = 0; i < ownedWindowList.size(); i++) {

Window child = ownedWindowList.elementAt(i).get();

if ((child != null) && child.showWithParent) {

child.show();

child.showWithParent = false;

} // endif

} // endfor

Window.updateChildFocusableWindowState(this);

createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED,

this, parent,

HierarchyEvent.SHOWING_CHANGED,

Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));

if (componentListener != null ||

(eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 ||

Toolkit.enabledOnToolkit(AWTEvent.COMPONENT_EVENT_MASK)) {

ComponentEvent e =

new ComponentEvent(this, ComponentEvent.COMPONENT_SHOWN);

Toolkit.getEventQueue().postEvent(e);

}

}

}

if (retval && (state & OPENED) == 0) {

postWindowEvent(WindowEvent.WINDOW_OPENED);

state |= OPENED;

}

return retval;

}

/**

* Shows or hides this {@code Dialog} depending on the value of parameter

* {@code b}.

* @param b if {@code true}, makes the {@code Dialog} visible,

* otherwise hides the {@code Dialog}.

* If the dialog and/or its owner

* are not yet displayable, both are made displayable. The

* dialog will be validated prior to being made visible.

* If {@code false}, hides the {@code Dialog} and then causes {@code setVisible(true)}

* to return if it is currently blocked.

* <p>

* <b>Notes for modal dialogs</b>.

* <ul>

* <li>{@code setVisible(true)}: If the dialog is not already

* visible, this call will not return until the dialog is

* hidden by calling {@code setVisible(false)} or

* {@code dispose}.

* <li>{@code setVisible(false)}: Hides the dialog and then

* returns on {@code setVisible(true)} if it is currently blocked.

* <li>It is OK to call this method from the event dispatching

* thread because the toolkit ensures that other events are

* not blocked while this method is blocked.

* </ul>

* @see java.awt.Window#setVisible

* @see java.awt.Window#dispose

* @see java.awt.Component#isDisplayable