Showing the changes to java/pkg/java/awt/Dialog.java (1 of 18352 files). Show all
Unified · Split
| @@ -0,0 +1,1680 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved. | ||
| 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | ||
| 4 | * | ||
| 5 | * This code is free software; you can redistribute it and/or modify it | ||
| 6 | * under the terms of the GNU General Public License version 2 only, as | ||
| 7 | * published by the Free Software Foundation. Oracle designates this | ||
| 8 | * particular file as subject to the "Classpath" exception as provided | ||
| 9 | * by Oracle in the LICENSE file that accompanied this code. | ||
| 10 | * | ||
| 11 | * This code is distributed in the hope that it will be useful, but WITHOUT | ||
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
| 14 | * version 2 for more details (a copy is included in the LICENSE file that | ||
| 15 | * accompanied this code). | ||
| 16 | * | ||
| 17 | * You should have received a copy of the GNU General Public License version | ||
| 18 | * 2 along with this work; if not, write to the Free Software Foundation, | ||
| 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| 20 | * | ||
| 21 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | ||
| 22 | * or visit www.oracle.com if you need additional information or have any | ||
| 23 | * questions. | ||
| 24 | */ | ||
| 25 | package java.awt; | ||
| 26 | |||
| 27 | import java.awt.peer.DialogPeer; | ||
| 28 | import java.awt.event.*; | ||
| 29 | import java.io.ObjectInputStream; | ||
| 30 | import java.io.IOException; | ||
| 31 | import java.util.Iterator; | ||
| 32 | import java.util.concurrent.atomic.AtomicLong; | ||
| 33 | import java.security.AccessController; | ||
| 34 | import java.security.PrivilegedAction; | ||
| 35 | import javax.accessibility.*; | ||
| 36 | import sun.awt.AppContext; | ||
| 37 | import sun.awt.SunToolkit; | ||
| 38 | import sun.awt.PeerEvent; | ||
| 39 | import sun.awt.util.IdentityArrayList; | ||
| 40 | import sun.awt.util.IdentityLinkedList; | ||
| 41 | import sun.security.util.SecurityConstants; | ||
| 42 | |||
| 43 | /** | ||
| 44 | * A Dialog is a top-level window with a title and a border | ||
| 45 | * that is typically used to take some form of input from the user. | ||
| 46 | * | ||
| 47 | * The size of the dialog includes any area designated for the | ||
| 48 | * border. The dimensions of the border area can be obtained | ||
| 49 | * using the <code>getInsets</code> method, however, since | ||
| 50 | * these dimensions are platform-dependent, a valid insets | ||
| 51 | * value cannot be obtained until the dialog is made displayable | ||
| 52 | * by either calling <code>pack</code> or <code>show</code>. | ||
| 53 | * Since the border area is included in the overall size of the | ||
| 54 | * dialog, the border effectively obscures a portion of the dialog, | ||
| 55 | * constraining the area available for rendering and/or displaying | ||
| 56 | * subcomponents to the rectangle which has an upper-left corner | ||
| 57 | * location of <code>(insets.left, insets.top)</code>, and has a size of | ||
| 58 | * <code>width - (insets.left + insets.right)</code> by | ||
| 59 | * <code>height - (insets.top + insets.bottom)</code>. | ||
| 60 | * <p> | ||
| 61 | * The default layout for a dialog is <code>BorderLayout</code>. | ||
| 62 | * <p> | ||
| 63 | * A dialog may have its native decorations (i.e. Frame & Titlebar) turned off | ||
| 64 | * with <code>setUndecorated</code>. This can only be done while the dialog | ||
| 65 | * is not {@link Component#isDisplayable() displayable}. | ||
| 66 | * <p> | ||
| 67 | * A dialog may have another window as its owner when it's constructed. When | ||
| 68 | * the owner window of a visible dialog is minimized, the dialog will | ||
| 69 | * automatically be hidden from the user. When the owner window is subsequently | ||
| 70 | * restored, the dialog is made visible to the user again. | ||
| 71 | * <p> | ||
| 72 | * In a multi-screen environment, you can create a <code>Dialog</code> | ||
| 73 | * on a different screen device than its owner. See {@link java.awt.Frame} for | ||
| 74 | * more information. | ||
| 75 | * <p> | ||
| 76 | * A dialog can be either modeless (the default) or modal. A modal | ||
| 77 | * dialog is one which blocks input to some other top-level windows | ||
| 78 | * in the application, except for any windows created with the dialog | ||
| 79 | * as their owner. See <a href="doc-files/Modality.html">AWT Modality</a> | ||
| 80 | * specification for details. | ||
| 81 | * <p> | ||
| 82 | * Dialogs are capable of generating the following | ||
| 83 | * <code>WindowEvents</code>: | ||
| 84 | * <code>WindowOpened</code>, <code>WindowClosing</code>, | ||
| 85 | * <code>WindowClosed</code>, <code>WindowActivated</code>, | ||
| 86 | * <code>WindowDeactivated</code>, <code>WindowGainedFocus</code>, | ||
| 87 | * <code>WindowLostFocus</code>. | ||
| 88 | * | ||
| 89 | * @see WindowEvent | ||
| 90 | * @see Window#addWindowListener | ||
| 91 | * | ||
| 92 | * @author Sami Shaio | ||
| 93 | * @author Arthur van Hoff | ||
| 94 | * @since JDK1.0 | ||
| 95 | */ | ||
| 96 | public class Dialog extends Window { | ||
| 97 | |||
| 98 | static { | ||
| 99 | /* ensure that the necessary native libraries are loaded */ | ||
| 100 | Toolkit.loadLibraries(); | ||
| 101 | if (!GraphicsEnvironment.isHeadless()) { | ||
| 102 | initIDs(); | ||
| 103 | } | ||
| 104 | } | ||
| 105 | |||
| 106 | /** | ||
| 107 | * A dialog's resizable property. Will be true | ||
| 108 | * if the Dialog is to be resizable, otherwise | ||
| 109 | * it will be false. | ||
| 110 | * | ||
| 111 | * @serial | ||
| 112 | * @see #setResizable(boolean) | ||
| 113 | */ | ||
| 114 | boolean resizable = true; | ||
| 115 | |||
| 116 | |||
| 117 | /** | ||
| 118 | * This field indicates whether the dialog is undecorated. | ||
| 119 | * This property can only be changed while the dialog is not displayable. | ||
| 120 | * <code>undecorated</code> will be true if the dialog is | ||
| 121 | * undecorated, otherwise it will be false. | ||
| 122 | * | ||
| 123 | * @serial | ||
| 124 | * @see #setUndecorated(boolean) | ||
| 125 | * @see #isUndecorated() | ||
| 126 | * @see Component#isDisplayable() | ||
| 127 | * @since 1.4 | ||
| 128 | */ | ||
| 129 | boolean undecorated = false; | ||
| 130 | |||
| 131 | /** | ||
| 132 | * Modal dialogs block all input to some top-level windows. | ||
| 133 | * Whether a particular window is blocked depends on dialog's type | ||
| 134 | * of modality; this is called the "scope of blocking". The | ||
| 135 | * <code>ModalityType</code> enum specifies modal types and their | ||
| 136 | * associated scopes. | ||
| 137 | * | ||
| 138 | * @see Dialog#getModalityType | ||
| 139 | * @see Dialog#setModalityType | ||
| 140 | * @see Toolkit#isModalityTypeSupported | ||
| 141 | * | ||
| 142 | * @since 1.6 | ||
| 143 | */ | ||
| 144 | public static enum ModalityType { | ||
| 145 | /** | ||
| 146 | * <code>MODELESS</code> dialog doesn't block any top-level windows. | ||
| 147 | */ | ||
| 148 | MODELESS, | ||
| 149 | /** | ||
| 150 | * A <code>DOCUMENT_MODAL</code> dialog blocks input to all top-level windows | ||
| 151 | * from the same document except those from its own child hierarchy. | ||
| 152 | * A document is a top-level window without an owner. It may contain child | ||
| 153 | * windows that, together with the top-level window are treated as a single | ||
| 154 | * solid document. Since every top-level window must belong to some | ||
| 155 | * document, its root can be found as the top-nearest window without an owner. | ||
| 156 | */ | ||
| 157 | DOCUMENT_MODAL, | ||
| 158 | /** | ||
| 159 | * An <code>APPLICATION_MODAL</code> dialog blocks all top-level windows | ||
| 160 | * from the same Java application except those from its own child hierarchy. | ||
| 161 | * If there are several applets launched in a browser, they can be | ||
| 162 | * treated either as separate applications or a single one. This behavior | ||
| 163 | * is implementation-dependent. | ||
| 164 | */ | ||
| 165 | APPLICATION_MODAL, | ||
| 166 | /** | ||
| 167 | * A <code>TOOLKIT_MODAL</code> dialog blocks all top-level windows run | ||
| 168 | * from the same toolkit except those from its own child hierarchy. If there | ||
| 169 | * are several applets launched in a browser, all of them run with the same | ||
| 170 | * toolkit; thus, a toolkit-modal dialog displayed by an applet may affect | ||
| 171 | * other applets and all windows of the browser instance which embeds the | ||
| 172 | * Java runtime environment for this toolkit. | ||
| 173 | * Special <code>AWTPermission</code> "toolkitModality" must be granted to use | ||
| 174 | * toolkit-modal dialogs. If a <code>TOOLKIT_MODAL</code> dialog is being created | ||
| 175 | * and this permission is not granted, a <code>SecurityException</code> will be | ||
| 176 | * thrown, and no dialog will be created. If a modality type is being changed | ||
| 177 | * to <code>TOOLKIT_MODAL</code> and this permission is not granted, a | ||
| 178 | * <code>SecurityException</code> will be thrown, and the modality type will | ||
| 179 | * be left unchanged. | ||
| 180 | */ | ||
| 181 | TOOLKIT_MODAL | ||
| 182 | }; | ||
| 183 | |||
| 184 | /** | ||
| 185 | * Default modality type for modal dialogs. The default modality type is | ||
| 186 | * <code>APPLICATION_MODAL</code>. Calling the oldstyle <code>setModal(true)</code> | ||
| 187 | * is equal to <code>setModalityType(DEFAULT_MODALITY_TYPE)</code>. | ||
| 188 | * | ||
| 189 | * @see java.awt.Dialog.ModalityType | ||
| 190 | * @see java.awt.Dialog#setModal | ||
| 191 | * | ||
| 192 | * @since 1.6 | ||
| 193 | */ | ||
| 194 | public final static ModalityType DEFAULT_MODALITY_TYPE = ModalityType.APPLICATION_MODAL; | ||
| 195 | |||
| 196 | /** | ||
| 197 | * True if this dialog is modal, false is the dialog is modeless. | ||
| 198 | * A modal dialog blocks user input to some application top-level | ||
| 199 | * windows. This field is kept only for backwards compatibility. Use the | ||
| 200 | * {@link Dialog.ModalityType ModalityType} enum instead. | ||
| 201 | * | ||
| 202 | * @serial | ||
| 203 | * | ||
| 204 | * @see #isModal | ||
| 205 | * @see #setModal | ||
| 206 | * @see #getModalityType | ||
| 207 | * @see #setModalityType | ||
| 208 | * @see ModalityType | ||
| 209 | * @see ModalityType#MODELESS | ||
| 210 | * @see #DEFAULT_MODALITY_TYPE | ||
| 211 | */ | ||
| 212 | boolean modal; | ||
| 213 | |||
| 214 | /** | ||
| 215 | * Modality type of this dialog. If the dialog's modality type is not | ||
| 216 | * {@link Dialog.ModalityType#MODELESS ModalityType.MODELESS}, it blocks all | ||
| 217 | * user input to some application top-level windows. | ||
| 218 | * | ||
| 219 | * @serial | ||
| 220 | * | ||
| 221 | * @see ModalityType | ||
| 222 | * @see #getModalityType | ||
| 223 | * @see #setModalityType | ||
| 224 | * | ||
| 225 | * @since 1.6 | ||
| 226 | */ | ||
| 227 | ModalityType modalityType; | ||
| 228 | |||
| 229 | /** | ||
| 230 | * Any top-level window can be marked not to be blocked by modal | ||
| 231 | * dialogs. This is called "modal exclusion". This enum specifies | ||
| 232 | * the possible modal exclusion types. | ||
| 233 | * | ||
| 234 | * @see Window#getModalExclusionType | ||
| 235 | * @see Window#setModalExclusionType | ||
| 236 | * @see Toolkit#isModalExclusionTypeSupported | ||
| 237 | * | ||
| 238 | * @since 1.6 | ||
| 239 | */ | ||
| 240 | public static enum ModalExclusionType { | ||
| 241 | /** | ||
| 242 | * No modal exclusion. | ||
| 243 | */ | ||
| 244 | NO_EXCLUDE, | ||
| 245 | /** | ||
| 246 | * <code>APPLICATION_EXCLUDE</code> indicates that a top-level window | ||
| 247 | * won't be blocked by any application-modal dialogs. Also, it isn't | ||
| 248 | * blocked by document-modal dialogs from outside of its child hierarchy. | ||
| 249 | */ | ||
| 250 | APPLICATION_EXCLUDE, | ||
| 251 | /** | ||
| 252 | * <code>TOOLKIT_EXCLUDE</code> indicates that a top-level window | ||
| 253 | * won't be blocked by application-modal or toolkit-modal dialogs. Also, | ||
| 254 | * it isn't blocked by document-modal dialogs from outside of its | ||
| 255 | * child hierarchy. | ||
| 256 | * The "toolkitModality" <code>AWTPermission</code> must be granted | ||
| 257 | * for this exclusion. If an exclusion property is being changed to | ||
| 258 | * <code>TOOLKIT_EXCLUDE</code> and this permission is not granted, a | ||
| 259 | * <code>SecurityEcxeption</code> will be thrown, and the exclusion | ||
| 260 | * property will be left unchanged. | ||
| 261 | */ | ||
| 262 | TOOLKIT_EXCLUDE | ||
| 263 | }; | ||
| 264 | |||
| 265 | /* operations with this list should be synchronized on tree lock*/ | ||
| 266 | transient static IdentityArrayList<Dialog> modalDialogs = new IdentityArrayList<Dialog>(); | ||
| 267 | |||
| 268 | transient IdentityArrayList<Window> blockedWindows = new IdentityArrayList<Window>(); | ||
| 269 | |||
| 270 | /** | ||
| 271 | * Specifies the title of the Dialog. | ||
| 272 | * This field can be null. | ||
| 273 | * | ||
| 274 | * @serial | ||
| 275 | * @see #getTitle() | ||
| 276 | * @see #setTitle(String) | ||
| 277 | */ | ||
| 278 | String title; | ||
| 279 | |||
| 280 | private transient ModalEventFilter modalFilter; | ||
| 281 | private transient volatile SecondaryLoop secondaryLoop; | ||
| 282 | |||
| 283 | /* | ||
| 284 | * Indicates that this dialog is being hidden. This flag is set to true at | ||
| 285 | * the beginning of hide() and to false at the end of hide(). | ||
| 286 | * | ||
| 287 | * @see #hide() | ||
| 288 | * @see #hideAndDisposePreHandler() | ||
| 289 | * @see #hideAndDisposeHandler() | ||
| 290 | * @see #shouldBlock() | ||
| 291 | */ | ||
| 292 | transient volatile boolean isInHide = false; | ||
| 293 | |||
| 294 | /* | ||
| 295 | * Indicates that this dialog is being disposed. This flag is set to true at | ||
| 296 | * the beginning of doDispose() and to false at the end of doDispose(). | ||
| 297 | * | ||
| 298 | * @see #hide() | ||
| 299 | * @see #hideAndDisposePreHandler() | ||
| 300 | * @see #hideAndDisposeHandler() | ||
| 301 | * @see #doDispose() | ||
| 302 | */ | ||
| 303 | transient volatile boolean isInDispose = false; | ||
| 304 | |||
| 305 | private static final String base = "dialog"; | ||
| 306 | private static int nameCounter = 0; | ||
| 307 | |||
| 308 | /* | ||
| 309 | * JDK 1.1 serialVersionUID | ||
| 310 | */ | ||
| 311 | private static final long serialVersionUID = 5920926903803293709L; | ||
| 312 | |||
| 313 | /** | ||
| 314 | * Constructs an initially invisible, modeless <code>Dialog</code> with | ||
| 315 | * the specified owner <code>Frame</code> and an empty title. | ||
| 316 | * | ||
| 317 | * @param owner the owner of the dialog or <code>null</code> if | ||
| 318 | * this dialog has no owner | ||
| 319 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 320 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 321 | * @exception HeadlessException when | ||
| 322 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 323 | * | ||
| 324 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 325 | * @see Component#setSize | ||
| 326 | * @see Component#setVisible | ||
| 327 | */ | ||
| 328 | public Dialog(Frame owner) { | ||
| 329 | this(owner, "", false); | ||
| 330 | } | ||
| 331 | |||
| 332 | /** | ||
| 333 | * Constructs an initially invisible <code>Dialog</code> with the specified | ||
| 334 | * owner <code>Frame</code> and modality and an empty title. | ||
| 335 | * | ||
| 336 | * @param owner the owner of the dialog or <code>null</code> if | ||
| 337 | * this dialog has no owner | ||
| 338 | * @param modal specifes whether dialog blocks user input to other top-level | ||
| 339 | * windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>; | ||
| 340 | * if <code>true</code>, the modality type property is set to | ||
| 341 | * <code>DEFAULT_MODALITY_TYPE</code> | ||
| 342 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 343 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 344 | * @exception HeadlessException when | ||
| 345 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 346 | * | ||
| 347 | * @see java.awt.Dialog.ModalityType | ||
| 348 | * @see java.awt.Dialog.ModalityType#MODELESS | ||
| 349 | * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE | ||
| 350 | * @see java.awt.Dialog#setModal | ||
| 351 | * @see java.awt.Dialog#setModalityType | ||
| 352 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 353 | */ | ||
| 354 | public Dialog(Frame owner, boolean modal) { | ||
| 355 | this(owner, "", modal); | ||
| 356 | } | ||
| 357 | |||
| 358 | /** | ||
| 359 | * Constructs an initially invisible, modeless <code>Dialog</code> with | ||
| 360 | * the specified owner <code>Frame</code> and title. | ||
| 361 | * | ||
| 362 | * @param owner the owner of the dialog or <code>null</code> if | ||
| 363 | * this dialog has no owner | ||
| 364 | * @param title the title of the dialog or <code>null</code> if this dialog | ||
| 365 | * has no title | ||
| 366 | * @exception IllegalArgumentException if the <code>owner</code>'s | ||
| 367 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 368 | * @exception HeadlessException when | ||
| 369 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 370 | * | ||
| 371 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 372 | * @see Component#setSize | ||
| 373 | * @see Component#setVisible | ||
| 374 | */ | ||
| 375 | public Dialog(Frame owner, String title) { | ||
| 376 | this(owner, title, false); | ||
| 377 | } | ||
| 378 | |||
| 379 | /** | ||
| 380 | * Constructs an initially invisible <code>Dialog</code> with the | ||
| 381 | * specified owner <code>Frame</code>, title and modality. | ||
| 382 | * | ||
| 383 | * @param owner the owner of the dialog or <code>null</code> if | ||
| 384 | * this dialog has no owner | ||
| 385 | * @param title the title of the dialog or <code>null</code> if this dialog | ||
| 386 | * has no title | ||
| 387 | * @param modal specifes whether dialog blocks user input to other top-level | ||
| 388 | * windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>; | ||
| 389 | * if <code>true</code>, the modality type property is set to | ||
| 390 | * <code>DEFAULT_MODALITY_TYPE</code> | ||
| 391 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 392 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 393 | * @exception HeadlessException when | ||
| 394 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 395 | * | ||
| 396 | * @see java.awt.Dialog.ModalityType | ||
| 397 | * @see java.awt.Dialog.ModalityType#MODELESS | ||
| 398 | * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE | ||
| 399 | * @see java.awt.Dialog#setModal | ||
| 400 | * @see java.awt.Dialog#setModalityType | ||
| 401 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 402 | * @see Component#setSize | ||
| 403 | * @see Component#setVisible | ||
| 404 | */ | ||
| 405 | public Dialog(Frame owner, String title, boolean modal) { | ||
| 406 | this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS); | ||
| 407 | } | ||
| 408 | |||
| 409 | /** | ||
| 410 | * Constructs an initially invisible <code>Dialog</code> with the specified owner | ||
| 411 | * <code>Frame</code>, title, modality, and <code>GraphicsConfiguration</code>. | ||
| 412 | * @param owner the owner of the dialog or <code>null</code> if this dialog | ||
| 413 | * has no owner | ||
| 414 | * @param title the title of the dialog or <code>null</code> if this dialog | ||
| 415 | * has no title | ||
| 416 | * @param modal specifes whether dialog blocks user input to other top-level | ||
| 417 | * windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>; | ||
| 418 | * if <code>true</code>, the modality type property is set to | ||
| 419 | * <code>DEFAULT_MODALITY_TYPE</code> | ||
| 420 | * @param gc the <code>GraphicsConfiguration</code> of the target screen device; | ||
| 421 | * if <code>null</code>, the default system <code>GraphicsConfiguration</code> | ||
| 422 | * is assumed | ||
| 423 | * @exception java.lang.IllegalArgumentException if <code>gc</code> | ||
| 424 | * is not from a screen device | ||
| 425 | * @exception HeadlessException when | ||
| 426 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 427 | * | ||
| 428 | * @see java.awt.Dialog.ModalityType | ||
| 429 | * @see java.awt.Dialog.ModalityType#MODELESS | ||
| 430 | * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE | ||
| 431 | * @see java.awt.Dialog#setModal | ||
| 432 | * @see java.awt.Dialog#setModalityType | ||
| 433 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 434 | * @see Component#setSize | ||
| 435 | * @see Component#setVisible | ||
| 436 | * @since 1.4 | ||
| 437 | */ | ||
| 438 | public Dialog(Frame owner, String title, boolean modal, | ||
| 439 | GraphicsConfiguration gc) { | ||
| 440 | this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS, gc); | ||
| 441 | } | ||
| 442 | |||
| 443 | /** | ||
| 444 | * Constructs an initially invisible, modeless <code>Dialog</code> with | ||
| 445 | * the specified owner <code>Dialog</code> and an empty title. | ||
| 446 | * | ||
| 447 | * @param owner the owner of the dialog or <code>null</code> if this | ||
| 448 | * dialog has no owner | ||
| 449 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 450 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 451 | * @exception HeadlessException when | ||
| 452 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 453 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 454 | * @since 1.2 | ||
| 455 | */ | ||
| 456 | public Dialog(Dialog owner) { | ||
| 457 | this(owner, "", false); | ||
| 458 | } | ||
| 459 | |||
| 460 | /** | ||
| 461 | * Constructs an initially invisible, modeless <code>Dialog</code> | ||
| 462 | * with the specified owner <code>Dialog</code> and title. | ||
| 463 | * | ||
| 464 | * @param owner the owner of the dialog or <code>null</code> if this | ||
| 465 | * has no owner | ||
| 466 | * @param title the title of the dialog or <code>null</code> if this dialog | ||
| 467 | * has no title | ||
| 468 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 469 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 470 | * @exception HeadlessException when | ||
| 471 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 472 | * | ||
| 473 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 474 | * @since 1.2 | ||
| 475 | */ | ||
| 476 | public Dialog(Dialog owner, String title) { | ||
| 477 | this(owner, title, false); | ||
| 478 | } | ||
| 479 | |||
| 480 | /** | ||
| 481 | * Constructs an initially invisible <code>Dialog</code> with the | ||
| 482 | * specified owner <code>Dialog</code>, title, and modality. | ||
| 483 | * | ||
| 484 | * @param owner the owner of the dialog or <code>null</code> if this | ||
| 485 | * dialog has no owner | ||
| 486 | * @param title the title of the dialog or <code>null</code> if this | ||
| 487 | * dialog has no title | ||
| 488 | * @param modal specifes whether dialog blocks user input to other top-level | ||
| 489 | * windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>; | ||
| 490 | * if <code>true</code>, the modality type property is set to | ||
| 491 | * <code>DEFAULT_MODALITY_TYPE</code> | ||
| 492 | * @exception IllegalArgumentException if the <code>owner</code>'s | ||
| 493 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 494 | * @exception HeadlessException when | ||
| 495 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 496 | * | ||
| 497 | * @see java.awt.Dialog.ModalityType | ||
| 498 | * @see java.awt.Dialog.ModalityType#MODELESS | ||
| 499 | * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE | ||
| 500 | * @see java.awt.Dialog#setModal | ||
| 501 | * @see java.awt.Dialog#setModalityType | ||
| 502 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 503 | * | ||
| 504 | * @since 1.2 | ||
| 505 | */ | ||
| 506 | public Dialog(Dialog owner, String title, boolean modal) { | ||
| 507 | this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS); | ||
| 508 | } | ||
| 509 | |||
| 510 | /** | ||
| 511 | * Constructs an initially invisible <code>Dialog</code> with the | ||
| 512 | * specified owner <code>Dialog</code>, title, modality and | ||
| 513 | * <code>GraphicsConfiguration</code>. | ||
| 514 | * | ||
| 515 | * @param owner the owner of the dialog or <code>null</code> if this | ||
| 516 | * dialog has no owner | ||
| 517 | * @param title the title of the dialog or <code>null</code> if this | ||
| 518 | * dialog has no title | ||
| 519 | * @param modal specifes whether dialog blocks user input to other top-level | ||
| 520 | * windows when shown. If <code>false</code>, the dialog is <code>MODELESS</code>; | ||
| 521 | * if <code>true</code>, the modality type property is set to | ||
| 522 | * <code>DEFAULT_MODALITY_TYPE</code> | ||
| 523 | * @param gc the <code>GraphicsConfiguration</code> of the target screen device; | ||
| 524 | * if <code>null</code>, the default system <code>GraphicsConfiguration</code> | ||
| 525 | * is assumed | ||
| 526 | * @exception java.lang.IllegalArgumentException if <code>gc</code> | ||
| 527 | * is not from a screen device | ||
| 528 | * @exception HeadlessException when | ||
| 529 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 530 | * | ||
| 531 | * @see java.awt.Dialog.ModalityType | ||
| 532 | * @see java.awt.Dialog.ModalityType#MODELESS | ||
| 533 | * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE | ||
| 534 | * @see java.awt.Dialog#setModal | ||
| 535 | * @see java.awt.Dialog#setModalityType | ||
| 536 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 537 | * @see Component#setSize | ||
| 538 | * @see Component#setVisible | ||
| 539 | * | ||
| 540 | * @since 1.4 | ||
| 541 | */ | ||
| 542 | public Dialog(Dialog owner, String title, boolean modal, | ||
| 543 | GraphicsConfiguration gc) { | ||
| 544 | this(owner, title, modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS, gc); | ||
| 545 | } | ||
| 546 | |||
| 547 | /** | ||
| 548 | * Constructs an initially invisible, modeless <code>Dialog</code> with the | ||
| 549 | * specified owner <code>Window</code> and an empty title. | ||
| 550 | * | ||
| 551 | * @param owner the owner of the dialog. The owner must be an instance of | ||
| 552 | * {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any | ||
| 553 | * of their descendents or <code>null</code> | ||
| 554 | * | ||
| 555 | * @exception java.lang.IllegalArgumentException if the <code>owner</code> | ||
| 556 | * is not an instance of {@link java.awt.Dialog Dialog} or {@link | ||
| 557 | * java.awt.Frame Frame} | ||
| 558 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 559 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 560 | * @exception HeadlessException when | ||
| 561 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 562 | * | ||
| 563 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 564 | * | ||
| 565 | * @since 1.6 | ||
| 566 | */ | ||
| 567 | public Dialog(Window owner) { | ||
| 568 | this(owner, "", ModalityType.MODELESS); | ||
| 569 | } | ||
| 570 | |||
| 571 | /** | ||
| 572 | * Constructs an initially invisible, modeless <code>Dialog</code> with | ||
| 573 | * the specified owner <code>Window</code> and title. | ||
| 574 | * | ||
| 575 | * @param owner the owner of the dialog. The owner must be an instance of | ||
| 576 | * {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any | ||
| 577 | * of their descendents or <code>null</code> | ||
| 578 | * @param title the title of the dialog or <code>null</code> if this dialog | ||
| 579 | * has no title | ||
| 580 | * | ||
| 581 | * @exception java.lang.IllegalArgumentException if the <code>owner</code> | ||
| 582 | * is not an instance of {@link java.awt.Dialog Dialog} or {@link | ||
| 583 | * java.awt.Frame Frame} | ||
| 584 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 585 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 586 | * @exception HeadlessException when | ||
| 587 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 588 | * | ||
| 589 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 590 | * | ||
| 591 | * @since 1.6 | ||
| 592 | */ | ||
| 593 | public Dialog(Window owner, String title) { | ||
| 594 | this(owner, title, ModalityType.MODELESS); | ||
| 595 | } | ||
| 596 | |||
| 597 | /** | ||
| 598 | * Constructs an initially invisible <code>Dialog</code> with the | ||
| 599 | * specified owner <code>Window</code> and modality and an empty title. | ||
| 600 | * | ||
| 601 | * @param owner the owner of the dialog. The owner must be an instance of | ||
| 602 | * {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any | ||
| 603 | * of their descendents or <code>null</code> | ||
| 604 | * @param modalityType specifies whether dialog blocks input to other | ||
| 605 | * windows when shown. <code>null</code> value and unsupported modality | ||
| 606 | * types are equivalent to <code>MODELESS</code> | ||
| 607 | * | ||
| 608 | * @exception java.lang.IllegalArgumentException if the <code>owner</code> | ||
| 609 | * is not an instance of {@link java.awt.Dialog Dialog} or {@link | ||
| 610 | * java.awt.Frame Frame} | ||
| 611 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 612 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 613 | * @exception HeadlessException when | ||
| 614 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 615 | * @exception SecurityException if the calling thread does not have permission | ||
| 616 | * to create modal dialogs with the given <code>modalityType</code> | ||
| 617 | * | ||
| 618 | * @see java.awt.Dialog.ModalityType | ||
| 619 | * @see java.awt.Dialog#setModal | ||
| 620 | * @see java.awt.Dialog#setModalityType | ||
| 621 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 622 | * @see java.awt.Toolkit#isModalityTypeSupported | ||
| 623 | * | ||
| 624 | * @since 1.6 | ||
| 625 | */ | ||
| 626 | public Dialog(Window owner, ModalityType modalityType) { | ||
| 627 | this(owner, "", modalityType); | ||
| 628 | } | ||
| 629 | |||
| 630 | /** | ||
| 631 | * Constructs an initially invisible <code>Dialog</code> with the | ||
| 632 | * specified owner <code>Window</code>, title and modality. | ||
| 633 | * | ||
| 634 | * @param owner the owner of the dialog. The owner must be an instance of | ||
| 635 | * {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any | ||
| 636 | * of their descendents or <code>null</code> | ||
| 637 | * @param title the title of the dialog or <code>null</code> if this dialog | ||
| 638 | * has no title | ||
| 639 | * @param modalityType specifies whether dialog blocks input to other | ||
| 640 | * windows when shown. <code>null</code> value and unsupported modality | ||
| 641 | * types are equivalent to <code>MODELESS</code> | ||
| 642 | * | ||
| 643 | * @exception java.lang.IllegalArgumentException if the <code>owner</code> | ||
| 644 | * is not an instance of {@link java.awt.Dialog Dialog} or {@link | ||
| 645 | * java.awt.Frame Frame} | ||
| 646 | * @exception java.lang.IllegalArgumentException if the <code>owner</code>'s | ||
| 647 | * <code>GraphicsConfiguration</code> is not from a screen device | ||
| 648 | * @exception HeadlessException when | ||
| 649 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 650 | * @exception SecurityException if the calling thread does not have permission | ||
| 651 | * to create modal dialogs with the given <code>modalityType</code> | ||
| 652 | * | ||
| 653 | * @see java.awt.Dialog.ModalityType | ||
| 654 | * @see java.awt.Dialog#setModal | ||
| 655 | * @see java.awt.Dialog#setModalityType | ||
| 656 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 657 | * @see java.awt.Toolkit#isModalityTypeSupported | ||
| 658 | * | ||
| 659 | * @since 1.6 | ||
| 660 | */ | ||
| 661 | public Dialog(Window owner, String title, ModalityType modalityType) { | ||
| 662 | super(owner); | ||
| 663 | |||
| 664 | if ((owner != null) && | ||
| 665 | !(owner instanceof Frame) && | ||
| 666 | !(owner instanceof Dialog)) | ||
| 667 | { | ||
| 668 | throw new IllegalArgumentException("Wrong parent window"); | ||
| 669 | } | ||
| 670 | |||
| 671 | this.title = title; | ||
| 672 | setModalityType(modalityType); | ||
| 673 | SunToolkit.checkAndSetPolicy(this, false); | ||
| 674 | } | ||
| 675 | |||
| 676 | /** | ||
| 677 | * Constructs an initially invisible <code>Dialog</code> with the | ||
| 678 | * specified owner <code>Window</code>, title, modality and | ||
| 679 | * <code>GraphicsConfiguration</code>. | ||
| 680 | * | ||
| 681 | * @param owner the owner of the dialog. The owner must be an instance of | ||
| 682 | * {@link java.awt.Dialog Dialog}, {@link java.awt.Frame Frame}, any | ||
| 683 | * of their descendents or <code>null</code> | ||
| 684 | * @param title the title of the dialog or <code>null</code> if this dialog | ||
| 685 | * has no title | ||
| 686 | * @param modalityType specifies whether dialog blocks input to other | ||
| 687 | * windows when shown. <code>null</code> value and unsupported modality | ||
| 688 | * types are equivalent to <code>MODELESS</code> | ||
| 689 | * @param gc the <code>GraphicsConfiguration</code> of the target screen device; | ||
| 690 | * if <code>null</code>, the default system <code>GraphicsConfiguration</code> | ||
| 691 | * is assumed | ||
| 692 | * | ||
| 693 | * @exception java.lang.IllegalArgumentException if the <code>owner</code> | ||
| 694 | * is not an instance of {@link java.awt.Dialog Dialog} or {@link | ||
| 695 | * java.awt.Frame Frame} | ||
| 696 | * @exception java.lang.IllegalArgumentException if <code>gc</code> | ||
| 697 | * is not from a screen device | ||
| 698 | * @exception HeadlessException when | ||
| 699 | * <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code> | ||
| 700 | * @exception SecurityException if the calling thread does not have permission | ||
| 701 | * to create modal dialogs with the given <code>modalityType</code> | ||
| 702 | * | ||
| 703 | * @see java.awt.Dialog.ModalityType | ||
| 704 | * @see java.awt.Dialog#setModal | ||
| 705 | * @see java.awt.Dialog#setModalityType | ||
| 706 | * @see java.awt.GraphicsEnvironment#isHeadless | ||
| 707 | * @see java.awt.Toolkit#isModalityTypeSupported | ||
| 708 | * | ||
| 709 | * @since 1.6 | ||
| 710 | */ | ||
| 711 | public Dialog(Window owner, String title, ModalityType modalityType, | ||
| 712 | GraphicsConfiguration gc) { | ||
| 713 | super(owner, gc); | ||
| 714 | |||
| 715 | if ((owner != null) && | ||
| 716 | !(owner instanceof Frame) && | ||
| 717 | !(owner instanceof Dialog)) | ||
| 718 | { | ||
| 719 | throw new IllegalArgumentException("wrong owner window"); | ||
| 720 | } | ||
| 721 | |||
| 722 | this.title = title; | ||
| 723 | setModalityType(modalityType); | ||
| 724 | SunToolkit.checkAndSetPolicy(this, false); | ||
| 725 | } | ||
| 726 | |||
| 727 | /** | ||
| 728 | * Construct a name for this component. Called by getName() when the | ||
| 729 | * name is null. | ||
| 730 | */ | ||
| 731 | String constructComponentName() { | ||
| 732 | synchronized (Dialog.class) { | ||
| 733 | return base + nameCounter++; | ||
| 734 | } | ||
| 735 | } | ||
| 736 | |||
| 737 | /** | ||
| 738 | * Makes this Dialog displayable by connecting it to | ||
| 739 | * a native screen resource. Making a dialog displayable will | ||
| 740 | * cause any of its children to be made displayable. | ||
| 741 | * This method is called internally by the toolkit and should | ||
| 742 | * not be called directly by programs. | ||
| 743 | * @see Component#isDisplayable | ||
| 744 | * @see #removeNotify | ||
| 745 | */ | ||
| 746 | public void addNotify() { | ||
| 747 | synchronized (getTreeLock()) { | ||
| 748 | if (parent != null && parent.getPeer() == null) { | ||
| 749 | parent.addNotify(); | ||
| 750 | } | ||
| 751 | |||
| 752 | if (peer == null) { | ||
| 753 | peer = getToolkit().createDialog(this); | ||
| 754 | } | ||
| 755 | super.addNotify(); | ||
| 756 | } | ||
| 757 | } | ||
| 758 | |||
| 759 | /** | ||
| 760 | * Indicates whether the dialog is modal. | ||
| 761 | * <p> | ||
| 762 | * This method is obsolete and is kept for backwards compatiblity only. | ||
| 763 | * Use {@link #getModalityType getModalityType()} instead. | ||
| 764 | * | ||
| 765 | * @return <code>true</code> if this dialog window is modal; | ||
| 766 | * <code>false</code> otherwise | ||
| 767 | * | ||
| 768 | * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE | ||
| 769 | * @see java.awt.Dialog.ModalityType#MODELESS | ||
| 770 | * @see java.awt.Dialog#setModal | ||
| 771 | * @see java.awt.Dialog#getModalityType | ||
| 772 | * @see java.awt.Dialog#setModalityType | ||
| 773 | */ | ||
| 774 | public boolean isModal() { | ||
| 775 | return isModal_NoClientCode(); | ||
| 776 | } | ||
| 777 | final boolean isModal_NoClientCode() { | ||
| 778 | return modalityType != ModalityType.MODELESS; | ||
| 779 | } | ||
| 780 | |||
| 781 | /** | ||
| 782 | * Specifies whether this dialog should be modal. | ||
| 783 | * <p> | ||
| 784 | * This method is obsolete and is kept for backwards compatibility only. | ||
| 785 | * Use {@link #setModalityType setModalityType()} instead. | ||
| 786 | * <p> | ||
| 787 | * Note: changing modality of the visible dialog may have no effect | ||
| 788 | * until it is hidden and then shown again. | ||
| 789 | * | ||
| 790 | * @param modal specifies whether dialog blocks input to other windows | ||
| 791 | * when shown; calling to <code>setModal(true)</code> is equivalent to | ||
| 792 | * <code>setModalityType(Dialog.DEFAULT_MODALITY_TYPE)</code>, and | ||
| 793 | * calling to <code>setModal(false)</code> is equvivalent to | ||
| 794 | * <code>setModalityType(Dialog.ModalityType.MODELESS)</code> | ||
| 795 | * | ||
| 796 | * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE | ||
| 797 | * @see java.awt.Dialog.ModalityType#MODELESS | ||
| 798 | * @see java.awt.Dialog#isModal | ||
| 799 | * @see java.awt.Dialog#getModalityType | ||
| 800 | * @see java.awt.Dialog#setModalityType | ||
| 801 | * | ||
| 802 | * @since 1.1 | ||
| 803 | */ | ||
| 804 | public void setModal(boolean modal) { | ||
| 805 | this.modal = modal; | ||
| 806 | setModalityType(modal ? DEFAULT_MODALITY_TYPE : ModalityType.MODELESS); | ||
| 807 | } | ||
| 808 | |||
| 809 | /** | ||
| 810 | * Returns the modality type of this dialog. | ||
| 811 | * | ||
| 812 | * @return modality type of this dialog | ||
| 813 | * | ||
| 814 | * @see java.awt.Dialog#setModalityType | ||
| 815 | * | ||
| 816 | * @since 1.6 | ||
| 817 | */ | ||
| 818 | public ModalityType getModalityType() { | ||
| 819 | return modalityType; | ||
| 820 | } | ||
| 821 | |||
| 822 | /** | ||
| 823 | * Sets the modality type for this dialog. See {@link | ||
| 824 | * java.awt.Dialog.ModalityType ModalityType} for possible modality types. | ||
| 825 | * <p> | ||
| 826 | * If the given modality type is not supported, <code>MODELESS</code> | ||
| 827 | * is used. You may want to call <code>getModalityType()</code> after calling | ||
| 828 | * this method to ensure that the modality type has been set. | ||
| 829 | * <p> | ||
| 830 | * Note: changing modality of the visible dialog may have no effect | ||
| 831 | * until it is hidden and then shown again. | ||
| 832 | * | ||
| 833 | * @param type specifies whether dialog blocks input to other | ||
| 834 | * windows when shown. <code>null</code> value and unsupported modality | ||
| 835 | * types are equivalent to <code>MODELESS</code> | ||
| 836 | * @exception SecurityException if the calling thread does not have permission | ||
| 837 | * to create modal dialogs with the given <code>modalityType</code> | ||
| 838 | * | ||
| 839 | * @see java.awt.Dialog#getModalityType | ||
| 840 | * @see java.awt.Toolkit#isModalityTypeSupported | ||
| 841 | * | ||
| 842 | * @since 1.6 | ||
| 843 | */ | ||
| 844 | public void setModalityType(ModalityType type) { | ||
| 845 | if (type == null) { | ||
| 846 | type = Dialog.ModalityType.MODELESS; | ||
| 847 | } | ||
| 848 | if (!Toolkit.getDefaultToolkit().isModalityTypeSupported(type)) { | ||
| 849 | type = Dialog.ModalityType.MODELESS; | ||
| 850 | } | ||
| 851 | if (modalityType == type) { | ||
| 852 | return; | ||
| 853 | } | ||
| 854 | if (type == ModalityType.TOOLKIT_MODAL) { | ||
| 855 | SecurityManager sm = System.getSecurityManager(); | ||
| 856 | if (sm != null) { | ||
| 857 | sm.checkPermission(SecurityConstants.AWT.TOOLKIT_MODALITY_PERMISSION); | ||
| 858 | } | ||
| 859 | } | ||
| 860 | modalityType = type; | ||
| 861 | modal = (modalityType != ModalityType.MODELESS); | ||
| 862 | } | ||
| 863 | |||
| 864 | /** | ||
| 865 | * Gets the title of the dialog. The title is displayed in the | ||
| 866 | * dialog's border. | ||
| 867 | * @return the title of this dialog window. The title may be | ||
| 868 | * <code>null</code>. | ||
| 869 | * @see java.awt.Dialog#setTitle | ||
| 870 | */ | ||
| 871 | public String getTitle() { | ||
| 872 | return title; | ||
| 873 | } | ||
| 874 | |||
| 875 | /** | ||
| 876 | * Sets the title of the Dialog. | ||
| 877 | * @param title the title displayed in the dialog's border; | ||
| 878 | * a null value results in an empty title | ||
| 879 | * @see #getTitle | ||
| 880 | */ | ||
| 881 | public void setTitle(String title) { | ||
| 882 | String oldTitle = this.title; | ||
| 883 | |||
| 884 | synchronized(this) { | ||
| 885 | this.title = title; | ||
| 886 | DialogPeer peer = (DialogPeer)this.peer; | ||
| 887 | if (peer != null) { | ||
| 888 | peer.setTitle(title); | ||
| 889 | } | ||
| 890 | } | ||
| 891 | firePropertyChange("title", oldTitle, title); | ||
| 892 | } | ||
| 893 | |||
| 894 | /** | ||
| 895 | * @return true if we actually showed, false if we just called toFront() | ||
| 896 | */ | ||
| 897 | private boolean conditionalShow(Component toFocus, AtomicLong time) { | ||
| 898 | boolean retval; | ||
| 899 | |||
| 900 | closeSplashScreen(); | ||
| 901 | |||
| 902 | synchronized (getTreeLock()) { | ||
| 903 | if (peer == null) { | ||
| 904 | addNotify(); | ||
| 905 | } | ||
| 906 | validateUnconditionally(); | ||
| 907 | if (visible) { | ||
| 908 | toFront(); | ||
| 909 | retval = false; | ||
| 910 | } else { | ||
| 911 | visible = retval = true; | ||
| 912 | |||
| 913 | // check if this dialog should be modal blocked BEFORE calling peer.show(), | ||
| 914 | // otherwise, a pair of FOCUS_GAINED and FOCUS_LOST may be mistakenly | ||
| 915 | // generated for the dialog | ||
| 916 | if (!isModal()) { | ||
| 917 | checkShouldBeBlocked(this); | ||
| 918 | } else { | ||
| 919 | modalDialogs.add(this); | ||
| 920 | modalShow(); | ||
| 921 | } | ||
| 922 | |||
| 923 | if (toFocus != null && time != null && isFocusable() && | ||
| 924 | isEnabled() && !isModalBlocked()) { | ||
| 925 | // keep the KeyEvents from being dispatched | ||
| 926 | // until the focus has been transfered | ||
| 927 | time.set(Toolkit.getEventQueue().getMostRecentEventTimeEx()); | ||
| 928 | KeyboardFocusManager.getCurrentKeyboardFocusManager(). | ||
| 929 | enqueueKeyEvents(time.get(), toFocus); | ||
| 930 | } | ||
| 931 | |||
| 932 | // This call is required as the show() method of the Dialog class | ||
| 933 | // does not invoke the super.show(). So wried... :( | ||
| 934 | mixOnShowing(); | ||
| 935 | |||
| 936 | peer.setVisible(true); // now guaranteed never to block | ||
| 937 | if (isModalBlocked()) { | ||
| 938 | modalBlocker.toFront(); | ||
| 939 | } | ||
| 940 | |||
| 941 | setLocationByPlatform(false); | ||
| 942 | for (int i = 0; i < ownedWindowList.size(); i++) { | ||
| 943 | Window child = ownedWindowList.elementAt(i).get(); | ||
| 944 | if ((child != null) && child.showWithParent) { | ||
| 945 | child.show(); | ||
| 946 | child.showWithParent = false; | ||
| 947 | } // endif | ||
| 948 | } // endfor | ||
| 949 | Window.updateChildFocusableWindowState(this); | ||
| 950 | |||
| 951 | createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, | ||
| 952 | this, parent, | ||
| 953 | HierarchyEvent.SHOWING_CHANGED, | ||
| 954 | Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK)); | ||
| 955 | if (componentListener != null || | ||
| 956 | (eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 || | ||
| 957 | Toolkit.enabledOnToolkit(AWTEvent.COMPONENT_EVENT_MASK)) { | ||
| 958 | ComponentEvent e = | ||
| 959 | new ComponentEvent(this, ComponentEvent.COMPONENT_SHOWN); | ||
| 960 | Toolkit.getEventQueue().postEvent(e); | ||
| 961 | } | ||
| 962 | } | ||
| 963 | } | ||
| 964 | |||
| 965 | if (retval && (state & OPENED) == 0) { | ||
| 966 | postWindowEvent(WindowEvent.WINDOW_OPENED); | ||
| 967 | state |= OPENED; | ||
| 968 | } | ||
| 969 | |||
| 970 | return retval; | ||
| 971 | } | ||
| 972 | |||
| 973 | /** | ||
| 974 | * Shows or hides this {@code Dialog} depending on the value of parameter | ||
| 975 | * {@code b}. | ||
| 976 | * @param b if {@code true}, makes the {@code Dialog} visible, | ||
| 977 | * otherwise hides the {@code Dialog}. | ||
| 978 | * If the dialog and/or its owner | ||
| 979 | * are not yet displayable, both are made displayable. The | ||
| 980 | * dialog will be validated prior to being made visible. | ||
| 981 | * If {@code false}, hides the {@code Dialog} and then causes {@code setVisible(true)} | ||
| 982 | * to return if it is currently blocked. | ||
| 983 | * <p> | ||
| 984 | * <b>Notes for modal dialogs</b>. | ||
| 985 | * <ul> | ||
| 986 | * <li>{@code setVisible(true)}: If the dialog is not already | ||
| 987 | * visible, this call will not return until the dialog is | ||
| 988 | * hidden by calling {@code setVisible(false)} or | ||
| 989 | * {@code dispose}. | ||
| 990 | * <li>{@code setVisible(false)}: Hides the dialog and then | ||
| 991 | * returns on {@code setVisible(true)} if it is currently blocked. | ||
| 992 | * <li>It is OK to call this method from the event dispatching | ||
| 993 | * thread because the toolkit ensures that other events are | ||
| 994 | * not blocked while this method is blocked. | ||
| 995 | * </ul> | ||
| 996 | * @see java.awt.Window#setVisible | ||
| 997 | * @see java.awt.Window#dispose | ||
| 998 | * @see java.awt.Component#isDisplayable | ||
| 999 | * @see java.awt.Component#validate | ||
| 1000 | * @see java.awt.Dialog#isModal | ||
| 1001 | */ | ||
| 1002 | public void setVisible(boolean b) { | ||
| 1003 | super.setVisible(b); | ||
| 1004 | } | ||
| 1005 | |||
| 1006 | /** | ||
| 1007 | * Makes the {@code Dialog} visible. If the dialog and/or its owner | ||
| 1008 | * are not yet displayable, both are made displayable. The | ||
| 1009 | * dialog will be validated prior to being made visible. | ||
| 1010 | * If the dialog is already visible, this will bring the dialog | ||
| 1011 | * to the front. | ||
| 1012 | * <p> | ||
| 1013 | * If the dialog is modal and is not already visible, this call | ||
| 1014 | * will not return until the dialog is hidden by calling hide or | ||
| 1015 | * dispose. It is permissible to show modal dialogs from the event | ||
| 1016 | * dispatching thread because the toolkit will ensure that another | ||
| 1017 | * event pump runs while the one which invoked this method is blocked. | ||
| 1018 | * @see Component#hide | ||
| 1019 | * @see Component#isDisplayable | ||
| 1020 | * @see Component#validate | ||
| 1021 | * @see #isModal | ||
| 1022 | * @see Window#setVisible(boolean) | ||
| 1023 | * @deprecated As of JDK version 1.5, replaced by | ||
| 1024 | * {@link #setVisible(boolean) setVisible(boolean)}. | ||
| 1025 | */ | ||
| 1026 | @Deprecated | ||
| 1027 | public void show() { | ||
| 1028 | beforeFirstShow = false; | ||
| 1029 | if (!isModal()) { | ||
| 1030 | conditionalShow(null, null); | ||
| 1031 | } else { | ||
| 1032 | AppContext showAppContext = AppContext.getAppContext(); | ||
| 1033 | |||
| 1034 | AtomicLong time = new AtomicLong(); | ||
| 1035 | Component predictedFocusOwner = null; | ||
| 1036 | try { | ||
| 1037 | predictedFocusOwner = getMostRecentFocusOwner(); | ||
| 1038 | if (conditionalShow(predictedFocusOwner, time)) { | ||
| 1039 | modalFilter = ModalEventFilter.createFilterForDialog(this); | ||
| 1040 | Conditional cond = new Conditional() { | ||
| 1041 | @Override | ||
| 1042 | public boolean evaluate() { | ||
| 1043 | return windowClosingException == null; | ||
| 1044 | } | ||
| 1045 | }; | ||
| 1046 | |||
| 1047 | // if this dialog is toolkit-modal, the filter should be added | ||
| 1048 | // to all EDTs (for all AppContexts) | ||
| 1049 | if (modalityType == ModalityType.TOOLKIT_MODAL) { | ||
| 1050 | Iterator it = AppContext.getAppContexts().iterator(); | ||
| 1051 | while (it.hasNext()) { | ||
| 1052 | AppContext appContext = (AppContext)it.next(); | ||
| 1053 | if (appContext == showAppContext) { | ||
| 1054 | continue; | ||
| 1055 | } | ||
| 1056 | EventQueue eventQueue = (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY); | ||
| 1057 | // it may occur that EDT for appContext hasn't been started yet, so | ||
| 1058 | // we post an empty invocation event to trigger EDT initialization | ||
| 1059 | Runnable createEDT = new Runnable() { | ||
| 1060 | public void run() {}; | ||
| 1061 | }; | ||
| 1062 | eventQueue.postEvent(new InvocationEvent(this, createEDT)); | ||
| 1063 | EventDispatchThread edt = eventQueue.getDispatchThread(); | ||
| 1064 | edt.addEventFilter(modalFilter); | ||
| 1065 | } | ||
| 1066 | } | ||
| 1067 | |||
| 1068 | modalityPushed(); | ||
| 1069 | try { | ||
| 1070 | EventQueue eventQueue = Toolkit.getDefaultToolkit().getSystemEventQueue(); | ||
| 1071 | secondaryLoop = eventQueue.createSecondaryLoop(cond, modalFilter, 0); | ||
| 1072 | if (!secondaryLoop.enter()) { | ||
| 1073 | secondaryLoop = null; | ||
| 1074 | } | ||
| 1075 | } finally { | ||
| 1076 | modalityPopped(); | ||
| 1077 | } | ||
| 1078 | |||
| 1079 | // if this dialog is toolkit-modal, its filter must be removed | ||
| 1080 | // from all EDTs (for all AppContexts) | ||
| 1081 | if (modalityType == ModalityType.TOOLKIT_MODAL) { | ||
| 1082 | Iterator it = AppContext.getAppContexts().iterator(); | ||
| 1083 | while (it.hasNext()) { | ||
| 1084 | AppContext appContext = (AppContext)it.next(); | ||
| 1085 | if (appContext == showAppContext) { | ||
| 1086 | continue; | ||
| 1087 | } | ||
| 1088 | EventQueue eventQueue = (EventQueue)appContext.get(AppContext.EVENT_QUEUE_KEY); | ||
| 1089 | EventDispatchThread edt = eventQueue.getDispatchThread(); | ||
| 1090 | edt.removeEventFilter(modalFilter); | ||
| 1091 | } | ||
| 1092 | } | ||
| 1093 | |||
| 1094 | if (windowClosingException != null) { | ||
| 1095 | windowClosingException.fillInStackTrace(); | ||
| 1096 | throw windowClosingException; | ||
| 1097 | } | ||
| 1098 | } | ||
| 1099 | } finally { | ||
| 1100 | if (predictedFocusOwner != null) { | ||
| 1101 | // Restore normal key event dispatching | ||
| 1102 | KeyboardFocusManager.getCurrentKeyboardFocusManager(). | ||
| 1103 | dequeueKeyEvents(time.get(), predictedFocusOwner); | ||
| 1104 | } | ||
| 1105 | } | ||
| 1106 | } | ||
| 1107 | } | ||
| 1108 | |||
| 1109 | final void modalityPushed() { | ||
| 1110 | Toolkit tk = Toolkit.getDefaultToolkit(); | ||
| 1111 | if (tk instanceof SunToolkit) { | ||
| 1112 | SunToolkit stk = (SunToolkit)tk; | ||
| 1113 | stk.notifyModalityPushed(this); | ||
| 1114 | } | ||
| 1115 | } | ||
| 1116 | |||
| 1117 | final void modalityPopped() { | ||
| 1118 | Toolkit tk = Toolkit.getDefaultToolkit(); | ||
| 1119 | if (tk instanceof SunToolkit) { | ||
| 1120 | SunToolkit stk = (SunToolkit)tk; | ||
| 1121 | stk.notifyModalityPopped(this); | ||
| 1122 | } | ||
| 1123 | } | ||
| 1124 | |||
| 1125 | void interruptBlocking() { | ||
| 1126 | if (isModal()) { | ||
| 1127 | disposeImpl(); | ||
| 1128 | } else if (windowClosingException != null) { | ||
| 1129 | windowClosingException.fillInStackTrace(); | ||
| 1130 | windowClosingException.printStackTrace(); | ||
| 1131 | windowClosingException = null; | ||
| 1132 | } | ||
| 1133 | } | ||
| 1134 | |||
| 1135 | private void hideAndDisposePreHandler() { | ||
| 1136 | isInHide = true; | ||
| 1137 | synchronized (getTreeLock()) { | ||
| 1138 | if (secondaryLoop != null) { | ||
| 1139 | modalHide(); | ||
| 1140 | // dialog can be shown and then disposed before its | ||
| 1141 | // modal filter is created | ||
| 1142 | if (modalFilter != null) { | ||
| 1143 | modalFilter.disable(); | ||
| 1144 | } | ||
| 1145 | modalDialogs.remove(this); | ||
| 1146 | } | ||
| 1147 | } | ||
| 1148 | } | ||
| 1149 | private void hideAndDisposeHandler() { | ||
| 1150 | if (secondaryLoop != null) { | ||
| 1151 | secondaryLoop.exit(); | ||
| 1152 | secondaryLoop = null; | ||
| 1153 | } | ||
| 1154 | isInHide = false; | ||
| 1155 | } | ||
| 1156 | |||
| 1157 | /** | ||
| 1158 | * Hides the Dialog and then causes {@code show} to return if it is currently | ||
| 1159 | * blocked. | ||
| 1160 | * @see Window#show | ||
| 1161 | * @see Window#dispose | ||
| 1162 | * @see Window#setVisible(boolean) | ||
| 1163 | * @deprecated As of JDK version 1.5, replaced by | ||
| 1164 | * {@link #setVisible(boolean) setVisible(boolean)}. | ||
| 1165 | */ | ||
| 1166 | @Deprecated | ||
| 1167 | public void hide() { | ||
| 1168 | hideAndDisposePreHandler(); | ||
| 1169 | super.hide(); | ||
| 1170 | // fix for 5048370: if hide() is called from super.doDispose(), then | ||
| 1171 | // hideAndDisposeHandler() should not be called here as it will be called | ||
| 1172 | // at the end of doDispose() | ||
| 1173 | if (!isInDispose) { | ||
| 1174 | hideAndDisposeHandler(); | ||
| 1175 | } | ||
| 1176 | } | ||
| 1177 | |||
| 1178 | /** | ||
| 1179 | * Disposes the Dialog and then causes show() to return if it is currently | ||
| 1180 | * blocked. | ||
| 1181 | */ | ||
| 1182 | void doDispose() { | ||
| 1183 | // fix for 5048370: set isInDispose flag to true to prevent calling | ||
| 1184 | // to hideAndDisposeHandler() from hide() | ||
| 1185 | isInDispose = true; | ||
| 1186 | super.doDispose(); | ||
| 1187 | hideAndDisposeHandler(); | ||
| 1188 | isInDispose = false; | ||
| 1189 | } | ||
| 1190 | |||
| 1191 | /** | ||
| 1192 | * {@inheritDoc} | ||
| 1193 | * <p> | ||
| 1194 | * If this dialog is modal and blocks some windows, then all of them are | ||
| 1195 | * also sent to the back to keep them below the blocking dialog. | ||
| 1196 | * | ||
| 1197 | * @see java.awt.Window#toBack | ||
| 1198 | */ | ||
| 1199 | public void toBack() { | ||
| 1200 | super.toBack(); | ||
| 1201 | if (visible) { | ||
| 1202 | synchronized (getTreeLock()) { | ||
| 1203 | for (Window w : blockedWindows) { | ||
| 1204 | w.toBack_NoClientCode(); | ||
| 1205 | } | ||
| 1206 | } | ||
| 1207 | } | ||
| 1208 | } | ||
| 1209 | |||
| 1210 | /** | ||
| 1211 | * Indicates whether this dialog is resizable by the user. | ||
| 1212 | * By default, all dialogs are initially resizable. | ||
| 1213 | * @return <code>true</code> if the user can resize the dialog; | ||
| 1214 | * <code>false</code> otherwise. | ||
| 1215 | * @see java.awt.Dialog#setResizable | ||
| 1216 | */ | ||
| 1217 | public boolean isResizable() { | ||
| 1218 | return resizable; | ||
| 1219 | } | ||
| 1220 | |||
| 1221 | /** | ||
| 1222 | * Sets whether this dialog is resizable by the user. | ||
| 1223 | * @param resizable <code>true</code> if the user can | ||
| 1224 | * resize this dialog; <code>false</code> otherwise. | ||
| 1225 | * @see java.awt.Dialog#isResizable | ||
| 1226 | */ | ||
| 1227 | public void setResizable(boolean resizable) { | ||
| 1228 | boolean testvalid = false; | ||
| 1229 | |||
| 1230 | synchronized (this) { | ||
| 1231 | this.resizable = resizable; | ||
| 1232 | DialogPeer peer = (DialogPeer)this.peer; | ||
| 1233 | if (peer != null) { | ||
| 1234 | peer.setResizable(resizable); | ||
| 1235 | testvalid = true; | ||
| 1236 | } | ||
| 1237 | } | ||
| 1238 | |||
| 1239 | // On some platforms, changing the resizable state affects | ||
| 1240 | // the insets of the Dialog. If we could, we'd call invalidate() | ||
| 1241 | // from the peer, but we need to guarantee that we're not holding | ||
| 1242 | // the Dialog lock when we call invalidate(). | ||
| 1243 | if (testvalid) { | ||
| 1244 | invalidateIfValid(); | ||
| 1245 | } | ||
| 1246 | } | ||
| 1247 | |||
| 1248 | |||
| 1249 | /** | ||
| 1250 | * Disables or enables decorations for this dialog. | ||
| 1251 | * <p> | ||
| 1252 | * This method can only be called while the dialog is not displayable. To | ||
| 1253 | * make this dialog decorated, it must be opaque and have the default shape, | ||
| 1254 | * otherwise the {@code IllegalComponentStateException} will be thrown. | ||
| 1255 | * Refer to {@link Window#setShape}, {@link Window#setOpacity} and {@link | ||
| 1256 | * Window#setBackground} for details | ||
| 1257 | * | ||
| 1258 | * @param undecorated {@code true} if no dialog decorations are to be | ||
| 1259 | * enabled; {@code false} if dialog decorations are to be enabled | ||
| 1260 | * | ||
| 1261 | * @throws IllegalComponentStateException if the dialog is displayable | ||
| 1262 | * @throws IllegalComponentStateException if {@code undecorated} is | ||
| 1263 | * {@code false}, and this dialog does not have the default shape | ||
| 1264 | * @throws IllegalComponentStateException if {@code undecorated} is | ||
| 1265 | * {@code false}, and this dialog opacity is less than {@code 1.0f} | ||
| 1266 | * @throws IllegalComponentStateException if {@code undecorated} is | ||
| 1267 | * {@code false}, and the alpha value of this dialog background | ||
| 1268 | * color is less than {@code 1.0f} | ||
| 1269 | * | ||
| 1270 | * @see #isUndecorated | ||
| 1271 | * @see Component#isDisplayable | ||
| 1272 | * @see Window#getShape | ||
| 1273 | * @see Window#getOpacity | ||
| 1274 | * @see Window#getBackground | ||
| 1275 | * | ||
| 1276 | * @since 1.4 | ||
| 1277 | */ | ||
| 1278 | public void setUndecorated(boolean undecorated) { | ||
| 1279 | /* Make sure we don't run in the middle of peer creation.*/ | ||
| 1280 | synchronized (getTreeLock()) { | ||
| 1281 | if (isDisplayable()) { | ||
| 1282 | throw new IllegalComponentStateException("The dialog is displayable."); | ||
| 1283 | } | ||
| 1284 | if (!undecorated) { | ||
| 1285 | if (getOpacity() < 1.0f) { | ||
| 1286 | throw new IllegalComponentStateException("The dialog is not opaque"); | ||
| 1287 | } | ||
| 1288 | if (getShape() != null) { | ||
| 1289 | throw new IllegalComponentStateException("The dialog does not have a default shape"); | ||
| 1290 | } | ||
| 1291 | Color bg = getBackground(); | ||
| 1292 | if ((bg != null) && (bg.getAlpha() < 255)) { | ||
| 1293 | throw new IllegalComponentStateException("The dialog background color is not opaque"); | ||
| 1294 | } | ||
| 1295 | } | ||
| 1296 | this.undecorated = undecorated; | ||
| 1297 | } | ||
| 1298 | } | ||
| 1299 | |||
| 1300 | /** | ||
| 1301 | * Indicates whether this dialog is undecorated. | ||
| 1302 | * By default, all dialogs are initially decorated. | ||
| 1303 | * @return <code>true</code> if dialog is undecorated; | ||
| 1304 | * <code>false</code> otherwise. | ||
| 1305 | * @see java.awt.Dialog#setUndecorated | ||
| 1306 | * @since 1.4 | ||
| 1307 | */ | ||
| 1308 | public boolean isUndecorated() { | ||
| 1309 | return undecorated; | ||
| 1310 | } | ||
| 1311 | |||
| 1312 | /** | ||
| 1313 | * {@inheritDoc} | ||
| 1314 | */ | ||
| 1315 | @Override | ||
| 1316 | public void setOpacity(float opacity) { | ||
| 1317 | synchronized (getTreeLock()) { | ||
| 1318 | if ((opacity < 1.0f) && !isUndecorated()) { | ||
| 1319 | throw new IllegalComponentStateException("The dialog is decorated"); | ||
| 1320 | } | ||
| 1321 | super.setOpacity(opacity); | ||
| 1322 | } | ||
| 1323 | } | ||
| 1324 | |||
| 1325 | /** | ||
| 1326 | * {@inheritDoc} | ||
| 1327 | */ | ||
| 1328 | @Override | ||
| 1329 | public void setShape(Shape shape) { | ||
| 1330 | synchronized (getTreeLock()) { | ||
| 1331 | if ((shape != null) && !isUndecorated()) { | ||
| 1332 | throw new IllegalComponentStateException("The dialog is decorated"); | ||
| 1333 | } | ||
| 1334 | super.setShape(shape); | ||
| 1335 | } | ||
| 1336 | } | ||
| 1337 | |||
| 1338 | /** | ||
| 1339 | * {@inheritDoc} | ||
| 1340 | */ | ||
| 1341 | @Override | ||
| 1342 | public void setBackground(Color bgColor) { | ||
| 1343 | synchronized (getTreeLock()) { | ||
| 1344 | if ((bgColor != null) && (bgColor.getAlpha() < 255) && !isUndecorated()) { | ||
| 1345 | throw new IllegalComponentStateException("The dialog is decorated"); | ||
| 1346 | } | ||
| 1347 | super.setBackground(bgColor); | ||
| 1348 | } | ||
| 1349 | } | ||
| 1350 | |||
| 1351 | /** | ||
| 1352 | * Returns a string representing the state of this dialog. This | ||
| 1353 | * method is intended to be used only for debugging purposes, and the | ||
| 1354 | * content and format of the returned string may vary between | ||
| 1355 | * implementations. The returned string may be empty but may not be | ||
| 1356 | * <code>null</code>. | ||
| 1357 | * | ||
| 1358 | * @return the parameter string of this dialog window. | ||
| 1359 | */ | ||
| 1360 | protected String paramString() { | ||
| 1361 | String str = super.paramString() + "," + modalityType; | ||
| 1362 | if (title != null) { | ||
| 1363 | str += ",title=" + title; | ||
| 1364 | } | ||
| 1365 | return str; | ||
| 1366 | } | ||
| 1367 | |||
| 1368 | /** | ||
| 1369 | * Initialize JNI field and method IDs | ||
| 1370 | */ | ||
| 1371 | private static native void initIDs(); | ||
| 1372 | |||
| 1373 | /* | ||
| 1374 | * --- Modality support --- | ||
| 1375 | * | ||
| 1376 | */ | ||
| 1377 | |||
| 1378 | /* | ||
| 1379 | * This method is called only for modal dialogs. | ||
| 1380 | * | ||
| 1381 | * Goes through the list of all visible top-level windows and | ||
| 1382 | * divide them into three distinct groups: blockers of this dialog, | ||
| 1383 | * blocked by this dialog and all others. Then blocks this dialog | ||
| 1384 | * by first met dialog from the first group (if any) and blocks all | ||
| 1385 | * the windows from the second group. | ||
| 1386 | */ | ||
| 1387 | void modalShow() { | ||
| 1388 | // find all the dialogs that block this one | ||
| 1389 | IdentityArrayList<Dialog> blockers = new IdentityArrayList<Dialog>(); | ||
| 1390 | for (Dialog d : modalDialogs) { | ||
| 1391 | if (d.shouldBlock(this)) { | ||
| 1392 | Window w = d; | ||
| 1393 | while ((w != null) && (w != this)) { | ||
| 1394 | w = (Window)(w.getOwner_NoClientCode()); | ||
| 1395 | } | ||
| 1396 | if ((w == this) || !shouldBlock(d) || (modalityType.compareTo(d.getModalityType()) < 0)) { | ||
| 1397 | blockers.add(d); | ||
| 1398 | } | ||
| 1399 | } | ||
| 1400 | } | ||
| 1401 | |||
| 1402 | // add all blockers' blockers to blockers :) | ||
| 1403 | for (int i = 0; i < blockers.size(); i++) { | ||
| 1404 | Dialog blocker = blockers.get(i); | ||
| 1405 | if (blocker.isModalBlocked()) { | ||
| 1406 | Dialog blockerBlocker = blocker.getModalBlocker(); | ||
| 1407 | if (!blockers.contains(blockerBlocker)) { | ||
| 1408 | blockers.add(i + 1, blockerBlocker); | ||
| 1409 | } | ||
| 1410 | } | ||
| 1411 | } | ||
| 1412 | |||
| 1413 | if (blockers.size() > 0) { | ||
| 1414 | blockers.get(0).blockWindow(this); | ||
| 1415 | } | ||
| 1416 | |||
| 1417 | // find all windows from blockers' hierarchies | ||
| 1418 | IdentityArrayList<Window> blockersHierarchies = new IdentityArrayList<Window>(blockers); | ||
| 1419 | int k = 0; | ||
| 1420 | while (k < blockersHierarchies.size()) { | ||
| 1421 | Window w = blockersHierarchies.get(k); | ||
| 1422 | Window[] ownedWindows = w.getOwnedWindows_NoClientCode(); | ||
| 1423 | for (Window win : ownedWindows) { | ||
| 1424 | blockersHierarchies.add(win); | ||
| 1425 | } | ||
| 1426 | k++; | ||
| 1427 | } | ||
| 1428 | |||
| 1429 | java.util.List<Window> toBlock = new IdentityLinkedList<Window>(); | ||
| 1430 | // block all windows from scope of blocking except from blockers' hierarchies | ||
| 1431 | IdentityArrayList<Window> unblockedWindows = Window.getAllUnblockedWindows(); | ||
| 1432 | for (Window w : unblockedWindows) { | ||
| 1433 | if (shouldBlock(w) && !blockersHierarchies.contains(w)) { | ||
| 1434 | if ((w instanceof Dialog) && ((Dialog)w).isModal_NoClientCode()) { | ||
| 1435 | Dialog wd = (Dialog)w; | ||
| 1436 | if (wd.shouldBlock(this) && (modalDialogs.indexOf(wd) > modalDialogs.indexOf(this))) { | ||
| 1437 | continue; | ||
| 1438 | } | ||
| 1439 | } | ||
| 1440 | toBlock.add(w); | ||
| 1441 | } | ||
| 1442 | } | ||
| 1443 | blockWindows(toBlock); | ||
| 1444 | |||
| 1445 | if (!isModalBlocked()) { | ||
| 1446 | updateChildrenBlocking(); | ||
| 1447 | } | ||
| 1448 | } | ||
| 1449 | |||
| 1450 | /* | ||
| 1451 | * This method is called only for modal dialogs. | ||
| 1452 | * | ||
| 1453 | * Unblocks all the windows blocked by this modal dialog. After | ||
| 1454 | * each of them has been unblocked, it is checked to be blocked by | ||
| 1455 | * any other modal dialogs. | ||
| 1456 | */ | ||
| 1457 | void modalHide() { | ||
| 1458 | // we should unblock all the windows first... | ||
| 1459 | IdentityArrayList<Window> save = new IdentityArrayList<Window>(); | ||
| 1460 | int blockedWindowsCount = blockedWindows.size(); | ||
| 1461 | for (int i = 0; i < blockedWindowsCount; i++) { | ||
| 1462 | Window w = blockedWindows.get(0); | ||
| 1463 | save.add(w); | ||
| 1464 | unblockWindow(w); // also removes w from blockedWindows | ||
| 1465 | } | ||
| 1466 | // ... and only after that check if they should be blocked | ||
| 1467 | // by another dialogs | ||
| 1468 | for (int i = 0; i < blockedWindowsCount; i++) { | ||
| 1469 | Window w = save.get(i); | ||
| 1470 | if ((w instanceof Dialog) && ((Dialog)w).isModal_NoClientCode()) { | ||
| 1471 | Dialog d = (Dialog)w; | ||
| 1472 | d.modalShow(); | ||
| 1473 | } else { | ||
| 1474 | checkShouldBeBlocked(w); | ||
| 1475 | } | ||
| 1476 | } | ||
| 1477 | } | ||
| 1478 | |||
| 1479 | /* | ||
| 1480 | * Returns whether the given top-level window should be blocked by | ||
| 1481 | * this dialog. Note, that the given window can be also a modal dialog | ||
| 1482 | * and it should block this dialog, but this method do not take such | ||
| 1483 | * situations into consideration (such checks are performed in the | ||
| 1484 | * modalShow() and modalHide() methods). | ||
| 1485 | * | ||
| 1486 | * This method should be called on the getTreeLock() lock. | ||
| 1487 | */ | ||
| 1488 | boolean shouldBlock(Window w) { | ||
| 1489 | if (!isVisible_NoClientCode() || | ||
| 1490 | (!w.isVisible_NoClientCode() && !w.isInShow) || | ||
| 1491 | isInHide || | ||
| 1492 | (w == this) || | ||
| 1493 | !isModal_NoClientCode()) | ||
| 1494 | { | ||
| 1495 | return false; | ||
| 1496 | } | ||
| 1497 | if ((w instanceof Dialog) && ((Dialog)w).isInHide) { | ||
| 1498 | return false; | ||
| 1499 | } | ||
| 1500 | // check if w is from children hierarchy | ||
| 1501 | // fix for 6271546: we should also take into consideration child hierarchies | ||
| 1502 | // of this dialog's blockers | ||
| 1503 | Window blockerToCheck = this; | ||
| 1504 | while (blockerToCheck != null) { | ||
| 1505 | Component c = w; | ||
| 1506 | while ((c != null) && (c != blockerToCheck)) { | ||
| 1507 | c = c.getParent_NoClientCode(); | ||
| 1508 | } | ||
| 1509 | if (c == blockerToCheck) { | ||
| 1510 | return false; | ||
| 1511 | } | ||
| 1512 | blockerToCheck = blockerToCheck.getModalBlocker(); | ||
| 1513 | } | ||
| 1514 | switch (modalityType) { | ||
| 1515 | case MODELESS: | ||
| 1516 | return false; | ||
| 1517 | case DOCUMENT_MODAL: | ||
| 1518 | if (w.isModalExcluded(ModalExclusionType.APPLICATION_EXCLUDE)) { | ||
| 1519 | // application- and toolkit-excluded windows are not blocked by | ||
| 1520 | // document-modal dialogs from outside their children hierarchy | ||
| 1521 | Component c = this; | ||
| 1522 | while ((c != null) && (c != w)) { | ||
| 1523 | c = c.getParent_NoClientCode(); | ||
| 1524 | } | ||
| 1525 | return c == w; | ||
| 1526 | } else { | ||
| 1527 | return getDocumentRoot() == w.getDocumentRoot(); | ||
| 1528 | } | ||
| 1529 | case APPLICATION_MODAL: | ||
| 1530 | return !w.isModalExcluded(ModalExclusionType.APPLICATION_EXCLUDE) && | ||
| 1531 | (appContext == w.appContext); | ||
| 1532 | case TOOLKIT_MODAL: | ||
| 1533 | return !w.isModalExcluded(ModalExclusionType.TOOLKIT_EXCLUDE); | ||
| 1534 | } | ||
| 1535 | |||
| 1536 | return false; | ||
| 1537 | } | ||
| 1538 | |||
| 1539 | /* | ||
| 1540 | * Adds the given top-level window to the list of blocked | ||
| 1541 | * windows for this dialog and marks it as modal blocked. | ||
| 1542 | * If the window is already blocked by some modal dialog, | ||
| 1543 | * does nothing. | ||
| 1544 | */ | ||
| 1545 | void blockWindow(Window w) { | ||
| 1546 | if (!w.isModalBlocked()) { | ||
| 1547 | w.setModalBlocked(this, true, true); | ||
| 1548 | blockedWindows.add(w); | ||
| 1549 | } | ||
| 1550 | } | ||
| 1551 | |||
| 1552 | void blockWindows(java.util.List<Window> toBlock) { | ||
| 1553 | DialogPeer dpeer = (DialogPeer)peer; | ||
| 1554 | if (dpeer == null) { | ||
| 1555 | return; | ||
| 1556 | } | ||
| 1557 | Iterator<Window> it = toBlock.iterator(); | ||
| 1558 | while (it.hasNext()) { | ||
| 1559 | Window w = it.next(); | ||
| 1560 | if (!w.isModalBlocked()) { | ||
| 1561 | w.setModalBlocked(this, true, false); | ||
| 1562 | } else { | ||
| 1563 | it.remove(); | ||
| 1564 | } | ||
| 1565 | } | ||
| 1566 | dpeer.blockWindows(toBlock); | ||
| 1567 | blockedWindows.addAll(toBlock); | ||
| 1568 | } | ||
| 1569 | |||
| 1570 | /* | ||
| 1571 | * Removes the given top-level window from the list of blocked | ||
| 1572 | * windows for this dialog and marks it as unblocked. If the | ||
| 1573 | * window is not modal blocked, does nothing. | ||
| 1574 | */ | ||
| 1575 | void unblockWindow(Window w) { | ||
| 1576 | if (w.isModalBlocked() && blockedWindows.contains(w)) { | ||
| 1577 | blockedWindows.remove(w); | ||
| 1578 | w.setModalBlocked(this, false, true); | ||
| 1579 | } | ||
| 1580 | } | ||
| 1581 | |||
| 1582 | /* | ||
| 1583 | * Checks if any other modal dialog D blocks the given window. | ||
| 1584 | * If such D exists, mark the window as blocked by D. | ||
| 1585 | */ | ||
| 1586 | static void checkShouldBeBlocked(Window w) { | ||
| 1587 | synchronized (w.getTreeLock()) { | ||
| 1588 | for (int i = 0; i < modalDialogs.size(); i++) { | ||
| 1589 | Dialog modalDialog = modalDialogs.get(i); | ||
| 1590 | if (modalDialog.shouldBlock(w)) { | ||
| 1591 | modalDialog.blockWindow(w); | ||
| 1592 | break; | ||
| 1593 | } | ||
| 1594 | } | ||
| 1595 | } | ||
| 1596 | } | ||
| 1597 | |||
| 1598 | private void readObject(ObjectInputStream s) | ||
| 1599 | throws ClassNotFoundException, IOException, HeadlessException | ||
| 1600 | { | ||
| 1601 | GraphicsEnvironment.checkHeadless(); | ||
| 1602 | s.defaultReadObject(); | ||
| 1603 | |||
| 1604 | // in 1.5 or earlier modalityType was absent, so use "modal" instead | ||
| 1605 | if (modalityType == null) { | ||
| 1606 | setModal(modal); | ||
| 1607 | } | ||
| 1608 | |||
| 1609 | blockedWindows = new IdentityArrayList(); | ||
| 1610 | } | ||
| 1611 | |||
| 1612 | /* | ||
| 1613 | * --- Accessibility Support --- | ||
| 1614 | * | ||
| 1615 | */ | ||
| 1616 | |||
| 1617 | /** | ||
| 1618 | * Gets the AccessibleContext associated with this Dialog. | ||
| 1619 | * For dialogs, the AccessibleContext takes the form of an | ||
| 1620 | * AccessibleAWTDialog. | ||
| 1621 | * A new AccessibleAWTDialog instance is created if necessary. | ||
| 1622 | * | ||
| 1623 | * @return an AccessibleAWTDialog that serves as the | ||
| 1624 | * AccessibleContext of this Dialog | ||
| 1625 | * @since 1.3 | ||
| 1626 | */ | ||
| 1627 | public AccessibleContext getAccessibleContext() { | ||
| 1628 | if (accessibleContext == null) { | ||
| 1629 | accessibleContext = new AccessibleAWTDialog(); | ||
| 1630 | } | ||
| 1631 | return accessibleContext; | ||
| 1632 | } | ||
| 1633 | |||
| 1634 | /** | ||
| 1635 | * This class implements accessibility support for the | ||
| 1636 | * <code>Dialog</code> class. It provides an implementation of the | ||
| 1637 | * Java Accessibility API appropriate to dialog user-interface elements. | ||
| 1638 | * @since 1.3 | ||
| 1639 | */ | ||
| 1640 | protected class AccessibleAWTDialog extends AccessibleAWTWindow | ||
| 1641 | { | ||
| 1642 | /* | ||
| 1643 | * JDK 1.3 serialVersionUID | ||
| 1644 | */ | ||
| 1645 | private static final long serialVersionUID = 4837230331833941201L; | ||
| 1646 | |||
| 1647 | /** | ||
| 1648 | * Get the role of this object. | ||
| 1649 | * | ||
| 1650 | * @return an instance of AccessibleRole describing the role of the | ||
| 1651 | * object | ||
| 1652 | * @see AccessibleRole | ||
| 1653 | */ | ||
| 1654 | public AccessibleRole getAccessibleRole() { | ||
| 1655 | return AccessibleRole.DIALOG; | ||
| 1656 | } | ||
| 1657 | |||
| 1658 | /** | ||
| 1659 | * Get the state of this object. | ||
| 1660 | * | ||
| 1661 | * @return an instance of AccessibleStateSet containing the current | ||
| 1662 | * state set of the object | ||
| 1663 | * @see AccessibleState | ||
| 1664 | */ | ||
| 1665 | public AccessibleStateSet getAccessibleStateSet() { | ||
| 1666 | AccessibleStateSet states = super.getAccessibleStateSet(); | ||
| 1667 | if (getFocusOwner() != null) { | ||
| 1668 | states.add(AccessibleState.ACTIVE); | ||
| 1669 | } | ||
| 1670 | if (isModal()) { | ||
| 1671 | states.add(AccessibleState.MODAL); | ||
| 1672 | } | ||
| 1673 | if (isResizable()) { | ||
| 1674 | states.add(AccessibleState.RESIZABLE); | ||
| 1675 | } | ||
| 1676 | return states; | ||
| 1677 | } | ||
| 1678 | |||
| 1679 | } // inner class AccessibleAWTDialog | ||
| 1680 | } | ||