/*
* Copyright (c) 1995, 2013, 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.
*/
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 getInsets
method, however, since
these dimensions are platform-dependent, a valid insets
value cannot be obtained until the dialog is made displayable
by either calling pack
or show
.
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 (insets.left, insets.top)
, and has a size of
width - (insets.left + insets.right)
by
height - (insets.top + insets.bottom)
.
The default layout for a dialog is BorderLayout
.
A dialog may have its native decorations (i.e. Frame & Titlebar) turned off
with setUndecorated
. This can only be done while the dialog is not displayable
.
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.
In a multi-screen environment, you can create a Dialog
on a different screen device than its owner. See Frame
for more information.
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 AWT Modality
specification for details.
Dialogs are capable of generating the following
WindowEvents
:
WindowOpened
, WindowClosing
,
WindowClosed
, WindowActivated
,
WindowDeactivated
, WindowGainedFocus
,
WindowLostFocus
.
Author: Sami Shaio, Arthur van Hoff See Also: Since: JDK1.0
/**
* 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.
See Also: @serial
/**
* 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.
undecorated
will be true if the dialog is
undecorated, otherwise it will be false.
See Also: @serial Since: 1.4
/**
* 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
ModalityType
enum specifies modal types and their
associated scopes.
See Also: - getModalityType.getModalityType
- Dialog.setModalityType
- Toolkit.isModalityTypeSupported
Since: 1.6
/**
* 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 {
MODELESS
dialog doesn't block any top-level windows.
/**
* <code>MODELESS</code> dialog doesn't block any top-level windows.
*/
MODELESS,
A DOCUMENT_MODAL
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.
/**
* 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 APPLICATION_MODAL
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.
/**
* 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 TOOLKIT_MODAL
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 AWTPermission
"toolkitModality" must be granted to use
toolkit-modal dialogs. If a TOOLKIT_MODAL
dialog is being created
and this permission is not granted, a SecurityException
will be
thrown, and no dialog will be created. If a modality type is being changed
to TOOLKIT_MODAL
and this permission is not granted, a
SecurityException
will be thrown, and the modality type will
be left unchanged.
/**
* 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
APPLICATION_MODAL
. Calling the oldstyle setModal(true)
is equal to setModalityType(DEFAULT_MODALITY_TYPE)
.
See Also: - ModalityType
- setModal
Since: 1.6
/**
* 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 ModalityType
enum instead. See Also: @serial
/**
* 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 ModalityType.MODELESS
, it blocks all user input to some application top-level windows. See Also: @serial Since: 1.6
/**
* 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 Also: - getModalExclusionType.getModalExclusionType
- Window.setModalExclusionType
- Toolkit.isModalExclusionTypeSupported
Since: 1.6
/**
* 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 modal exclusion.
*/
NO_EXCLUDE,
APPLICATION_EXCLUDE
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.
/**
* <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,
TOOLKIT_EXCLUDE
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" AWTPermission
must be granted
for this exclusion. If an exclusion property is being changed to
TOOLKIT_EXCLUDE
and this permission is not granted, a
SecurityEcxeption
will be thrown, and the exclusion
property will be left unchanged.
/**
* <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.
See Also: @serial
/**
* 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 Dialog
with
the specified owner Frame
and an empty title.
Params: - owner – the owner of the dialog or
null
if
this dialog has no owner
Throws: - IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also:
/**
* 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 Dialog
with the specified
owner Frame
and modality and an empty title.
Params: - owner – the owner of the dialog or
null
if
this dialog has no owner - modal – specifies whether dialog blocks user input to other top-level
windows when shown. If
false
, the dialog is MODELESS
;
if true
, the modality type property is set to
DEFAULT_MODALITY_TYPE
Throws: - IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also:
/**
* 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 specifies 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 Dialog
with
the specified owner Frame
and title.
Params: - owner – the owner of the dialog or
null
if
this dialog has no owner - title – the title of the dialog or
null
if this dialog
has no title
Throws: - IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also:
/**
* 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 Dialog
with the
specified owner Frame
, title and modality.
Params: - owner – the owner of the dialog or
null
if
this dialog has no owner - title – the title of the dialog or
null
if this dialog
has no title - modal – specifies whether dialog blocks user input to other top-level
windows when shown. If
false
, the dialog is MODELESS
;
if true
, the modality type property is set to
DEFAULT_MODALITY_TYPE
Throws: - IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also:
/**
* 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 specifies 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 Dialog
with the specified owner
Frame
, title, modality, and GraphicsConfiguration
.
Params: - owner – the owner of the dialog or
null
if this dialog
has no owner - title – the title of the dialog or
null
if this dialog
has no title - modal – specifies whether dialog blocks user input to other top-level
windows when shown. If
false
, the dialog is MODELESS
;
if true
, the modality type property is set to
DEFAULT_MODALITY_TYPE
- gc – the
GraphicsConfiguration
of the target screen device;
if null
, the default system GraphicsConfiguration
is assumed
Throws: - IllegalArgumentException – if
gc
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also: Since: 1.4
/**
* 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 specifies 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 Dialog
with
the specified owner Dialog
and an empty title.
Params: - owner – the owner of the dialog or
null
if this
dialog has no owner
Throws: - IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also: Since: 1.2
/**
* 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 Dialog
with the specified owner Dialog
and title.
Params: - owner – the owner of the dialog or
null
if this
has no owner - title – the title of the dialog or
null
if this dialog
has no title
Throws: - IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also: Since: 1.2
/**
* 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 Dialog
with the
specified owner Dialog
, title, and modality.
Params: - owner – the owner of the dialog or
null
if this
dialog has no owner - title – the title of the dialog or
null
if this
dialog has no title - modal – specifies whether dialog blocks user input to other top-level
windows when shown. If
false
, the dialog is MODELESS
;
if true
, the modality type property is set to
DEFAULT_MODALITY_TYPE
Throws: - IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also: Since: 1.2
/**
* 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 specifies 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 Dialog
with the
specified owner Dialog
, title, modality and
GraphicsConfiguration
.
Params: - owner – the owner of the dialog or
null
if this
dialog has no owner - title – the title of the dialog or
null
if this
dialog has no title - modal – specifies whether dialog blocks user input to other top-level
windows when shown. If
false
, the dialog is MODELESS
;
if true
, the modality type property is set to
DEFAULT_MODALITY_TYPE
- gc – the
GraphicsConfiguration
of the target screen device;
if null
, the default system GraphicsConfiguration
is assumed
Throws: - IllegalArgumentException – if
gc
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also: Since: 1.4
/**
* 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 specifies 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 Dialog
with the
specified owner Window
and an empty title.
Params: Throws: - IllegalArgumentException – if the
owner
is not an instance of Dialog
or Frame
- IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also: Since: 1.6
/**
* 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 Dialog
with
the specified owner Window
and title.
Params: Throws: - IllegalArgumentException – if the
owner
is not an instance of Dialog
or Frame
- IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
See Also: Since: 1.6
/**
* 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 Dialog
with the
specified owner Window
and modality and an empty title.
Params: Throws: - IllegalArgumentException – if the
owner
is not an instance of Dialog
or Frame
- IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
- SecurityException – if the calling thread does not have permission
to create modal dialogs with the given
modalityType
See Also: Since: 1.6
/**
* 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 Dialog
with the
specified owner Window
, title and modality.
Params: - owner – the owner of the dialog. The owner must be an instance of
Dialog
, Frame
, any of their descendents or null
- title – the title of the dialog or
null
if this dialog
has no title - modalityType – specifies whether dialog blocks input to other
windows when shown.
null
value and unsupported modality
types are equivalent to MODELESS
Throws: - IllegalArgumentException – if the
owner
is not an instance of Dialog
or Frame
- IllegalArgumentException – if the
owner
's
GraphicsConfiguration
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
- SecurityException – if the calling thread does not have permission
to create modal dialogs with the given
modalityType
See Also: Since: 1.6
/**
* 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 Dialog
with the
specified owner Window
, title, modality and
GraphicsConfiguration
.
Params: - owner – the owner of the dialog. The owner must be an instance of
Dialog
, Frame
, any of their descendents or null
- title – the title of the dialog or
null
if this dialog
has no title - modalityType – specifies whether dialog blocks input to other
windows when shown.
null
value and unsupported modality
types are equivalent to MODELESS
- gc – the
GraphicsConfiguration
of the target screen device;
if null
, the default system GraphicsConfiguration
is assumed
Throws: - IllegalArgumentException – if the
owner
is not an instance of Dialog
or Frame
- IllegalArgumentException – if
gc
is not from a screen device - HeadlessException – when
GraphicsEnvironment.isHeadless()
returns true
- SecurityException – if the calling thread does not have permission
to create modal dialogs with the given
modalityType
See Also: Since: 1.6
/**
* 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.
/**
* 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 Also: - isDisplayable.isDisplayable
- Window.removeNotify
/**
* 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.
This method is obsolete and is kept for backwards compatibility only. Use getModalityType()
instead.
See Also: Returns: true
if this dialog window is modal;
false
otherwise
/**
* Indicates whether the dialog is modal.
* <p>
* This method is obsolete and is kept for backwards compatibility 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.
This method is obsolete and is kept for backwards compatibility only. Use setModalityType()
instead.
Note: changing modality of the visible dialog may have no effect
until it is hidden and then shown again.
Params: - modal – specifies whether dialog blocks input to other windows
when shown; calling to
setModal(true)
is equivalent to
setModalityType(Dialog.DEFAULT_MODALITY_TYPE)
, and
calling to setModal(false)
is equvivalent to
setModalityType(Dialog.ModalityType.MODELESS)
See Also: Since: 1.1
/**
* 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.
See Also: Returns: modality type of this dialog Since: 1.6
/**
* 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 ModalityType
for possible modality types.
If the given modality type is not supported, MODELESS
is used. You may want to call getModalityType()
after calling
this method to ensure that the modality type has been set.
Note: changing modality of the visible dialog may have no effect
until it is hidden and then shown again.
Params: - type – specifies whether dialog blocks input to other
windows when shown.
null
value and unsupported modality
types are equivalent to MODELESS
Throws: - SecurityException – if the calling thread does not have permission
to create modal dialogs with the given
modalityType
See Also: Since: 1.6
/**
* 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.
See Also: Returns: the title of this dialog window. The title may be
null
.
/**
* 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.
Params: - title – the title displayed in the dialog's border;
a null value results in an empty title
See Also:
/**
* 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);
}
Returns: true if we actually showed, false if we just called toFront()
/**
* @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().getMostRecentKeyEventTime());
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 Dialog
depending on the value of parameter b
. Params: - b – if
true
, makes the Dialog
visible, otherwise hides the 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 false
, hides the Dialog
and then causes setVisible(true)
to return if it is currently blocked.
Notes for modal dialogs.
setVisible(true)
: If the dialog is not already visible, this call will not return until the dialog is hidden by calling setVisible(false)
or dispose
. setVisible(false)
: Hides the dialog and then returns on setVisible(true)
if it is currently blocked. - 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.
See Also:
/**
* 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
* @see java.awt.Component#validate
* @see java.awt.Dialog#isModal
*/
public void setVisible(boolean b) {
super.setVisible(b);
}
Makes the Dialog
visible. 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 the dialog is already visible, this will bring the dialog to the front.
If the dialog is modal and is not already visible, this call
will not return until the dialog is hidden by calling hide or
dispose. It is permissible to show modal dialogs from the event
dispatching thread because the toolkit will ensure that another
event pump runs while the one which invoked this method is blocked.
See Also: Deprecated: As of JDK version 1.5, replaced by setVisible(boolean)
.
/**
* Makes the {@code Dialog} visible. 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 the dialog is already visible, this will bring the dialog
* to the front.
* <p>
* If the dialog is modal and is not already visible, this call
* will not return until the dialog is hidden by calling hide or
* dispose. It is permissible to show modal dialogs from the event
* dispatching thread because the toolkit will ensure that another
* event pump runs while the one which invoked this method is blocked.
* @see Component#hide
* @see Component#isDisplayable
* @see Component#validate
* @see #isModal
* @see Window#setVisible(boolean)
* @deprecated As of JDK version 1.5, replaced by
* {@link #setVisible(boolean) setVisible(boolean)}.
*/
@Deprecated
public void show() {
if (!initialized) {
throw new IllegalStateException("The dialog component " +
"has not been initialized properly");
}
beforeFirstShow = false;
if (!isModal()) {
conditionalShow(null, null);
} else {
AppContext showAppContext = AppContext.getAppContext();
AtomicLong time = new AtomicLong();
Component predictedFocusOwner = null;
try {
predictedFocusOwner = getMostRecentFocusOwner();
if (conditionalShow(predictedFocusOwner, time)) {
modalFilter = ModalEventFilter.createFilterForDialog(this);
final Conditional cond = new Conditional() {
@Override
public boolean evaluate() {
return windowClosingException == null;
}
};
// if this dialog is toolkit-modal, the filter should be added
// to all EDTs (for all AppContexts)
if (modalityType == ModalityType.TOOLKIT_MODAL) {
Iterator<AppContext> it = AppContext.getAppContexts().iterator();
while (it.hasNext()) {
AppContext appContext = it.next();
if (appContext == showAppContext) {
continue;
}
EventQueue eventQueue = (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY);
// it may occur that EDT for appContext hasn't been started yet, so
// we post an empty invocation event to trigger EDT initialization
Runnable createEDT = new Runnable() {
public void run() {};
};
eventQueue.postEvent(new InvocationEvent(this, createEDT));
EventDispatchThread edt = eventQueue.getDispatchThread();
edt.addEventFilter(modalFilter);
}
}
modalityPushed();
try {
final EventQueue eventQueue = AccessController.doPrivileged(
new PrivilegedAction<EventQueue>() {
public EventQueue run() {
return Toolkit.getDefaultToolkit().getSystemEventQueue();
}
});
secondaryLoop = eventQueue.createSecondaryLoop(cond, modalFilter, 0);
if (!secondaryLoop.enter()) {
secondaryLoop = null;
}
} finally {
modalityPopped();
}
// if this dialog is toolkit-modal, its filter must be removed
// from all EDTs (for all AppContexts)
if (modalityType == ModalityType.TOOLKIT_MODAL) {
Iterator<AppContext> it = AppContext.getAppContexts().iterator();
while (it.hasNext()) {
AppContext appContext = it.next();
if (appContext == showAppContext) {
continue;
}
EventQueue eventQueue = (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY);
EventDispatchThread edt = eventQueue.getDispatchThread();
edt.removeEventFilter(modalFilter);
}
}
if (windowClosingException != null) {
windowClosingException.fillInStackTrace();
throw windowClosingException;
}
}
} finally {
if (predictedFocusOwner != null) {
// Restore normal key event dispatching
KeyboardFocusManager.getCurrentKeyboardFocusManager().
dequeueKeyEvents(time.get(), predictedFocusOwner);
}
}
}
}
final void modalityPushed() {
Toolkit tk = Toolkit.getDefaultToolkit();
if (tk instanceof SunToolkit) {
SunToolkit stk = (SunToolkit)tk;
stk.notifyModalityPushed(this);
}
}
final void modalityPopped() {
Toolkit tk = Toolkit.getDefaultToolkit();
if (tk instanceof SunToolkit) {
SunToolkit stk = (SunToolkit)tk;
stk.notifyModalityPopped(this);
}
}
void interruptBlocking() {
if (isModal()) {
disposeImpl();
} else if (windowClosingException != null) {
windowClosingException.fillInStackTrace();
windowClosingException.printStackTrace();
windowClosingException = null;
}
}
private void hideAndDisposePreHandler() {
isInHide = true;
synchronized (getTreeLock()) {
if (secondaryLoop != null) {
modalHide();
// dialog can be shown and then disposed before its
// modal filter is created
if (modalFilter != null) {
modalFilter.disable();
}
modalDialogs.remove(this);
}
}
}
private void hideAndDisposeHandler() {
if (secondaryLoop != null) {
secondaryLoop.exit();
secondaryLoop = null;
}
isInHide = false;
}
Hides the Dialog and then causes show
to return if it is currently blocked. See Also: Deprecated: As of JDK version 1.5, replaced by setVisible(boolean)
.
/**
* Hides the Dialog and then causes {@code show} to return if it is currently
* blocked.
* @see Window#show
* @see Window#dispose
* @see Window#setVisible(boolean)
* @deprecated As of JDK version 1.5, replaced by
* {@link #setVisible(boolean) setVisible(boolean)}.
*/
@Deprecated
public void hide() {
hideAndDisposePreHandler();
super.hide();
// fix for 5048370: if hide() is called from super.doDispose(), then
// hideAndDisposeHandler() should not be called here as it will be called
// at the end of doDispose()
if (!isInDispose) {
hideAndDisposeHandler();
}
}
Disposes the Dialog and then causes show() to return if it is currently
blocked.
/**
* Disposes the Dialog and then causes show() to return if it is currently
* blocked.
*/
void doDispose() {
// fix for 5048370: set isInDispose flag to true to prevent calling
// to hideAndDisposeHandler() from hide()
isInDispose = true;
super.doDispose();
hideAndDisposeHandler();
isInDispose = false;
}
{@inheritDoc}
If this dialog is modal and blocks some windows, then all of them are
also sent to the back to keep them below the blocking dialog.
See Also:
/**
* {@inheritDoc}
* <p>
* If this dialog is modal and blocks some windows, then all of them are
* also sent to the back to keep them below the blocking dialog.
*
* @see java.awt.Window#toBack
*/
public void toBack() {
super.toBack();
if (visible) {
synchronized (getTreeLock()) {
for (Window w : blockedWindows) {
w.toBack_NoClientCode();
}
}
}
}
Indicates whether this dialog is resizable by the user.
By default, all dialogs are initially resizable.
See Also: Returns: true
if the user can resize the dialog;
false
otherwise.
/**
* Indicates whether this dialog is resizable by the user.
* By default, all dialogs are initially resizable.
* @return <code>true</code> if the user can resize the dialog;
* <code>false</code> otherwise.
* @see java.awt.Dialog#setResizable
*/
public boolean isResizable() {
return resizable;
}
Sets whether this dialog is resizable by the user.
Params: - resizable –
true
if the user can
resize this dialog; false
otherwise.
See Also:
/**
* Sets whether this dialog is resizable by the user.
* @param resizable <code>true</code> if the user can
* resize this dialog; <code>false</code> otherwise.
* @see java.awt.Dialog#isResizable
*/
public void setResizable(boolean resizable) {
boolean testvalid = false;
synchronized (this) {
this.resizable = resizable;
DialogPeer peer = (DialogPeer)this.peer;
if (peer != null) {
peer.setResizable(resizable);
testvalid = true;
}
}
// On some platforms, changing the resizable state affects
// the insets of the Dialog. If we could, we'd call invalidate()
// from the peer, but we need to guarantee that we're not holding
// the Dialog lock when we call invalidate().
if (testvalid) {
invalidateIfValid();
}
}
Disables or enables decorations for this dialog.
This method can only be called while the dialog is not displayable. To make this dialog decorated, it must be opaque and have the default shape, otherwise the IllegalComponentStateException
will be thrown. Refer to Window.setShape
, Window.setOpacity
and Window.setBackground
for details
Params: - undecorated –
true
if no dialog decorations are to be enabled; false
if dialog decorations are to be enabled
Throws: - IllegalComponentStateException – if the dialog is displayable
- IllegalComponentStateException – if
undecorated
is false
, and this dialog does not have the default shape - IllegalComponentStateException – if
undecorated
is false
, and this dialog opacity is less than 1.0f
- IllegalComponentStateException – if
undecorated
is false
, and the alpha value of this dialog background color is less than 1.0f
See Also: Since: 1.4
/**
* Disables or enables decorations for this dialog.
* <p>
* This method can only be called while the dialog is not displayable. To
* make this dialog decorated, it must be opaque and have the default shape,
* otherwise the {@code IllegalComponentStateException} will be thrown.
* Refer to {@link Window#setShape}, {@link Window#setOpacity} and {@link
* Window#setBackground} for details
*
* @param undecorated {@code true} if no dialog decorations are to be
* enabled; {@code false} if dialog decorations are to be enabled
*
* @throws IllegalComponentStateException if the dialog is displayable
* @throws IllegalComponentStateException if {@code undecorated} is
* {@code false}, and this dialog does not have the default shape
* @throws IllegalComponentStateException if {@code undecorated} is
* {@code false}, and this dialog opacity is less than {@code 1.0f}
* @throws IllegalComponentStateException if {@code undecorated} is
* {@code false}, and the alpha value of this dialog background
* color is less than {@code 1.0f}
*
* @see #isUndecorated
* @see Component#isDisplayable
* @see Window#getShape
* @see Window#getOpacity
* @see Window#getBackground
*
* @since 1.4
*/
public void setUndecorated(boolean undecorated) {
/* Make sure we don't run in the middle of peer creation.*/
synchronized (getTreeLock()) {
if (isDisplayable()) {
throw new IllegalComponentStateException("The dialog is displayable.");
}
if (!undecorated) {
if (getOpacity() < 1.0f) {
throw new IllegalComponentStateException("The dialog is not opaque");
}
if (getShape() != null) {
throw new IllegalComponentStateException("The dialog does not have a default shape");
}
Color bg = getBackground();
if ((bg != null) && (bg.getAlpha() < 255)) {
throw new IllegalComponentStateException("The dialog background color is not opaque");
}
}
this.undecorated = undecorated;
}
}
Indicates whether this dialog is undecorated.
By default, all dialogs are initially decorated.
See Also: Returns: true
if dialog is undecorated;
false
otherwise. Since: 1.4
/**
* Indicates whether this dialog is undecorated.
* By default, all dialogs are initially decorated.
* @return <code>true</code> if dialog is undecorated;
* <code>false</code> otherwise.
* @see java.awt.Dialog#setUndecorated
* @since 1.4
*/
public boolean isUndecorated() {
return undecorated;
}
{@inheritDoc}
/**
* {@inheritDoc}
*/
@Override
public void setOpacity(float opacity) {
synchronized (getTreeLock()) {
if ((opacity < 1.0f) && !isUndecorated()) {
throw new IllegalComponentStateException("The dialog is decorated");
}
super.setOpacity(opacity);
}
}
{@inheritDoc}
/**
* {@inheritDoc}
*/
@Override
public void setShape(Shape shape) {
synchronized (getTreeLock()) {
if ((shape != null) && !isUndecorated()) {
throw new IllegalComponentStateException("The dialog is decorated");
}
super.setShape(shape);
}
}
{@inheritDoc}
/**
* {@inheritDoc}
*/
@Override
public void setBackground(Color bgColor) {
synchronized (getTreeLock()) {
if ((bgColor != null) && (bgColor.getAlpha() < 255) && !isUndecorated()) {
throw new IllegalComponentStateException("The dialog is decorated");
}
super.setBackground(bgColor);
}
}
Returns a string representing the state of this dialog. This
method is intended to be used only for debugging purposes, and the
content and format of the returned string may vary between
implementations. The returned string may be empty but may not be
null
.
Returns: the parameter string of this dialog window.
/**
* Returns a string representing the state of this dialog. This
* method is intended to be used only for debugging purposes, and the
* content and format of the returned string may vary between
* implementations. The returned string may be empty but may not be
* <code>null</code>.
*
* @return the parameter string of this dialog window.
*/
protected String paramString() {
String str = super.paramString() + "," + modalityType;
if (title != null) {
str += ",title=" + title;
}
return str;
}
Initialize JNI field and method IDs
/**
* Initialize JNI field and method IDs
*/
private static native void initIDs();
/*
* --- Modality support ---
*
*/
/*
* This method is called only for modal dialogs.
*
* Goes through the list of all visible top-level windows and
* divide them into three distinct groups: blockers of this dialog,
* blocked by this dialog and all others. Then blocks this dialog
* by first met dialog from the first group (if any) and blocks all
* the windows from the second group.
*/
void modalShow() {
// find all the dialogs that block this one
IdentityArrayList<Dialog> blockers = new IdentityArrayList<Dialog>();
for (Dialog d : modalDialogs) {
if (d.shouldBlock(this)) {
Window w = d;
while ((w != null) && (w != this)) {
w = w.getOwner_NoClientCode();
}
if ((w == this) || !shouldBlock(d) || (modalityType.compareTo(d.getModalityType()) < 0)) {
blockers.add(d);
}
}
}
// add all blockers' blockers to blockers :)
for (int i = 0; i < blockers.size(); i++) {
Dialog blocker = blockers.get(i);
if (blocker.isModalBlocked()) {
Dialog blockerBlocker = blocker.getModalBlocker();
if (!blockers.contains(blockerBlocker)) {
blockers.add(i + 1, blockerBlocker);
}
}
}
if (blockers.size() > 0) {
blockers.get(0).blockWindow(this);
}
// find all windows from blockers' hierarchies
IdentityArrayList<Window> blockersHierarchies = new IdentityArrayList<Window>(blockers);
int k = 0;
while (k < blockersHierarchies.size()) {
Window w = blockersHierarchies.get(k);
Window[] ownedWindows = w.getOwnedWindows_NoClientCode();
for (Window win : ownedWindows) {
blockersHierarchies.add(win);
}
k++;
}
java.util.List<Window> toBlock = new IdentityLinkedList<Window>();
// block all windows from scope of blocking except from blockers' hierarchies
IdentityArrayList<Window> unblockedWindows = Window.getAllUnblockedWindows();
for (Window w : unblockedWindows) {
if (shouldBlock(w) && !blockersHierarchies.contains(w)) {
if ((w instanceof Dialog) && ((Dialog)w).isModal_NoClientCode()) {
Dialog wd = (Dialog)w;
if (wd.shouldBlock(this) && (modalDialogs.indexOf(wd) > modalDialogs.indexOf(this))) {
continue;
}
}
toBlock.add(w);
}
}
blockWindows(toBlock);
if (!isModalBlocked()) {
updateChildrenBlocking();
}
}
/*
* This method is called only for modal dialogs.
*
* Unblocks all the windows blocked by this modal dialog. After
* each of them has been unblocked, it is checked to be blocked by
* any other modal dialogs.
*/
void modalHide() {
// we should unblock all the windows first...
IdentityArrayList<Window> save = new IdentityArrayList<Window>();
int blockedWindowsCount = blockedWindows.size();
for (int i = 0; i < blockedWindowsCount; i++) {
Window w = blockedWindows.get(0);
save.add(w);
unblockWindow(w); // also removes w from blockedWindows
}
// ... and only after that check if they should be blocked
// by another dialogs
for (int i = 0; i < blockedWindowsCount; i++) {
Window w = save.get(i);
if ((w instanceof Dialog) && ((Dialog)w).isModal_NoClientCode()) {
Dialog d = (Dialog)w;
d.modalShow();
} else {
checkShouldBeBlocked(w);
}
}
}
/*
* Returns whether the given top-level window should be blocked by
* this dialog. Note, that the given window can be also a modal dialog
* and it should block this dialog, but this method do not take such
* situations into consideration (such checks are performed in the
* modalShow() and modalHide() methods).
*
* This method should be called on the getTreeLock() lock.
*/
boolean shouldBlock(Window w) {
if (!isVisible_NoClientCode() ||
(!w.isVisible_NoClientCode() && !w.isInShow) ||
isInHide ||
(w == this) ||
!isModal_NoClientCode())
{
return false;
}
if ((w instanceof Dialog) && ((Dialog)w).isInHide) {
return false;
}
// check if w is from children hierarchy
// fix for 6271546: we should also take into consideration child hierarchies
// of this dialog's blockers
Window blockerToCheck = this;
while (blockerToCheck != null) {
Component c = w;
while ((c != null) && (c != blockerToCheck)) {
c = c.getParent_NoClientCode();
}
if (c == blockerToCheck) {
return false;
}
blockerToCheck = blockerToCheck.getModalBlocker();
}
switch (modalityType) {
case MODELESS:
return false;
case DOCUMENT_MODAL:
if (w.isModalExcluded(ModalExclusionType.APPLICATION_EXCLUDE)) {
// application- and toolkit-excluded windows are not blocked by
// document-modal dialogs from outside their children hierarchy
Component c = this;
while ((c != null) && (c != w)) {
c = c.getParent_NoClientCode();
}
return c == w;
} else {
return getDocumentRoot() == w.getDocumentRoot();
}
case APPLICATION_MODAL:
return !w.isModalExcluded(ModalExclusionType.APPLICATION_EXCLUDE) &&
(appContext == w.appContext);
case TOOLKIT_MODAL:
return !w.isModalExcluded(ModalExclusionType.TOOLKIT_EXCLUDE);
}
return false;
}
/*
* Adds the given top-level window to the list of blocked
* windows for this dialog and marks it as modal blocked.
* If the window is already blocked by some modal dialog,
* does nothing.
*/
void blockWindow(Window w) {
if (!w.isModalBlocked()) {
w.setModalBlocked(this, true, true);
blockedWindows.add(w);
}
}
void blockWindows(java.util.List<Window> toBlock) {
DialogPeer dpeer = (DialogPeer)peer;
if (dpeer == null) {
return;
}
Iterator<Window> it = toBlock.iterator();
while (it.hasNext()) {
Window w = it.next();
if (!w.isModalBlocked()) {
w.setModalBlocked(this, true, false);
} else {
it.remove();
}
}
dpeer.blockWindows(toBlock);
blockedWindows.addAll(toBlock);
}
/*
* Removes the given top-level window from the list of blocked
* windows for this dialog and marks it as unblocked. If the
* window is not modal blocked, does nothing.
*/
void unblockWindow(Window w) {
if (w.isModalBlocked() && blockedWindows.contains(w)) {
blockedWindows.remove(w);
w.setModalBlocked(this, false, true);
}
}
/*
* Checks if any other modal dialog D blocks the given window.
* If such D exists, mark the window as blocked by D.
*/
static void checkShouldBeBlocked(Window w) {
synchronized (w.getTreeLock()) {
for (int i = 0; i < modalDialogs.size(); i++) {
Dialog modalDialog = modalDialogs.get(i);
if (modalDialog.shouldBlock(w)) {
modalDialog.blockWindow(w);
break;
}
}
}
}
private void checkModalityPermission(ModalityType mt) {
if (mt == ModalityType.TOOLKIT_MODAL) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(
SecurityConstants.AWT.TOOLKIT_MODALITY_PERMISSION
);
}
}
}
private void readObject(ObjectInputStream s)
throws ClassNotFoundException, IOException, HeadlessException
{
GraphicsEnvironment.checkHeadless();
java.io.ObjectInputStream.GetField fields =
s.readFields();
ModalityType localModalityType = (ModalityType)fields.get("modalityType", null);
try {
checkModalityPermission(localModalityType);
} catch (AccessControlException ace) {
localModalityType = DEFAULT_MODALITY_TYPE;
}
// in 1.5 or earlier modalityType was absent, so use "modal" instead
if (localModalityType == null) {
this.modal = fields.get("modal", false);
setModal(modal);
} else {
this.modalityType = localModalityType;
}
this.resizable = fields.get("resizable", true);
this.undecorated = fields.get("undecorated", false);
this.title = (String)fields.get("title", "");
blockedWindows = new IdentityArrayList<>();
SunToolkit.checkAndSetPolicy(this);
initialized = true;
}
/*
* --- Accessibility Support ---
*
*/
Gets the AccessibleContext associated with this Dialog.
For dialogs, the AccessibleContext takes the form of an
AccessibleAWTDialog.
A new AccessibleAWTDialog instance is created if necessary.
Returns: an AccessibleAWTDialog that serves as the
AccessibleContext of this Dialog Since: 1.3
/**
* Gets the AccessibleContext associated with this Dialog.
* For dialogs, the AccessibleContext takes the form of an
* AccessibleAWTDialog.
* A new AccessibleAWTDialog instance is created if necessary.
*
* @return an AccessibleAWTDialog that serves as the
* AccessibleContext of this Dialog
* @since 1.3
*/
public AccessibleContext getAccessibleContext() {
if (accessibleContext == null) {
accessibleContext = new AccessibleAWTDialog();
}
return accessibleContext;
}
This class implements accessibility support for the
Dialog
class. It provides an implementation of the
Java Accessibility API appropriate to dialog user-interface elements.
Since: 1.3
/**
* This class implements accessibility support for the
* <code>Dialog</code> class. It provides an implementation of the
* Java Accessibility API appropriate to dialog user-interface elements.
* @since 1.3
*/
protected class AccessibleAWTDialog extends AccessibleAWTWindow
{
/*
* JDK 1.3 serialVersionUID
*/
private static final long serialVersionUID = 4837230331833941201L;
Get the role of this object.
See Also: Returns: an instance of AccessibleRole describing the role of the
object
/**
* Get the role of this object.
*
* @return an instance of AccessibleRole describing the role of the
* object
* @see AccessibleRole
*/
public AccessibleRole getAccessibleRole() {
return AccessibleRole.DIALOG;
}
Get the state of this object.
See Also: Returns: an instance of AccessibleStateSet containing the current
state set of the object
/**
* Get the state of this object.
*
* @return an instance of AccessibleStateSet containing the current
* state set of the object
* @see AccessibleState
*/
public AccessibleStateSet getAccessibleStateSet() {
AccessibleStateSet states = super.getAccessibleStateSet();
if (getFocusOwner() != null) {
states.add(AccessibleState.ACTIVE);
}
if (isModal()) {
states.add(AccessibleState.MODAL);
}
if (isResizable()) {
states.add(AccessibleState.RESIZABLE);
}
return states;
}
} // inner class AccessibleAWTDialog
}