home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / JDialog.java < prev    next >
Text File  |  1998-02-26  |  31KB  |  957 lines
  1. /*
  2.  * @(#)JDialog.java    1.27 98/02/05
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20. package com.sun.java.swing;
  21.  
  22. import java.awt.*;
  23. import java.awt.event.*;
  24. import java.beans.PropertyChangeListener;
  25. import java.util.Locale;
  26. import java.util.Vector;
  27. import java.io.Serializable;
  28. import com.sun.java.accessibility.*;
  29. import java.applet.Applet;
  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 static methods
  34.  * in JOptionPane to create a variety of standard dialogs.
  35.  *
  36.  * The JDialog component contains a JRootPane as it's only 
  37.  * child.
  38.  * The <code>contentPane</code> should be the parent of any children of 
  39.  * the JDialog. From the older <code>java.awt.Window</code> object you 
  40.  * would normally do something like this:
  41.  * <PRE>
  42.  *       dialog.add(child);
  43.  * </PRE>
  44.  * Using JDialog the proper semantic is:
  45.  * <PRE>
  46.  *       dialog.getContentPane().add(child);
  47.  * </PRE>
  48.  * The same priniciple holds true for setting layout managers, removing 
  49.  * components, listing children, etc. All these methods should normally 
  50.  * be sent to the <code>contentPane</code> instead of to the JDialog.
  51.  * The <code>contentPane</code> is always non-null. Attempting to set it 
  52.  * to null generates an exception. The default <code>contentPane</code> 
  53.  * has a BorderLayout manager set on it. 
  54.  * <p>
  55.  * Please see the JRootPane documentation for a complete 
  56.  * description of the <code>contentPane</code>, <code>glassPane</code>, 
  57.  * and <code>layeredPane</code> components.
  58.  * <p>
  59.  * NOTE: For 1.1, Modal dialogs are currently constrained to only allow
  60.  * lightweight popup menus (JPopupMenu, JComboBox, JMenuBar) because
  61.  * of window ownership limitations in AWT1.1.   This creates the further
  62.  * limitation of not being able to mix Swing popup components with
  63.  * AWT heavyweight components in a modal dialog since the heavyweight
  64.  * components would always overlap the lightweights, potentially
  65.  * obscuring the popup menu.
  66.  * (A heavyweight component uses a native-platform component (peer)
  67.  * component for its implementation -- AWT components are heavyweight
  68.  * components.)
  69.  * <p>
  70.  * Warning: serialized objects of this class will not be compatible with
  71.  * future swing releases.  The current serialization support is appropriate 
  72.  * for short term storage or RMI between Swing1.0 applications.  It will
  73.  * not be possible to load serialized Swing1.0 objects with future releases
  74.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  75.  * baseline for the serialized form of Swing objects.
  76.  *
  77.  * @see JOptionPane
  78.  * @see JRootPane
  79.  *
  80.  * @beaninfo
  81.  *      attribute: isContainer true
  82.  *      attribute: containerDelegate getContentPane
  83.  *    description: A toplevel window for creating dialog boxes.
  84.  *
  85.  * @version 1.27 02/05/98
  86.  * @author David Kloba
  87.  * @author James Gosling
  88.  * @author Scott Violet
  89.  */
  90. public class JDialog extends Dialog implements WindowConstants, Accessible, RootPaneContainer 
  91. {
  92.     private int defaultCloseOperation = HIDE_ON_CLOSE;
  93.     
  94.     /**
  95.      * @see #getRootPane
  96.      * @see #setRootPane
  97.      */
  98.     protected JRootPane rootPane;
  99.  
  100.     /**
  101.      * @see #isRootPaneCheckingEnabled
  102.      * @see #setRootPaneCheckingEnabled
  103.      */
  104.     protected boolean rootPaneCheckingEnabled = false;
  105.  
  106.  
  107.     /**
  108.      * Creates a non-modal dialog without a title and without
  109.      * a specified Frame owner.  A shared, hidden frame will be
  110.      * set as the owner of the Dialog.
  111.      */
  112.     public JDialog() {
  113.         this(null, false);
  114.     }
  115.  
  116.     /**
  117.      * Creates a non-modal dialog without a title with the
  118.      * specifed Frame as its owner.
  119.      *
  120.      * @param owner the Frame from which the dialog is displayed
  121.      */
  122.     public JDialog(Frame owner) {
  123.         this(owner, false);
  124.     }
  125.  
  126.     /**
  127.      * Creates a modal or non-modal dialog without a title and
  128.      * with the specified owner frame.
  129.      * <p>
  130.      * NOTE: Modal dialogs cannot have heavyweight components in them.
  131.      *
  132.      * @param owner the Frame from which the dialog is displayed
  133.      * @param modal  true for a modal dialog, false for one that allows
  134.      *               others windows to be active at the same time
  135.      */
  136.     public JDialog(Frame owner, boolean modal) {
  137.         this(owner, null, modal);
  138.     }
  139.  
  140.     /**
  141.      * Creates a non-modal dialog with the specified title and
  142.      * with the specified owner frame.
  143.      *
  144.      * @param owner the Frame from which the dialog is displayed
  145.      * @param title  the String to display in the dialog's title bar
  146.      */
  147.     public JDialog(Frame owner, String title) {
  148.         this(owner, title, false);     
  149.     }
  150.  
  151.     /**
  152.      * Creates a modal or non-modal dialog with the specified title 
  153.      * and the specified owner frame.
  154.      * <p>
  155.      * NOTE: Any popup components (JComboBox, JPopupMenu, JMenuBar)
  156.      * created within a modal dialog will be forced to be lightweight.
  157.      *
  158.      * @param owner the frame from which the dialog is displayed
  159.      * @param title  the String to display in the dialog's title bar
  160.      * @param modal  true for a modal dialog, false for one that allows
  161.      *               others windows to be active at the same time
  162.      */
  163.     public JDialog(Frame owner, String title, boolean modal) {
  164.         super(owner == null? SwingUtilities.getSharedOwnerFrame() : owner, 
  165.               title, modal);
  166.         dialogInit();
  167.     }
  168.  
  169.     /** Called by the constructors to init the JDialog properly. */
  170.     protected void dialogInit() {
  171.         enableEvents(AWTEvent.WINDOW_EVENT_MASK);
  172.         setRootPane(createRootPane());
  173.         setRootPaneCheckingEnabled(true);
  174.     }
  175.  
  176.     /** Called by the constructor methods to create the default rootPane. */
  177.     protected JRootPane createRootPane() {
  178.         return new JRootPane();
  179.     }
  180.  
  181.     /**
  182.      * Handles window events depending on the state of the
  183.      * <code>defaultCloseOperation</code> property.
  184.      *
  185.      * @see #setDefaultCloseOperation
  186.      */
  187.     protected void processWindowEvent(WindowEvent e) {
  188.         super.processWindowEvent(e);
  189.  
  190.         if (e.getID() == WindowEvent.WINDOW_CLOSING) {
  191.             switch(defaultCloseOperation) {
  192.               case HIDE_ON_CLOSE:
  193.                  setVisible(false);
  194.                  break;
  195.               case DISPOSE_ON_CLOSE:
  196.                  setVisible(false);
  197.                  dispose();
  198.                  break;
  199.               case DO_NOTHING_ON_CLOSE:
  200.                  default: 
  201.                  break;
  202.             }
  203.         }
  204.     }
  205.  
  206.  
  207.     /**
  208.      * Sets the operation which will happen by default when
  209.      * the user initiates a "close" on this dialog.
  210.      * The possible choices are:
  211.      * <ul>
  212.      * <li>DO_NOTHING_ON_CLOSE - do not do anything - require the
  213.      * program to handle the operation in the windowClosing
  214.      * method of a registered WindowListener object.
  215.      * <li>HIDE_ON_CLOSE - automatically hide the dialog after
  216.      * invoking any registered WindowListener objects
  217.      * <li>DISPOSE_ON_CLOSE - automatically hide and dispose the 
  218.      * dialog after invoking any registered WindowListener objects
  219.      * </ul>
  220.      * <p>
  221.      * The value is set to HIDE_ON_CLOSE by default.
  222.      * @see #addWindowListener
  223.      * @see #getDefaultCloseOperation
  224.      *
  225.      * @beaninfo
  226.      *   preferred: true
  227.      * description: The dialog's default close operation.
  228.      */
  229.     public void setDefaultCloseOperation(int operation) {
  230.         this.defaultCloseOperation = operation;
  231.     }
  232.  
  233.    /**
  234.     * Returns the operation which occurs when the user
  235.     * initiates a "close" on this dialog.
  236.     *
  237.     * @return an int indicating the window-close operation
  238.     * @see #setDefaultCloseOperation
  239.     */
  240.     public int getDefaultCloseOperation() {
  241.         return defaultCloseOperation;
  242.     }
  243.  
  244.  
  245.     /** 
  246.      * Just calls <code>paint(g)</code>.  This method was overridden to 
  247.      * prevent an unneccessary call to clear the background.
  248.      */
  249.     public void update(Graphics g) {
  250.         paint(g);
  251.     }
  252.  
  253.    /**
  254.     * Sets the menubar for this dialog.
  255.     * @param menubar the menubar being placed in the dialog
  256.     *
  257.     * @see #getJMenuBar
  258.     *
  259.     * @beaninfo
  260.     *      hidden: true
  261.     * description: The menubar for accessing pulldown menus from this dialog.
  262.     */
  263.     public void setJMenuBar(JMenuBar menu) {
  264.         getRootPane().setMenuBar(menu);
  265.     }
  266.  
  267.    /**
  268.     * Returns the menubar set on this dialog.
  269.     *
  270.     * @see #setJMenuBar
  271.     */
  272.     public JMenuBar getJMenuBar() { 
  273.         return getRootPane().getMenuBar(); 
  274.     }
  275.  
  276.  
  277.     /**
  278.      * @return true if add and setLayout should be checked
  279.      * @see #addImpl
  280.      * @see #setLayout
  281.      * @see #setRootPaneCheckingEnabled
  282.      */
  283.     protected boolean isRootPaneCheckingEnabled() {
  284.         return rootPaneCheckingEnabled;
  285.     }
  286.  
  287.  
  288.     /**
  289.      * If true then calls to add() and setLayout() will cause an exception
  290.      * to be thrown.  
  291.      *
  292.      * @see #addImpl
  293.      * @see #setLayout
  294.      * @see #isRootPaneCheckingEnabled
  295.      * @beaninfo
  296.      *   hidden: true
  297.      * description: Whether the add and setLayout methods throw exceptions when invoked.
  298.      */
  299.     protected void setRootPaneCheckingEnabled(boolean enabled) {
  300.         rootPaneCheckingEnabled = enabled;
  301.     }
  302.  
  303.     /**
  304.      * Create an runtime exception with a message like:
  305.      * <pre>
  306.      * "Do not use JDialog.add() use JDialog.getContentPane().add() instead"
  307.      * </pre>
  308.      */
  309.     private Error createRootPaneException(String op) {
  310.         String type = getClass().getName();
  311.         return new Error(
  312.             "Do not use " + type + "." + op + "() use " 
  313.                           + type + ".getContentPane()." + op + "() instead");
  314.     }
  315.  
  316.  
  317.     /**
  318.      * By default, children may not be added directly to a this component,
  319.      * they must be added to its contentPane instead.  For example:
  320.      * <pre>
  321.      * thisComponent.getContentPane().add(child)
  322.      * </pre>
  323.      * An attempt to add to directly to this component will cause an
  324.      * runtime exception to be thrown.  Subclasses can disable this
  325.      * behavior.
  326.      * 
  327.      * @see #setRootPaneCheckingEnabled
  328.      * @exception Error if called with rootPaneChecking true
  329.      */
  330.     protected void addImpl(Component comp, Object constraints, int index) 
  331.     {
  332.         if(isRootPaneCheckingEnabled()) {
  333.             throw createRootPaneException("add");
  334.         }
  335.         else {
  336.             super.addImpl(comp, constraints, index);
  337.         }
  338.     }
  339.  
  340.  
  341.     /**
  342.      * By default the layout of this component may not be set,
  343.      * the layout of its contentPane should be set instead.  
  344.      * For example:
  345.      * <pre>
  346.      * thisComponent.getContentPane().setLayout(new BorderLayout())
  347.      * </pre>
  348.      * An attempt to set the layout of this component will cause an
  349.      * runtime exception to be thrown.  Subclasses can disable this
  350.      * behavior.
  351.      * 
  352.      * @see #setRootPaneCheckingEnabled
  353.      * @exception Error if called with rootPaneChecking true
  354.      */
  355.     public void setLayout(LayoutManager manager) {
  356.         if(isRootPaneCheckingEnabled()) {
  357.             throw createRootPaneException("setLayout");
  358.         }
  359.         else {
  360.             super.setLayout(manager);
  361.         }
  362.     }
  363.  
  364.  
  365.     /**
  366.      * Returns the rootPane object for this dialog.
  367.      *
  368.      * @see #setRootPane
  369.      * @see RootPaneContainer#getRootPane
  370.      */
  371.     public JRootPane getRootPane() { 
  372.         return rootPane; 
  373.     }
  374.  
  375.  
  376.     /**
  377.      * Sets the rootPane property.  This method is called by the constructor.
  378.      * @param root the rootPane object for this dialog
  379.      *
  380.      * @see #getRootPane
  381.      * @see RootPaneContainer#setRootPane
  382.      *
  383.      * @beaninfo
  384.      *   hidden: true
  385.      * description: the RootPane object for this dialog.
  386.      */
  387.     protected void setRootPane(JRootPane root) {
  388.         if(rootPane != null) {
  389.             remove(rootPane);
  390.         }
  391.         rootPane = root;
  392.         if(rootPane != null) {
  393.             boolean checkingEnabled = isRootPaneCheckingEnabled();
  394.             try {
  395.                 setRootPaneCheckingEnabled(false);
  396.                 add(rootPane, BorderLayout.CENTER);
  397.             }
  398.             finally {
  399.                 setRootPaneCheckingEnabled(checkingEnabled);
  400.             }
  401.         }
  402.     }
  403.  
  404.  
  405.     /**
  406.      * Returns the contentPane object for this dialog.
  407.      *
  408.      * @see #setContentPane
  409.      * @see RootPaneContainer#getContentPane
  410.      */
  411.     public Container getContentPane() { 
  412.         return getRootPane().getContentPane(); 
  413.     }
  414.  
  415.  
  416.    /**
  417.      * Sets the contentPane property.  This method is called by the constructor.
  418.      * @param contentPane the contentPane object for this dialog
  419.      *
  420.      * @see #getContentPane
  421.      * @see RootPaneContainer#setContentPane
  422.      *
  423.      * @beaninfo
  424.      *     hidden: true
  425.      *     description: The client area of the dialog where child 
  426.      *                  components are normally inserted.
  427.      */
  428.     public void setContentPane(Container contentPane) {
  429.         getRootPane().setContentPane(contentPane);
  430.     }
  431.  
  432.     /**
  433.      * Returns the layeredPane object for this dialog.
  434.      *
  435.      * @see #setLayeredPane
  436.      * @see RootPaneContainer#getLayeredPane
  437.      */
  438.     public JLayeredPane getLayeredPane() { 
  439.         return getRootPane().getLayeredPane(); 
  440.     }
  441.  
  442.     /**
  443.      * Sets the layeredPane property.  This method is called by the constructor.
  444.      * @param layeredPane the layeredPane object for this dialog
  445.      *
  446.      * @see #getLayeredPane
  447.      * @see RootPaneContainer#setLayeredPane
  448.      *
  449.      * @beaninfo
  450.      *     hidden: true
  451.      *     description: The pane which holds the various dialog layers.
  452.      */
  453.     public void setLayeredPane(JLayeredPane layeredPane) {
  454.         getRootPane().setLayeredPane(layeredPane);
  455.     }
  456.  
  457.     /**
  458.      * Returns the glassPane object for this dialog.
  459.      *
  460.      * @see #setGlassPane
  461.      * @see RootPaneContainer#getGlassPane
  462.      */
  463.     public Component getGlassPane() { 
  464.         return getRootPane().getGlassPane(); 
  465.     }
  466.  
  467.     /**
  468.      * Sets the glassPane property. 
  469.      * This method is called by the constructor.
  470.      * @param glassPane the glassPane object for this dialog
  471.      * @see #getGlassPane
  472.      * @see RootPaneContainer#setGlassPane
  473.      *
  474.      * @beaninfo
  475.      *     hidden: true
  476.      *     description: A transparent pane used for menu rendering.
  477.      */
  478.     public void setGlassPane(Component glassPane) {
  479.         getRootPane().setGlassPane(glassPane);
  480.     }
  481.  
  482.  
  483.     /**
  484.      * Sets the location of the dialog relative to the specified
  485.      * component. If the component is not currently showing, the 
  486.      * dialog is centered on the screen.
  487.      *
  488.      * @param c  the component in relation to which the dialog's location
  489.      *           is determined
  490.      */
  491.     public void setLocationRelativeTo(Component c) {
  492.         Container root=null;
  493.  
  494.         if (c != null) {
  495.             if (c instanceof Window || c instanceof Applet) {
  496.                root = (Container)c;
  497.             } else {
  498.                 Container parent;
  499.                 for(parent = c.getParent() ; parent != null ; parent = parent.getParent()) {
  500.                     if (parent instanceof Window || parent instanceof Applet) {
  501.                         root = parent;
  502.                         break;
  503.                     }
  504.                 }
  505.             }
  506.         }
  507.  
  508.         if((c != null && !c.isShowing()) || root == null ||
  509.            !root.isShowing()) {
  510.             Dimension         paneSize = getSize();
  511.             Dimension         screenSize = getToolkit().getScreenSize();
  512.  
  513.             setLocation((screenSize.width - paneSize.width) / 2,
  514.                         (screenSize.height - paneSize.height) / 2);
  515.         } else {
  516.             Dimension           invokerSize = c.getSize();
  517.             Point               invokerScreenLocation = c.getLocationOnScreen();
  518.             Rectangle           dialogBounds = getBounds();
  519.             int                 dx = invokerScreenLocation.x+((invokerSize.width-dialogBounds.width)>>1);
  520.             int                 dy = invokerScreenLocation.y+((invokerSize.height - dialogBounds.height)>>1);
  521.             Dimension           ss = getToolkit().getScreenSize();
  522.  
  523.             if (dy+dialogBounds.height>ss.height) {
  524.                 dy = ss.height-dialogBounds.height;
  525.                 dx = invokerScreenLocation.x<(ss.width>>1) ? invokerScreenLocation.x+invokerSize.width :
  526.                     invokerScreenLocation.x-dialogBounds.width;
  527.             }
  528.             if (dx+dialogBounds.width>ss.width) dx = ss.width-dialogBounds.width;
  529.             if (dx<0) dx = 0;
  530.             if (dy<0) dy = 0;
  531.             setLocation(dx, dy);
  532.         }
  533.     }
  534.  
  535.  
  536. /////////////////
  537. // Accessibility support
  538. ////////////////
  539.  
  540.     protected AccessibleContext accessibleContext = null;
  541.  
  542.     /**
  543.      * Get the AccessibleContext associated with this JDialog
  544.      *
  545.      * @return the AccessibleContext of this JDialog
  546.      */
  547.     public AccessibleContext getAccessibleContext() {
  548.         if (accessibleContext == null) {
  549.             accessibleContext = new AccessibleJDialog();
  550.         }
  551.         return accessibleContext;
  552.     }
  553.  
  554.     /**
  555.      * The class used to obtain the AccessibleRole for this object.
  556.      */
  557.     protected class AccessibleJDialog extends AccessibleContext 
  558.         implements Serializable, AccessibleComponent {
  559.  
  560.         
  561.         // AccessibleContext methods
  562.         //
  563.         /**
  564.          * Get the accessible name of this object.  
  565.          *
  566.          * @return the localized name of the object -- can be null if this 
  567.          * object does not have a name
  568.          */
  569.         public String getAccessibleName() {
  570.             if (accessibleName != null) {
  571.                 return accessibleName;
  572.             } else {
  573.                 if (getTitle() == null) {
  574.                     return super.getAccessibleName();
  575.                 } else {
  576.                     return getTitle();
  577.                 }
  578.             }
  579.         }
  580.  
  581.         /**
  582.          * Get the role of this object.
  583.          *
  584.          * @return an instance of AccessibleRole describing the role of the 
  585.          * object
  586.          * @see AccessibleRole
  587.          */
  588.         public AccessibleRole getAccessibleRole() {
  589.             return AccessibleRole.DIALOG;
  590.         }
  591.  
  592.         /**
  593.          * Get the state of this object.
  594.          *
  595.          * @return an instance of AccessibleStateSet containing the current 
  596.          * state set of the object
  597.          * @see AccessibleState
  598.          */
  599.         public AccessibleStateSet getAccessibleStateSet() {
  600.             AccessibleStateSet states = SwingUtilities.getAccessibleStateSet(JDialog.this);
  601.             if (isResizable()) {
  602.                 states.add(AccessibleState.RESIZABLE);
  603.             }
  604.             if (getFocusOwner() != null) {
  605.                 states.add(AccessibleState.ACTIVE);
  606.             }
  607.             if (isModal()) {
  608.                 states.add(AccessibleState.MODAL);
  609.             }
  610.             return states;
  611.         }
  612.  
  613.         /**
  614.          * Get the Accessible parent of this object.  If the parent of this
  615.          * object implements Accessible, this method should simply return
  616.          * getParent().
  617.          *
  618.          * @return the Accessible parent of this object -- can be null if this
  619.          * object does not have an Accessible parent
  620.          */
  621.         public Accessible getAccessibleParent() {
  622.             Container parent = getParent();
  623.             if (parent instanceof Accessible) {
  624.                 return (Accessible) parent;
  625.             } else {
  626.                 return null;
  627.             }
  628.         }
  629.  
  630.         /**
  631.          * Get the index of this object in its accessible parent. 
  632.          *
  633.          * @return the index of this object in its parent; -1 if this 
  634.          * object does not have an accessible parent.
  635.          * @see #getAccessibleParent
  636.          */
  637.         public int getAccessibleIndexInParent() {
  638.             return SwingUtilities.getAccessibleIndexInParent(JDialog.this);
  639.         }
  640.  
  641.         /**
  642.          * Returns the number of accessible children in the object.  If all
  643.          * of the children of this object implement Accessible, than this
  644.          * method should return the number of children of this object.
  645.          *
  646.          * @return the number of accessible children in the object.
  647.          */
  648.         public int getAccessibleChildrenCount() {
  649.             return SwingUtilities.getAccessibleChildrenCount(JDialog.this);
  650.         }
  651.  
  652.         /**
  653.          * Return the nth Accessible child of the object.  
  654.          *
  655.          * @param i zero-based index of child
  656.          * @return the nth Accessible child of the object
  657.          */
  658.         public Accessible getAccessibleChild(int i) {
  659.             return SwingUtilities.getAccessibleChild(JDialog.this,i);
  660.         }
  661.  
  662.         /**
  663.          * Return the locale of this object.
  664.          *
  665.          * @return the locale of this object
  666.          */
  667.         public Locale getLocale() {
  668.             return JDialog.this.getLocale();
  669.         }
  670.  
  671.         /**
  672.          * Get the AccessibleComponent associated with this object if one
  673.          * exists.  Otherwise return null.
  674.          */
  675.         public AccessibleComponent getAccessibleComponent() {
  676.             return this;
  677.         }
  678.  
  679.  
  680.         // AccessibleComponent methods
  681.         //
  682.         /**
  683.          * Get the background color of this object.
  684.          *
  685.          * @return the background color, if supported, of the object; 
  686.          * otherwise, null
  687.          */
  688.         public Color getBackground() {
  689.             return JDialog.this.getBackground();
  690.         }
  691.  
  692.         /**
  693.          * Set the background color of this object.
  694.          *
  695.          * @param c the new Color for the background
  696.          */
  697.         public void setBackground(Color c) {
  698.             JDialog.this.setBackground(c);
  699.         }
  700.  
  701.         /**
  702.          * Get the foreground color of this object.
  703.          *
  704.          * @return the foreground color, if supported, of the object; 
  705.          * otherwise, null
  706.          */
  707.         public Color getForeground() {
  708.             return JDialog.this.getForeground();
  709.         }
  710.  
  711.         /**
  712.          * Set the foreground color of this object.
  713.          *
  714.          * @param c the new Color for the foreground
  715.          */
  716.         public void setForeground(Color c) {
  717.             JDialog.this.setForeground(c);
  718.         }
  719.  
  720.         /**
  721.          * Get the Cursor of this object.
  722.          *
  723.          * @return the Cursor, if supported, of the object; otherwise, null
  724.          */
  725.         public Cursor getCursor() {
  726.             return JDialog.this.getCursor();
  727.         }
  728.  
  729.         /**
  730.          * Set the Cursor of this object.
  731.          *
  732.          * @param c the new Cursor for the object
  733.          */
  734.         public void setCursor(Cursor cursor) {
  735.             JDialog.this.setCursor(cursor);
  736.         }
  737.  
  738.         /**
  739.          * Get the Font of this object.
  740.          *
  741.          * @return the Font,if supported, for the object; otherwise, null
  742.          */
  743.         public Font getFont() {
  744.             return JDialog.this.getFont();
  745.         }
  746.  
  747.         /**
  748.          * Set the Font of this object.
  749.          *
  750.          * @param f the new Font for the object
  751.          */
  752.         public void setFont(Font f) {
  753.             JDialog.this.setFont(f);
  754.         }
  755.  
  756.         /**
  757.          * Get the FontMetrics of this object.
  758.          *
  759.          * @param f the Font
  760.          * @return the FontMetrics, if supported, the object; otherwise, null
  761.          * @see getFont
  762.          */
  763.         public FontMetrics getFontMetrics(Font f) {
  764.             return JDialog.this.getFontMetrics(f);
  765.         }
  766.  
  767.         /**
  768.          * Determine if the object is enabled.
  769.          *
  770.          * @return true if object is enabled; otherwise, false
  771.          */
  772.         public boolean isEnabled() {
  773.             return JDialog.this.isEnabled();
  774.         }
  775.  
  776.         /**
  777.          * Set the enabled state of the object.
  778.          *
  779.          * @param b if true, enables this object; otherwise, disables it 
  780.          */
  781.         public void setEnabled(boolean b) {
  782.             JDialog.this.setEnabled(b);
  783.         }
  784.         
  785.         /**
  786.          * Determine if the object is visible.  Note: this means that the
  787.          * object intends to be visible; however, it may not in fact be
  788.          * showing on the screen because one of the objects that this object
  789.          * is contained by is not visible.  To determine if an object is
  790.          * showing on the screen, use isShowing().
  791.          *
  792.          * @return true if object is visible; otherwise, false
  793.          */
  794.         public boolean isVisible() {
  795.             return JDialog.this.isVisible();
  796.         }
  797.  
  798.         /**
  799.          * Set the visible state of the object.
  800.          *
  801.          * @param b if true, shows this object; otherwise, hides it 
  802.          */
  803.         public void setVisible(boolean b) {
  804.             JDialog.this.setVisible(b);
  805.         }
  806.  
  807.         /**
  808.          * Determine if the object is showing. This is determined by checking
  809.          * the visibility of the object and ancestors of the object.  Note: 
  810.          * this will return true even if the object is obscured by another 
  811.          * (for example, it happens to be underneath a menu that was pulled 
  812.          * down).
  813.          *
  814.          * @return true if object is showing; otherwise, false
  815.          */
  816.         public boolean isShowing() {
  817.             return JDialog.this.isShowing();
  818.         }
  819.  
  820.         /** 
  821.          * Checks whether the specified point is within this object's bounds,
  822.          * where the point's x and y coordinates are defined to be relative to 
  823.          * the coordinate system of the object. 
  824.          *
  825.          * @param p the Point relative to the coordinate system of the object
  826.          * @return true if object contains Point; otherwise false
  827.          */
  828.         public boolean contains(Point p) {
  829.             return JDialog.this.contains(p);
  830.         }
  831.     
  832.         /** 
  833.          * Returns the location of the object on the screen.
  834.          *
  835.          * @return location of object on screen -- can be null if this object
  836.          * is not on the screen
  837.          */
  838.         public Point getLocationOnScreen() {
  839.             return JDialog.this.getLocationOnScreen();
  840.         }
  841.  
  842.         /** 
  843.          * Gets the location of the object relative to the parent in the form 
  844.          * of a point specifying the object's top-left corner in the screen's 
  845.          * coordinate space.
  846.          *
  847.          * @return An instance of Point representing the top-left corner of 
  848.          * the objects's bounds in the coordinate space of the screen; null if
  849.          * this object or its parent are not on the screen
  850.          */
  851.         public Point getLocation() {
  852.             return JDialog.this.getLocation();
  853.         }
  854.  
  855.         /** 
  856.          * Sets the location of the object relative to the parent.
  857.          */
  858.         public void setLocation(Point p) {
  859.             JDialog.this.setLocation(p);
  860.         }
  861.  
  862.         /** 
  863.          * Gets the bounds of this object in the form of a Rectangle object. 
  864.          * The bounds specify this object's width, height, and location
  865.          * relative to its parent. 
  866.          *
  867.          * @return A rectangle indicating this component's bounds; null if 
  868.          * this object is not on the screen.
  869.          */
  870.         public Rectangle getBounds() {
  871.             return JDialog.this.getBounds();
  872.         }
  873.  
  874.         /** 
  875.          * Sets the bounds of this object in the form of a Rectangle object. 
  876.          * The bounds specify this object's width, height, and location
  877.          * relative to its parent.
  878.          *      
  879.          * @param A rectangle indicating this component's bounds
  880.          */
  881.         public void setBounds(Rectangle r) {
  882.             JDialog.this.setBounds(r);
  883.         }
  884.  
  885.         /** 
  886.          * Returns the size of this object in the form of a Dimension object. 
  887.          * The height field of the Dimension object contains this objects's
  888.          * height, and the width field of the Dimension object contains this 
  889.          * object's width. 
  890.          *
  891.          * @return A Dimension object that indicates the size of this 
  892.          * component; null if this object is not on the screen
  893.          */
  894.         public Dimension getSize() {
  895.             return JDialog.this.getSize();
  896.         }
  897.  
  898.         /** 
  899.          * Resizes this object so that it has width width and height. 
  900.          *      
  901.          * @param d - The dimension specifying the new size of the object. 
  902.          */
  903.         public void setSize(Dimension d) {
  904.             JDialog.this.setSize(d);
  905.         }
  906.  
  907.         /**
  908.          * Returns the Accessible child, if one exists, contained at the local
  909.          * coordinate Point.
  910.          *
  911.          * @param p The point defining the top-left corner of the Accessible, 
  912.          * given in the coordinate space of the object's parent. 
  913.          * @return the Accessible, if it exists, at the specified location; 
  914.          * else null
  915.          */
  916.         public Accessible getAccessibleAt(Point p) {
  917.             return SwingUtilities.getAccessibleAt(JDialog.this,p);
  918.         }
  919.  
  920.         /**
  921.          * Returns whether this object can accept focus or not.
  922.          *
  923.          * @return true if object can accept focus; otherwise false
  924.          */
  925.         public boolean isFocusTraversable() {
  926.             return JDialog.this.isFocusTraversable();
  927.         }
  928.  
  929.         /**
  930.          * Requests focus for this object.
  931.          */
  932.         public void requestFocus() {
  933.             JDialog.this.requestFocus();
  934.         }
  935.  
  936.         /**
  937.          * Adds the specified focus listener to receive focus events from this 
  938.          * component. 
  939.          *
  940.          * @param l the focus listener
  941.          */
  942.         public void addFocusListener(FocusListener l) {
  943.             JDialog.this.addFocusListener(l);
  944.         }
  945.  
  946.         /**
  947.          * Removes the specified focus listener so it no longer receives focus 
  948.          * events from this component.
  949.          *
  950.          * @param l the focus listener
  951.          */
  952.         public void removeFocusListener(FocusListener l) {
  953.             JDialog.this.removeFocusListener(l);
  954.         }
  955.     } // inner class AccessibleJDialog
  956. }
  957.