Home » openjdk-7 » javax » swing » [javadoc | source]

    1   /*
    2    * Copyright (c) 1997, 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 javax.swing;
   26   
   27   import java.awt;
   28   import java.awt.event;
   29   import javax.accessibility;
   30   
   31   /**
   32    * The main class for creating a dialog window. You can use this class
   33    * to create a custom dialog, or invoke the many class methods
   34    * in {@link JOptionPane} to create a variety of standard dialogs.
   35    * For information about creating dialogs, see
   36    * <em>The Java Tutorial</em> section
   37    * <a
   38    href="http://java.sun.com/docs/books/tutorial/uiswing/components/dialog.html">How
   39    * to Make Dialogs</a>.
   40    *
   41    * <p>
   42    *
   43    * The {@code JDialog} component contains a {@code JRootPane}
   44    * as its only child.
   45    * The {@code contentPane} should be the parent of any children of the
   46    * {@code JDialog}.
   47    * As a convenience {@code add} and its variants, {@code remove} and
   48    * {@code setLayout} have been overridden to forward to the
   49    * {@code contentPane} as necessary. This means you can write:
   50    * <pre>
   51    *       dialog.add(child);
   52    * </pre>
   53    * And the child will be added to the contentPane.
   54    * The {@code contentPane} is always non-{@code null}.
   55    * Attempting to set it to {@code null} generates an exception.
   56    * The default {@code contentPane} has a {@code BorderLayout}
   57    * manager set on it.
   58    * Refer to {@link javax.swing.RootPaneContainer}
   59    * for details on adding, removing and setting the {@code LayoutManager}
   60    * of a {@code JDialog}.
   61    * <p>
   62    * Please see the {@code JRootPane} documentation for a complete
   63    * description of the {@code contentPane}, {@code glassPane},
   64    * and {@code layeredPane} components.
   65    * <p>
   66    * In a multi-screen environment, you can create a {@code JDialog}
   67    * on a different screen device than its owner.  See {@link java.awt.Frame} for
   68    * more information.
   69    * <p>
   70    * <strong>Warning:</strong> Swing is not thread safe. For more
   71    * information see <a
   72    * href="package-summary.html#threading">Swing's Threading
   73    * Policy</a>.
   74    * <p>
   75    * <strong>Warning:</strong>
   76    * Serialized objects of this class will not be compatible with
   77    * future Swing releases. The current serialization support is
   78    * appropriate for short term storage or RMI between applications running
   79    * the same version of Swing.  As of 1.4, support for long term storage
   80    * of all JavaBeans<sup><font size="-2">TM</font></sup>
   81    * has been added to the {@code java.beans} package.
   82    * Please see {@link java.beans.XMLEncoder}.
   83    *
   84    * @see JOptionPane
   85    * @see JRootPane
   86    * @see javax.swing.RootPaneContainer
   87    *
   88    * @beaninfo
   89    *      attribute: isContainer true
   90    *      attribute: containerDelegate getContentPane
   91    *    description: A toplevel window for creating dialog boxes.
   92    *
   93    * @author David Kloba
   94    * @author James Gosling
   95    * @author Scott Violet
   96    */
   97   public class JDialog extends Dialog implements WindowConstants,
   98                                                  Accessible,
   99                                                  RootPaneContainer,
  100                                  TransferHandler.HasGetTransferHandler
  101   {
  102       /**
  103        * Key into the AppContext, used to check if should provide decorations
  104        * by default.
  105        */
  106       private static final Object defaultLookAndFeelDecoratedKey =
  107               new StringBuffer("JDialog.defaultLookAndFeelDecorated");
  108   
  109       private int defaultCloseOperation = HIDE_ON_CLOSE;
  110   
  111       /**
  112        * @see #getRootPane
  113        * @see #setRootPane
  114        */
  115       protected JRootPane rootPane;
  116   
  117       /**
  118        * If true then calls to {@code add} and {@code setLayout}
  119        * will be forwarded to the {@code contentPane}. This is initially
  120        * false, but is set to true when the {@code JDialog} is constructed.
  121        *
  122        * @see #isRootPaneCheckingEnabled
  123        * @see #setRootPaneCheckingEnabled
  124        * @see javax.swing.RootPaneContainer
  125        */
  126       protected boolean rootPaneCheckingEnabled = false;
  127   
  128       /**
  129        * The {@code TransferHandler} for this dialog.
  130        */
  131       private TransferHandler transferHandler;
  132   
  133       /**
  134        * Creates a modeless dialog without a title and without a specified
  135        * {@code Frame} owner.  A shared, hidden frame will be
  136        * set as the owner of the dialog.
  137        * <p>
  138        * This constructor sets the component's locale property to the value
  139        * returned by {@code JComponent.getDefaultLocale}.
  140        * <p>
  141        * NOTE: This constructor does not allow you to create an unowned
  142        * {@code JDialog}. To create an unowned {@code JDialog}
  143        * you must use either the {@code JDialog(Window)} or
  144        * {@code JDialog(Dialog)} constructor with an argument of
  145        * {@code null}.
  146        *
  147        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  148        *     returns {@code true}.
  149        * @see java.awt.GraphicsEnvironment#isHeadless
  150        * @see JComponent#getDefaultLocale
  151        */
  152       public JDialog() {
  153           this((Frame)null, false);
  154       }
  155   
  156       /**
  157        * Creates a modeless dialog with the specified {@code Frame}
  158        * as its owner and an empty title. If {@code owner}
  159        * is {@code null}, a shared, hidden frame will be set as the
  160        * owner of the dialog.
  161        * <p>
  162        * This constructor sets the component's locale property to the value
  163        * returned by {@code JComponent.getDefaultLocale}.
  164        * <p>
  165        * NOTE: This constructor does not allow you to create an unowned
  166        * {@code JDialog}. To create an unowned {@code JDialog}
  167        * you must use either the {@code JDialog(Window)} or
  168        * {@code JDialog(Dialog)} constructor with an argument of
  169        * {@code null}.
  170        *
  171        * @param owner the {@code Frame} from which the dialog is displayed
  172        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  173        *     returns {@code true}.
  174        * @see java.awt.GraphicsEnvironment#isHeadless
  175        * @see JComponent#getDefaultLocale
  176        */
  177       public JDialog(Frame owner) {
  178           this(owner, false);
  179       }
  180   
  181       /**
  182        * Creates a dialog with an empty title and the specified modality and
  183        * {@code Frame} as its owner. If {@code owner} is {@code null},
  184        * a shared, hidden frame will be set as the owner of the dialog.
  185        * <p>
  186        * This constructor sets the component's locale property to the value
  187        * returned by {@code JComponent.getDefaultLocale}.
  188        * <p>
  189        * NOTE: This constructor does not allow you to create an unowned
  190        * {@code JDialog}. To create an unowned {@code JDialog}
  191        * you must use either the {@code JDialog(Window)} or
  192        * {@code JDialog(Dialog)} constructor with an argument of
  193        * {@code null}.
  194        *
  195        * @param owner the {@code Frame} from which the dialog is displayed
  196        * @param modal specifies whether dialog blocks user input to other top-level
  197        *     windows when shown. If {@code true}, the modality type property is set to
  198        *     {@code DEFAULT_MODALITY_TYPE}, otherwise the dialog is modeless.
  199        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  200        *     returns {@code true}.
  201        * @see java.awt.GraphicsEnvironment#isHeadless
  202        * @see JComponent#getDefaultLocale
  203        */
  204       public JDialog(Frame owner, boolean modal) {
  205           this(owner, "", modal);
  206       }
  207   
  208       /**
  209        * Creates a modeless dialog with the specified title and
  210        * with the specified owner frame.  If {@code owner}
  211        * is {@code null}, a shared, hidden frame will be set as the
  212        * owner of the dialog.
  213        * <p>
  214        * This constructor sets the component's locale property to the value
  215        * returned by {@code JComponent.getDefaultLocale}.
  216        * <p>
  217        * NOTE: This constructor does not allow you to create an unowned
  218        * {@code JDialog}. To create an unowned {@code JDialog}
  219        * you must use either the {@code JDialog(Window)} or
  220        * {@code JDialog(Dialog)} constructor with an argument of
  221        * {@code null}.
  222        *
  223        * @param owner the {@code Frame} from which the dialog is displayed
  224        * @param title  the {@code String} to display in the dialog's
  225        *                  title bar
  226        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  227        *     returns {@code true}.
  228        * @see java.awt.GraphicsEnvironment#isHeadless
  229        * @see JComponent#getDefaultLocale
  230        */
  231       public JDialog(Frame owner, String title) {
  232           this(owner, title, false);
  233       }
  234   
  235       /**
  236        * Creates a dialog with the specified title, owner {@code Frame}
  237        * and modality. If {@code owner} is {@code null},
  238        * a shared, hidden frame will be set as the owner of this dialog.
  239        * <p>
  240        * This constructor sets the component's locale property to the value
  241        * returned by {@code JComponent.getDefaultLocale}.
  242        * <p>
  243        * NOTE: Any popup components ({@code JComboBox},
  244        * {@code JPopupMenu}, {@code JMenuBar})
  245        * created within a modal dialog will be forced to be lightweight.
  246        * <p>
  247        * NOTE: This constructor does not allow you to create an unowned
  248        * {@code JDialog}. To create an unowned {@code JDialog}
  249        * you must use either the {@code JDialog(Window)} or
  250        * {@code JDialog(Dialog)} constructor with an argument of
  251        * {@code null}.
  252        *
  253        * @param owner the {@code Frame} from which the dialog is displayed
  254        * @param title  the {@code String} to display in the dialog's
  255        *     title bar
  256        * @param modal specifies whether dialog blocks user input to other top-level
  257        *     windows when shown. If {@code true}, the modality type property is set to
  258        *     {@code DEFAULT_MODALITY_TYPE} otherwise the dialog is modeless
  259        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  260        *     returns {@code true}.
  261        *
  262        * @see java.awt.Dialog.ModalityType
  263        * @see java.awt.Dialog.ModalityType#MODELESS
  264        * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE
  265        * @see java.awt.Dialog#setModal
  266        * @see java.awt.Dialog#setModalityType
  267        * @see java.awt.GraphicsEnvironment#isHeadless
  268        * @see JComponent#getDefaultLocale
  269        */
  270       public JDialog(Frame owner, String title, boolean modal) {
  271           super(owner == null? SwingUtilities.getSharedOwnerFrame() : owner,
  272                 title, modal);
  273           if (owner == null) {
  274               WindowListener ownerShutdownListener =
  275                       SwingUtilities.getSharedOwnerFrameShutdownListener();
  276               addWindowListener(ownerShutdownListener);
  277           }
  278           dialogInit();
  279       }
  280   
  281       /**
  282        * Creates a dialog with the specified title,
  283        * owner {@code Frame}, modality and {@code GraphicsConfiguration}.
  284        * If {@code owner} is {@code null},
  285        * a shared, hidden frame will be set as the owner of this dialog.
  286        * <p>
  287        * This constructor sets the component's locale property to the value
  288        * returned by {@code JComponent.getDefaultLocale}.
  289        * <p>
  290        * NOTE: Any popup components ({@code JComboBox},
  291        * {@code JPopupMenu}, {@code JMenuBar})
  292        * created within a modal dialog will be forced to be lightweight.
  293        * <p>
  294        * NOTE: This constructor does not allow you to create an unowned
  295        * {@code JDialog}. To create an unowned {@code JDialog}
  296        * you must use either the {@code JDialog(Window)} or
  297        * {@code JDialog(Dialog)} constructor with an argument of
  298        * {@code null}.
  299        *
  300        * @param owner the {@code Frame} from which the dialog is displayed
  301        * @param title  the {@code String} to display in the dialog's
  302        *     title bar
  303        * @param modal specifies whether dialog blocks user input to other top-level
  304        *     windows when shown. If {@code true}, the modality type property is set to
  305        *     {@code DEFAULT_MODALITY_TYPE}, otherwise the dialog is modeless.
  306        * @param gc the {@code GraphicsConfiguration} of the target screen device;
  307        *     if {@code null}, the default system {@code GraphicsConfiguration}
  308        *     is assumed
  309        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  310        *     returns {@code true}.
  311        * @see java.awt.Dialog.ModalityType
  312        * @see java.awt.Dialog.ModalityType#MODELESS
  313        * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE
  314        * @see java.awt.Dialog#setModal
  315        * @see java.awt.Dialog#setModalityType
  316        * @see java.awt.GraphicsEnvironment#isHeadless
  317        * @see JComponent#getDefaultLocale
  318        * @since 1.4
  319        */
  320       public JDialog(Frame owner, String title, boolean modal,
  321                      GraphicsConfiguration gc) {
  322           super(owner == null? SwingUtilities.getSharedOwnerFrame() : owner,
  323                 title, modal, gc);
  324           if (owner == null) {
  325               WindowListener ownerShutdownListener =
  326                       SwingUtilities.getSharedOwnerFrameShutdownListener();
  327               addWindowListener(ownerShutdownListener);
  328           }
  329           dialogInit();
  330       }
  331   
  332       /**
  333        * Creates a modeless dialog with the specified {@code Dialog}
  334        * as its owner and an empty title.
  335        * <p>
  336        * This constructor sets the component's locale property to the value
  337        * returned by {@code JComponent.getDefaultLocale}.
  338        *
  339        * @param owner the owner {@code Dialog} from which the dialog is displayed
  340        *     or {@code null} if this dialog has no owner
  341        * @throws HeadlessException {@code if GraphicsEnvironment.isHeadless()}
  342        *     returns {@code true}.
  343        * @see java.awt.GraphicsEnvironment#isHeadless
  344        * @see JComponent#getDefaultLocale
  345        */
  346       public JDialog(Dialog owner) {
  347           this(owner, false);
  348       }
  349   
  350       /**
  351        * Creates a dialog with an empty title and the specified modality and
  352        * {@code Dialog} as its owner.
  353        * <p>
  354        * This constructor sets the component's locale property to the value
  355        * returned by {@code JComponent.getDefaultLocale}.
  356        *
  357        * @param owner the owner {@code Dialog} from which the dialog is displayed
  358        *     or {@code null} if this dialog has no owner
  359        * @param modal specifies whether dialog blocks user input to other top-level
  360        *     windows when shown. If {@code true}, the modality type property is set to
  361        *     {@code DEFAULT_MODALITY_TYPE}, otherwise the dialog is modeless.
  362        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  363        *     returns {@code true}.
  364        * @see java.awt.Dialog.ModalityType
  365        * @see java.awt.Dialog.ModalityType#MODELESS
  366        * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE
  367        * @see java.awt.Dialog#setModal
  368        * @see java.awt.Dialog#setModalityType
  369        * @see java.awt.GraphicsEnvironment#isHeadless
  370        * @see JComponent#getDefaultLocale
  371        */
  372       public JDialog(Dialog owner, boolean modal) {
  373           this(owner, "", modal);
  374       }
  375   
  376       /**
  377        * Creates a modeless dialog with the specified title and
  378        * with the specified owner dialog.
  379        * <p>
  380        * This constructor sets the component's locale property to the value
  381        * returned by {@code JComponent.getDefaultLocale}.
  382        *
  383        * @param owner the owner {@code Dialog} from which the dialog is displayed
  384        *     or {@code null} if this dialog has no owner
  385        * @param title  the {@code String} to display in the dialog's
  386        *                  title bar
  387        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  388        *     returns {@code true}.
  389        * @see java.awt.GraphicsEnvironment#isHeadless
  390        * @see JComponent#getDefaultLocale
  391        */
  392       public JDialog(Dialog owner, String title) {
  393           this(owner, title, false);
  394       }
  395   
  396       /**
  397        * Creates a dialog with the specified title, modality
  398        * and the specified owner {@code Dialog}.
  399        * <p>
  400        * This constructor sets the component's locale property to the value
  401        * returned by {@code JComponent.getDefaultLocale}.
  402        *
  403        * @param owner the owner {@code Dialog} from which the dialog is displayed
  404        *     or {@code null} if this dialog has no owner
  405        * @param title  the {@code String} to display in the dialog's
  406        *     title bar
  407        * @param modal specifies whether dialog blocks user input to other top-level
  408        *     windows when shown. If {@code true}, the modality type property is set to
  409        *     {@code DEFAULT_MODALITY_TYPE}, otherwise the dialog is modeless
  410        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  411        *     returns {@code true}.
  412        * @see java.awt.Dialog.ModalityType
  413        * @see java.awt.Dialog.ModalityType#MODELESS
  414        * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE
  415        * @see java.awt.Dialog#setModal
  416        * @see java.awt.Dialog#setModalityType
  417        * @see java.awt.GraphicsEnvironment#isHeadless
  418        * @see JComponent#getDefaultLocale
  419        */
  420       public JDialog(Dialog owner, String title, boolean modal) {
  421           super(owner, title, modal);
  422           dialogInit();
  423       }
  424   
  425       /**
  426        * Creates a dialog with the specified title, owner {@code Dialog},
  427        * modality and {@code GraphicsConfiguration}.
  428        *
  429        * <p>
  430        * NOTE: Any popup components ({@code JComboBox},
  431        * {@code JPopupMenu}, {@code JMenuBar})
  432        * created within a modal dialog will be forced to be lightweight.
  433        * <p>
  434        * This constructor sets the component's locale property to the value
  435        * returned by {@code JComponent.getDefaultLocale}.
  436        *
  437        * @param owner the owner {@code Dialog} from which the dialog is displayed
  438        *     or {@code null} if this dialog has no owner
  439        * @param title  the {@code String} to display in the dialog's
  440        *     title bar
  441        * @param modal specifies whether dialog blocks user input to other top-level
  442        *     windows when shown. If {@code true}, the modality type property is set to
  443        *     {@code DEFAULT_MODALITY_TYPE}, otherwise the dialog is modeless
  444        * @param gc the {@code GraphicsConfiguration} of the target screen device;
  445        *     if {@code null}, the default system {@code GraphicsConfiguration}
  446        *     is assumed
  447        * @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
  448        *     returns {@code true}.
  449        * @see java.awt.Dialog.ModalityType
  450        * @see java.awt.Dialog.ModalityType#MODELESS
  451        * @see java.awt.Dialog#DEFAULT_MODALITY_TYPE
  452        * @see java.awt.Dialog#setModal
  453        * @see java.awt.Dialog#setModalityType
  454        * @see java.awt.GraphicsEnvironment#isHeadless
  455        * @see JComponent#getDefaultLocale
  456        * @since 1.4
  457        */
  458       public JDialog(Dialog owner, String title, boolean modal,
  459                      GraphicsConfiguration gc) {
  460           super(owner, title, modal, gc);
  461           dialogInit();
  462       }
  463   
  464       /**
  465        * Creates a modeless dialog with the specified {@code Window}
  466        * as its owner and an empty title.
  467        * <p>
  468        * This constructor sets the component's locale property to the value
  469        * returned by {@code JComponent.getDefaultLocale}.
  470        *
  471        * @param owner the {@code Window} from which the dialog is displayed or
  472        *     {@code null} if this dialog has no owner
  473        *
  474        * @throws IllegalArgumentException
  475        *     if the {@code owner} is not an instance of {@link java.awt.Dialog Dialog}
  476        *     or {@link java.awt.Frame Frame}
  477        * @throws IllegalArgumentException
  478        *     if the {@code owner}'s {@code GraphicsConfiguration} is not from a screen device
  479        * @throws HeadlessException
  480        *     when {@code GraphicsEnvironment.isHeadless()} returns {@code true}
  481        *
  482        * @see java.awt.GraphicsEnvironment#isHeadless
  483        * @see JComponent#getDefaultLocale
  484        *
  485        * @since 1.6
  486        */
  487       public JDialog(Window owner) {
  488           this(owner, Dialog.ModalityType.MODELESS);
  489       }
  490   
  491       /**
  492        * Creates a dialog with an empty title and the specified modality and
  493        * {@code Window} as its owner.
  494        * <p>
  495        * This constructor sets the component's locale property to the value
  496        * returned by {@code JComponent.getDefaultLocale}.
  497        *
  498        * @param owner the {@code Window} from which the dialog is displayed or
  499        *     {@code null} if this dialog has no owner
  500        * @param modalityType specifies whether dialog blocks input to other
  501        *     windows when shown. {@code null} value and unsupported modality
  502        *     types are equivalent to {@code MODELESS}
  503        *
  504        * @throws IllegalArgumentException
  505        *     if the {@code owner} is not an instance of {@link java.awt.Dialog Dialog}
  506        *     or {@link java.awt.Frame Frame}
  507        * @throws IllegalArgumentException
  508        *     if the {@code owner}'s {@code GraphicsConfiguration} is not from a screen device
  509        * @throws HeadlessException
  510        *     when {@code GraphicsEnvironment.isHeadless()} returns {@code true}
  511        * @throws SecurityException
  512        *     if the calling thread does not have permission to create modal dialogs
  513        *     with the given {@code modalityType}
  514        *
  515        * @see java.awt.Dialog.ModalityType
  516        * @see java.awt.Dialog#setModal
  517        * @see java.awt.Dialog#setModalityType
  518        * @see java.awt.GraphicsEnvironment#isHeadless
  519        * @see JComponent#getDefaultLocale
  520        *
  521        * @since 1.6
  522        */
  523       public JDialog(Window owner, ModalityType modalityType) {
  524           this(owner, "", modalityType);
  525       }
  526   
  527       /**
  528        * Creates a modeless dialog with the specified title and owner
  529        * {@code Window}.
  530        * <p>
  531        * This constructor sets the component's locale property to the value
  532        * returned by {@code JComponent.getDefaultLocale}.
  533        *
  534        * @param owner the {@code Window} from which the dialog is displayed or
  535        *     {@code null} if this dialog has no owner
  536        * @param title the {@code String} to display in the dialog's
  537        *     title bar or {@code null} if the dialog has no title
  538        *
  539        * @throws IllegalArgumentException
  540        *     if the {@code owner} is not an instance of {@link java.awt.Dialog Dialog}
  541        *     or {@link java.awt.Frame Frame}
  542        * @throws IllegalArgumentException
  543        *     if the {@code owner}'s {@code GraphicsConfiguration} is not from a screen device
  544        * @throws HeadlessException
  545        *     when {@code GraphicsEnvironment.isHeadless()} returns {@code true}
  546        *
  547        * @see java.awt.GraphicsEnvironment#isHeadless
  548        * @see JComponent#getDefaultLocale
  549        *
  550        * @since 1.6
  551        */
  552       public JDialog(Window owner, String title) {
  553           this(owner, title, Dialog.ModalityType.MODELESS);
  554       }
  555   
  556       /**
  557        * Creates a dialog with the specified title, owner {@code Window} and
  558        * modality.
  559        * <p>
  560        * This constructor sets the component's locale property to the value
  561        * returned by {@code JComponent.getDefaultLocale}.
  562        *
  563        * @param owner the {@code Window} from which the dialog is displayed or
  564        *     {@code null} if this dialog has no owner
  565        * @param title the {@code String} to display in the dialog's
  566        *     title bar or {@code null} if the dialog has no title
  567        * @param modalityType specifies whether dialog blocks input to other
  568        *     windows when shown. {@code null} value and unsupported modality
  569        *     types are equivalent to {@code MODELESS}
  570        *
  571        * @throws IllegalArgumentException
  572        *     if the {@code owner} is not an instance of {@link java.awt.Dialog Dialog}
  573        *     or {@link java.awt.Frame Frame}
  574        * @throws IllegalArgumentException
  575        *     if the {@code owner}'s {@code GraphicsConfiguration} is not from a screen device
  576        * @throws HeadlessException
  577        *     when {@code GraphicsEnvironment.isHeadless()} returns {@code true}
  578        * @throws SecurityException
  579        *     if the calling thread does not have permission to create modal dialogs
  580        *     with the given {@code modalityType}
  581        *
  582        * @see java.awt.Dialog.ModalityType
  583        * @see java.awt.Dialog#setModal
  584        * @see java.awt.Dialog#setModalityType
  585        * @see java.awt.GraphicsEnvironment#isHeadless
  586        * @see JComponent#getDefaultLocale
  587        *
  588        * @since 1.6
  589        */
  590       public JDialog(Window owner, String title, Dialog.ModalityType modalityType) {
  591           super(owner, title, modalityType);
  592           dialogInit();
  593       }
  594   
  595       /**
  596        * Creates a dialog with the specified title, owner {@code Window},
  597        * modality and {@code GraphicsConfiguration}.
  598        * <p>
  599        * NOTE: Any popup components ({@code JComboBox},
  600        * {@code JPopupMenu}, {@code JMenuBar})
  601        * created within a modal dialog will be forced to be lightweight.
  602        * <p>
  603        * This constructor sets the component's locale property to the value
  604        * returned by {@code JComponent.getDefaultLocale}.
  605        *
  606        * @param owner the {@code Window} from which the dialog is displayed or
  607        *     {@code null} if this dialog has no owner
  608        * @param title the {@code String} to display in the dialog's
  609        *     title bar or {@code null} if the dialog has no title
  610        * @param modalityType specifies whether dialog blocks input to other
  611        *     windows when shown. {@code null} value and unsupported modality
  612        *     types are equivalent to {@code MODELESS}
  613        * @param gc the {@code GraphicsConfiguration} of the target screen device;
  614        *     if {@code null}, the default system {@code GraphicsConfiguration}
  615        *     is assumed
  616        * @throws IllegalArgumentException
  617        *     if the {@code owner} is not an instance of {@link java.awt.Dialog Dialog}
  618        *     or {@link java.awt.Frame Frame}
  619        * @throws IllegalArgumentException
  620        *     if the {@code owner}'s {@code GraphicsConfiguration} is not from a screen device
  621        * @throws HeadlessException
  622        *     when {@code GraphicsEnvironment.isHeadless()} returns {@code true}
  623        * @throws SecurityException
  624        *     if the calling thread does not have permission to create modal dialogs
  625        *     with the given {@code modalityType}
  626        *
  627        * @see java.awt.Dialog.ModalityType
  628        * @see java.awt.Dialog#setModal
  629        * @see java.awt.Dialog#setModalityType
  630        * @see java.awt.GraphicsEnvironment#isHeadless
  631        * @see JComponent#getDefaultLocale
  632        *
  633        * @since 1.6
  634        */
  635       public JDialog(Window owner, String title, Dialog.ModalityType modalityType,
  636                      GraphicsConfiguration gc) {
  637           super(owner, title, modalityType, gc);
  638           dialogInit();
  639       }
  640   
  641       /**
  642        * Called by the constructors to init the {@code JDialog} properly.
  643        */
  644       protected void dialogInit() {
  645           enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.WINDOW_EVENT_MASK);
  646           setLocale( JComponent.getDefaultLocale() );
  647           setRootPane(createRootPane());
  648           setRootPaneCheckingEnabled(true);
  649           if (JDialog.isDefaultLookAndFeelDecorated()) {
  650               boolean supportsWindowDecorations =
  651               UIManager.getLookAndFeel().getSupportsWindowDecorations();
  652               if (supportsWindowDecorations) {
  653                   setUndecorated(true);
  654                   getRootPane().setWindowDecorationStyle(JRootPane.PLAIN_DIALOG);
  655               }
  656           }
  657           sun.awt.SunToolkit.checkAndSetPolicy(this, true);
  658       }
  659   
  660       /**
  661        * Called by the constructor methods to create the default
  662        * {@code rootPane}.
  663        */
  664       protected JRootPane createRootPane() {
  665           JRootPane rp = new JRootPane();
  666           // NOTE: this uses setOpaque vs LookAndFeel.installProperty as there
  667           // is NO reason for the RootPane not to be opaque. For painting to
  668           // work the contentPane must be opaque, therefor the RootPane can
  669           // also be opaque.
  670           rp.setOpaque(true);
  671           return rp;
  672       }
  673   
  674       /**
  675        * Handles window events depending on the state of the
  676        * {@code defaultCloseOperation} property.
  677        *
  678        * @see #setDefaultCloseOperation
  679        */
  680       protected void processWindowEvent(WindowEvent e) {
  681           super.processWindowEvent(e);
  682   
  683           if (e.getID() == WindowEvent.WINDOW_CLOSING) {
  684               switch(defaultCloseOperation) {
  685                 case HIDE_ON_CLOSE:
  686                    setVisible(false);
  687                    break;
  688                 case DISPOSE_ON_CLOSE:
  689                    dispose();
  690                    break;
  691                 case DO_NOTHING_ON_CLOSE:
  692                    default:
  693                    break;
  694               }
  695           }
  696       }
  697   
  698   
  699       /**
  700        * Sets the operation that will happen by default when
  701        * the user initiates a "close" on this dialog.
  702        * You must specify one of the following choices:
  703        * <p>
  704        * <ul>
  705        * <li>{@code DO_NOTHING_ON_CLOSE}
  706        * (defined in {@code WindowConstants}):
  707        * Don't do anything; require the
  708        * program to handle the operation in the {@code windowClosing}
  709        * method of a registered {@code WindowListener} object.
  710        *
  711        * <li>{@code HIDE_ON_CLOSE}
  712        * (defined in {@code WindowConstants}):
  713        * Automatically hide the dialog after
  714        * invoking any registered {@code WindowListener}
  715        * objects.
  716        *
  717        * <li>{@code DISPOSE_ON_CLOSE}
  718        * (defined in {@code WindowConstants}):
  719        * Automatically hide and dispose the
  720        * dialog after invoking any registered {@code WindowListener}
  721        * objects.
  722        * </ul>
  723        * <p>
  724        * The value is set to {@code HIDE_ON_CLOSE} by default. Changes
  725        * to the value of this property cause the firing of a property
  726        * change event, with property name "defaultCloseOperation".
  727        * <p>
  728        * <b>Note</b>: When the last displayable window within the
  729        * Java virtual machine (VM) is disposed of, the VM may
  730        * terminate.  See <a href="../../java/awt/doc-files/AWTThreadIssues.html">
  731        * AWT Threading Issues</a> for more information.
  732        *
  733        * @param operation the operation which should be performed when the
  734        *        user closes the dialog
  735        * @throws IllegalArgumentException if defaultCloseOperation value
  736        *         isn't one of the above valid values
  737        * @see #addWindowListener
  738        * @see #getDefaultCloseOperation
  739        * @see WindowConstants
  740        *
  741        * @beaninfo
  742        *   preferred: true
  743        *       bound: true
  744        *        enum: DO_NOTHING_ON_CLOSE WindowConstants.DO_NOTHING_ON_CLOSE
  745        *              HIDE_ON_CLOSE       WindowConstants.HIDE_ON_CLOSE
  746        *              DISPOSE_ON_CLOSE    WindowConstants.DISPOSE_ON_CLOSE
  747        * description: The dialog's default close operation.
  748        */
  749       public void setDefaultCloseOperation(int operation) {
  750           if (operation != DO_NOTHING_ON_CLOSE &&
  751               operation != HIDE_ON_CLOSE &&
  752               operation != DISPOSE_ON_CLOSE) {
  753               throw new IllegalArgumentException("defaultCloseOperation must be one of: DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, or DISPOSE_ON_CLOSE");
  754           }
  755   
  756           int oldValue = this.defaultCloseOperation;
  757           this.defaultCloseOperation = operation;
  758           firePropertyChange("defaultCloseOperation", oldValue, operation);
  759       }
  760   
  761      /**
  762       * Returns the operation which occurs when the user
  763       * initiates a "close" on this dialog.
  764       *
  765       * @return an integer indicating the window-close operation
  766       * @see #setDefaultCloseOperation
  767       */
  768       public int getDefaultCloseOperation() {
  769           return defaultCloseOperation;
  770       }
  771   
  772       /**
  773        * Sets the {@code transferHandler} property, which is a mechanism to
  774        * support transfer of data into this component. Use {@code null}
  775        * if the component does not support data transfer operations.
  776        * <p>
  777        * If the system property {@code suppressSwingDropSupport} is {@code false}
  778        * (the default) and the current drop target on this component is either
  779        * {@code null} or not a user-set drop target, this method will change the
  780        * drop target as follows: If {@code newHandler} is {@code null} it will
  781        * clear the drop target. If not {@code null} it will install a new
  782        * {@code DropTarget}.
  783        * <p>
  784        * Note: When used with {@code JDialog}, {@code TransferHandler} only
  785        * provides data import capability, as the data export related methods
  786        * are currently typed to {@code JComponent}.
  787        * <p>
  788        * Please see
  789        * <a href="http://java.sun.com/docs/books/tutorial/uiswing/misc/dnd.html">
  790        * How to Use Drag and Drop and Data Transfer</a>, a section in
  791        * <em>The Java Tutorial</em>, for more information.
  792        *
  793        * @param newHandler the new {@code TransferHandler}
  794        *
  795        * @see TransferHandler
  796        * @see #getTransferHandler
  797        * @see java.awt.Component#setDropTarget
  798        * @since 1.6
  799        *
  800        * @beaninfo
  801        *        bound: true
  802        *       hidden: true
  803        *  description: Mechanism for transfer of data into the component
  804        */
  805       public void setTransferHandler(TransferHandler newHandler) {
  806           TransferHandler oldHandler = transferHandler;
  807           transferHandler = newHandler;
  808           SwingUtilities.installSwingDropTargetAsNecessary(this, transferHandler);
  809           firePropertyChange("transferHandler", oldHandler, newHandler);
  810       }
  811   
  812       /**
  813        * Gets the {@code transferHandler} property.
  814        *
  815        * @return the value of the {@code transferHandler} property
  816        *
  817        * @see TransferHandler
  818        * @see #setTransferHandler
  819        * @since 1.6
  820        */
  821       public TransferHandler getTransferHandler() {
  822           return transferHandler;
  823       }
  824   
  825       /**
  826        * Calls {@code paint(g)}.  This method was overridden to
  827        * prevent an unnecessary call to clear the background.
  828        *
  829        * @param g  the {@code Graphics} context in which to paint
  830        */
  831       public void update(Graphics g) {
  832           paint(g);
  833       }
  834   
  835      /**
  836       * Sets the menubar for this dialog.
  837       *
  838       * @param menu the menubar being placed in the dialog
  839       *
  840       * @see #getJMenuBar
  841       *
  842       * @beaninfo
  843       *      hidden: true
  844       * description: The menubar for accessing pulldown menus from this dialog.
  845       */
  846       public void setJMenuBar(JMenuBar menu) {
  847           getRootPane().setMenuBar(menu);
  848       }
  849   
  850      /**
  851       * Returns the menubar set on this dialog.
  852       *
  853       * @see #setJMenuBar
  854       */
  855       public JMenuBar getJMenuBar() {
  856           return getRootPane().getMenuBar();
  857       }
  858   
  859   
  860       /**
  861        * Returns whether calls to {@code add} and
  862        * {@code setLayout} are forwarded to the {@code contentPane}.
  863        *
  864        * @return true if {@code add} and {@code setLayout}
  865        *         are fowarded; false otherwise
  866        *
  867        * @see #addImpl
  868        * @see #setLayout
  869        * @see #setRootPaneCheckingEnabled
  870        * @see javax.swing.RootPaneContainer
  871        */
  872       protected boolean isRootPaneCheckingEnabled() {
  873           return rootPaneCheckingEnabled;
  874       }
  875   
  876   
  877       /**
  878        * Sets whether calls to {@code add} and
  879        * {@code setLayout} are forwarded to the {@code contentPane}.
  880        *
  881        * @param enabled  true if {@code add} and {@code setLayout}
  882        *        are forwarded, false if they should operate directly on the
  883        *        {@code JDialog}.
  884        *
  885        * @see #addImpl
  886        * @see #setLayout
  887        * @see #isRootPaneCheckingEnabled
  888        * @see javax.swing.RootPaneContainer
  889        * @beaninfo
  890        *      hidden: true
  891        * description: Whether the add and setLayout methods are forwarded
  892        */
  893       protected void setRootPaneCheckingEnabled(boolean enabled) {
  894           rootPaneCheckingEnabled = enabled;
  895       }
  896   
  897       /**
  898        * Adds the specified child {@code Component}.
  899        * This method is overridden to conditionally forward calls to the
  900        * {@code contentPane}.
  901        * By default, children are added to the {@code contentPane} instead
  902        * of the frame, refer to {@link javax.swing.RootPaneContainer} for
  903        * details.
  904        *
  905        * @param comp the component to be enhanced
  906        * @param constraints the constraints to be respected
  907        * @param index the index
  908        * @throws IllegalArgumentException if {@code index} is invalid
  909        * @throws IllegalArgumentException if adding the container's parent
  910        *                  to itself
  911        * @throws IllegalArgumentException if adding a window to a container
  912        *
  913        * @see #setRootPaneCheckingEnabled
  914        * @see javax.swing.RootPaneContainer
  915        */
  916       protected void addImpl(Component comp, Object constraints, int index)
  917       {
  918           if(isRootPaneCheckingEnabled()) {
  919               getContentPane().add(comp, constraints, index);
  920           }
  921           else {
  922               super.addImpl(comp, constraints, index);
  923           }
  924       }
  925   
  926       /**
  927        * Removes the specified component from the container. If
  928        * {@code comp} is not the {@code rootPane}, this will forward
  929        * the call to the {@code contentPane}. This will do nothing if
  930        * {@code comp} is not a child of the {@code JDialog} or
  931        * {@code contentPane}.
  932        *
  933        * @param comp the component to be removed
  934        * @throws NullPointerException if {@code comp} is null
  935        * @see #add
  936        * @see javax.swing.RootPaneContainer
  937        */
  938       public void remove(Component comp) {
  939           if (comp == rootPane) {
  940               super.remove(comp);
  941           } else {
  942               getContentPane().remove(comp);
  943           }
  944       }
  945   
  946   
  947       /**
  948        * Sets the {@code LayoutManager}.
  949        * Overridden to conditionally forward the call to the
  950        * {@code contentPane}.
  951        * Refer to {@link javax.swing.RootPaneContainer} for
  952        * more information.
  953        *
  954        * @param manager the {@code LayoutManager}
  955        * @see #setRootPaneCheckingEnabled
  956        * @see javax.swing.RootPaneContainer
  957        */
  958       public void setLayout(LayoutManager manager) {
  959           if(isRootPaneCheckingEnabled()) {
  960               getContentPane().setLayout(manager);
  961           }
  962           else {
  963               super.setLayout(manager);
  964           }
  965       }
  966   
  967   
  968       /**
  969        * Returns the {@code rootPane} object for this dialog.
  970        *
  971        * @see #setRootPane
  972        * @see RootPaneContainer#getRootPane
  973        */
  974       public JRootPane getRootPane() {
  975           return rootPane;
  976       }
  977   
  978   
  979       /**
  980        * Sets the {@code rootPane} property.
  981        * This method is called by the constructor.
  982        *
  983        * @param root the {@code rootPane} object for this dialog
  984        *
  985        * @see #getRootPane
  986        *
  987        * @beaninfo
  988        *   hidden: true
  989        * description: the RootPane object for this dialog.
  990        */
  991       protected void setRootPane(JRootPane root) {
  992           if(rootPane != null) {
  993               remove(rootPane);
  994           }
  995           rootPane = root;
  996           if(rootPane != null) {
  997               boolean checkingEnabled = isRootPaneCheckingEnabled();
  998               try {
  999                   setRootPaneCheckingEnabled(false);
 1000                   add(rootPane, BorderLayout.CENTER);
 1001               }
 1002               finally {
 1003                   setRootPaneCheckingEnabled(checkingEnabled);
 1004               }
 1005           }
 1006       }
 1007   
 1008   
 1009       /**
 1010        * Returns the {@code contentPane} object for this dialog.
 1011        *
 1012        * @return the {@code contentPane} property
 1013        *
 1014        * @see #setContentPane
 1015        * @see RootPaneContainer#getContentPane
 1016        */
 1017       public Container getContentPane() {
 1018           return getRootPane().getContentPane();
 1019       }
 1020   
 1021   
 1022      /**
 1023        * Sets the {@code contentPane} property.
 1024        * This method is called by the constructor.
 1025        * <p>
 1026        * Swing's painting architecture requires an opaque {@code JComponent}
 1027        * in the containment hiearchy. This is typically provided by the
 1028        * content pane. If you replace the content pane it is recommended you
 1029        * replace it with an opaque {@code JComponent}.
 1030        * @see JRootPane
 1031        *
 1032        * @param contentPane the {@code contentPane} object for this dialog
 1033        *
 1034        * @throws java.awt.IllegalComponentStateException (a runtime
 1035        *            exception) if the content pane parameter is {@code null}
 1036        * @see #getContentPane
 1037        * @see RootPaneContainer#setContentPane
 1038        *
 1039        * @beaninfo
 1040        *     hidden: true
 1041        *     description: The client area of the dialog where child
 1042        *                  components are normally inserted.
 1043        */
 1044       public void setContentPane(Container contentPane) {
 1045           getRootPane().setContentPane(contentPane);
 1046       }
 1047   
 1048       /**
 1049        * Returns the {@code layeredPane} object for this dialog.
 1050        *
 1051        * @return the {@code layeredPane} property
 1052        *
 1053        * @see #setLayeredPane
 1054        * @see RootPaneContainer#getLayeredPane
 1055        */
 1056       public JLayeredPane getLayeredPane() {
 1057           return getRootPane().getLayeredPane();
 1058       }
 1059   
 1060       /**
 1061        * Sets the {@code layeredPane} property.
 1062        * This method is called by the constructor.
 1063        *
 1064        * @param layeredPane the new {@code layeredPane} property
 1065        *
 1066        * @throws java.awt.IllegalComponentStateException (a runtime
 1067        *            exception) if the layered pane parameter is null
 1068        * @see #getLayeredPane
 1069        * @see RootPaneContainer#setLayeredPane
 1070        *
 1071        * @beaninfo
 1072        *     hidden: true
 1073        *     description: The pane which holds the various dialog layers.
 1074        */
 1075       public void setLayeredPane(JLayeredPane layeredPane) {
 1076           getRootPane().setLayeredPane(layeredPane);
 1077       }
 1078   
 1079       /**
 1080        * Returns the {@code glassPane} object for this dialog.
 1081        *
 1082        * @return the {@code glassPane} property
 1083        *
 1084        * @see #setGlassPane
 1085        * @see RootPaneContainer#getGlassPane
 1086        */
 1087       public Component getGlassPane() {
 1088           return getRootPane().getGlassPane();
 1089       }
 1090   
 1091       /**
 1092        * Sets the {@code glassPane} property.
 1093        * This method is called by the constructor.
 1094        *
 1095        * @param glassPane the {@code glassPane} object for this dialog
 1096        * @see #getGlassPane
 1097        * @see RootPaneContainer#setGlassPane
 1098        *
 1099        * @beaninfo
 1100        *     hidden: true
 1101        *     description: A transparent pane used for menu rendering.
 1102        */
 1103       public void setGlassPane(Component glassPane) {
 1104           getRootPane().setGlassPane(glassPane);
 1105       }
 1106   
 1107       /**
 1108        * {@inheritDoc}
 1109        *
 1110        * @since 1.6
 1111        */
 1112       public Graphics getGraphics() {
 1113           JComponent.getGraphicsInvoked(this);
 1114           return super.getGraphics();
 1115       }
 1116   
 1117       /**
 1118        * Repaints the specified rectangle of this component within
 1119        * {@code time} milliseconds.  Refer to {@code RepaintManager}
 1120        * for details on how the repaint is handled.
 1121        *
 1122        * @param     time   maximum time in milliseconds before update
 1123        * @param     x    the <i>x</i> coordinate
 1124        * @param     y    the <i>y</i> coordinate
 1125        * @param     width    the width
 1126        * @param     height   the height
 1127        * @see       RepaintManager
 1128        * @since     1.6
 1129        */
 1130       public void repaint(long time, int x, int y, int width, int height) {
 1131           if (RepaintManager.HANDLE_TOP_LEVEL_PAINT) {
 1132               RepaintManager.currentManager(this).addDirtyRegion(
 1133                                 this, x, y, width, height);
 1134           }
 1135           else {
 1136               super.repaint(time, x, y, width, height);
 1137           }
 1138       }
 1139   
 1140       /**
 1141        * Provides a hint as to whether or not newly created {@code JDialog}s
 1142        * should have their Window decorations (such as borders, widgets to
 1143        * close the window, title...) provided by the current look
 1144        * and feel. If {@code defaultLookAndFeelDecorated} is true,
 1145        * the current {@code LookAndFeel} supports providing window
 1146        * decorations, and the current window manager supports undecorated
 1147        * windows, then newly created {@code JDialog}s will have their
 1148        * Window decorations provided by the current {@code LookAndFeel}.
 1149        * Otherwise, newly created {@code JDialog}s will have their
 1150        * Window decorations provided by the current window manager.
 1151        * <p>
 1152        * You can get the same effect on a single JDialog by doing the following:
 1153        * <pre>
 1154        *    JDialog dialog = new JDialog();
 1155        *    dialog.setUndecorated(true);
 1156        *    dialog.getRootPane().setWindowDecorationStyle(JRootPane.PLAIN_DIALOG);
 1157        * </pre>
 1158        *
 1159        * @param defaultLookAndFeelDecorated A hint as to whether or not current
 1160        *        look and feel should provide window decorations
 1161        * @see javax.swing.LookAndFeel#getSupportsWindowDecorations
 1162        * @since 1.4
 1163        */
 1164       public static void setDefaultLookAndFeelDecorated(boolean defaultLookAndFeelDecorated) {
 1165           if (defaultLookAndFeelDecorated) {
 1166               SwingUtilities.appContextPut(defaultLookAndFeelDecoratedKey, Boolean.TRUE);
 1167           } else {
 1168               SwingUtilities.appContextPut(defaultLookAndFeelDecoratedKey, Boolean.FALSE);
 1169           }
 1170       }
 1171   
 1172       /**
 1173        * Returns true if newly created {@code JDialog}s should have their
 1174        * Window decorations provided by the current look and feel. This is only
 1175        * a hint, as certain look and feels may not support this feature.
 1176        *
 1177        * @return true if look and feel should provide Window decorations.
 1178        * @since 1.4
 1179        */
 1180       public static boolean isDefaultLookAndFeelDecorated() {
 1181           Boolean defaultLookAndFeelDecorated =
 1182               (Boolean) SwingUtilities.appContextGet(defaultLookAndFeelDecoratedKey);
 1183           if (defaultLookAndFeelDecorated == null) {
 1184               defaultLookAndFeelDecorated = Boolean.FALSE;
 1185           }
 1186           return defaultLookAndFeelDecorated.booleanValue();
 1187       }
 1188   
 1189       /**
 1190        * Returns a string representation of this {@code JDialog}.
 1191        * This method
 1192        * is intended to be used only for debugging purposes, and the
 1193        * content and format of the returned string may vary between
 1194        * implementations. The returned string may be empty but may not
 1195        * be {@code null}.
 1196        *
 1197        * @return  a string representation of this {@code JDialog}.
 1198        */
 1199       protected String paramString() {
 1200           String defaultCloseOperationString;
 1201           if (defaultCloseOperation == HIDE_ON_CLOSE) {
 1202               defaultCloseOperationString = "HIDE_ON_CLOSE";
 1203           } else if (defaultCloseOperation == DISPOSE_ON_CLOSE) {
 1204               defaultCloseOperationString = "DISPOSE_ON_CLOSE";
 1205           } else if (defaultCloseOperation == DO_NOTHING_ON_CLOSE) {
 1206               defaultCloseOperationString = "DO_NOTHING_ON_CLOSE";
 1207           } else defaultCloseOperationString = "";
 1208           String rootPaneString = (rootPane != null ?
 1209                                    rootPane.toString() : "");
 1210           String rootPaneCheckingEnabledString = (rootPaneCheckingEnabled ?
 1211                                                   "true" : "false");
 1212   
 1213           return super.paramString() +
 1214           ",defaultCloseOperation=" + defaultCloseOperationString +
 1215           ",rootPane=" + rootPaneString +
 1216           ",rootPaneCheckingEnabled=" + rootPaneCheckingEnabledString;
 1217       }
 1218   
 1219   
 1220   /////////////////
 1221   // Accessibility support
 1222   ////////////////
 1223   
 1224       protected AccessibleContext accessibleContext = null;
 1225   
 1226       /**
 1227        * Gets the AccessibleContext associated with this JDialog.
 1228        * For JDialogs, the AccessibleContext takes the form of an
 1229        * AccessibleJDialog.
 1230        * A new AccessibleJDialog instance is created if necessary.
 1231        *
 1232        * @return an AccessibleJDialog that serves as the
 1233        *         AccessibleContext of this JDialog
 1234        */
 1235       public AccessibleContext getAccessibleContext() {
 1236           if (accessibleContext == null) {
 1237               accessibleContext = new AccessibleJDialog();
 1238           }
 1239           return accessibleContext;
 1240       }
 1241   
 1242       /**
 1243        * This class implements accessibility support for the
 1244        * {@code JDialog} class.  It provides an implementation of the
 1245        * Java Accessibility API appropriate to dialog user-interface
 1246        * elements.
 1247        */
 1248       protected class AccessibleJDialog extends AccessibleAWTDialog {
 1249   
 1250           // AccessibleContext methods
 1251           //
 1252           /**
 1253            * Get the accessible name of this object.
 1254            *
 1255            * @return the localized name of the object -- can be null if this
 1256            * object does not have a name
 1257            */
 1258           public String getAccessibleName() {
 1259               if (accessibleName != null) {
 1260                   return accessibleName;
 1261               } else {
 1262                   if (getTitle() == null) {
 1263                       return super.getAccessibleName();
 1264                   } else {
 1265                       return getTitle();
 1266                   }
 1267               }
 1268           }
 1269   
 1270           /**
 1271            * Get the state of this object.
 1272            *
 1273            * @return an instance of AccessibleStateSet containing the current
 1274            * state set of the object
 1275            * @see AccessibleState
 1276            */
 1277           public AccessibleStateSet getAccessibleStateSet() {
 1278               AccessibleStateSet states = super.getAccessibleStateSet();
 1279   
 1280               if (isResizable()) {
 1281                   states.add(AccessibleState.RESIZABLE);
 1282               }
 1283               if (getFocusOwner() != null) {
 1284                   states.add(AccessibleState.ACTIVE);
 1285               }
 1286               if (isModal()) {
 1287                   states.add(AccessibleState.MODAL);
 1288               }
 1289               return states;
 1290           }
 1291   
 1292       } // inner class AccessibleJDialog
 1293   }

Home » openjdk-7 » javax » swing » [javadoc | source]