Source for javax.swing.JFrame

   1: /*
   2:  * @(#)JFrame.java    1.104 03/12/19
   3:  *
   4:  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
   5:  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
   6:  */
   7: package javax.swing;
   8: 
   9: import java.awt.*;
  10: import java.awt.event.*;
  11: import java.beans.PropertyChangeListener;
  12: import java.util.Locale;
  13: import java.util.Vector;
  14: import java.io.Serializable;
  15: 
  16: import javax.accessibility.*;
  17: 
  18: 
  19: /**
  20:  * An extended version of <code>java.awt.Frame</code> that adds support for 
  21:  * the JFC/Swing component architecture.
  22:  * You can find task-oriented documentation about using <code>JFrame</code>
  23:  * in <em>The Java Tutorial</em>, in the section
  24:  * <a
  25:  href="http://java.sun.com/docs/books/tutorial/uiswing/components/frame.html">How to Make Frames</a>.
  26:  * 
  27:  * <p>
  28:  * The <code>JFrame</code> class is slightly incompatible with <code>Frame</code>.
  29:  * Like all other JFC/Swing top-level containers,
  30:  * a <code>JFrame</code> contains a <code>JRootPane</code> as its only child.
  31:  * The <b>content pane</b> provided by the root pane should,
  32:  * as a rule, contain
  33:  * all the non-menu components displayed by the <code>JFrame</code>.
  34:  * This is different from the AWT <code>Frame</code> case.  
  35:  * As a conveniance <code>add</code> and its variants, <code>remove</code> and
  36:  * <code>setLayout</code> have been overridden to forward to the
  37:  * <code>contentPane</code> as necessary. This means you can write:
  38:  * <pre>
  39:  *       frame.add(child);
  40:  * </pre>
  41:  * And the child will be added to the contentPane.
  42:  * The content pane will
  43:  * always be non-null. Attempting to set it to null will cause the JFrame
  44:  * to throw an exception. The default content pane will have a BorderLayout
  45:  * manager set on it. 
  46:  * Refer to {@link javax.swing.RootPaneContainer}
  47:  * for details on adding, removing and setting the <code>LayoutManager</code>
  48:  * of a <code>JFrame</code>.
  49:  * <p>
  50:  * Unlike a <code>Frame</code>, a <code>JFrame</code> has some notion of how to 
  51:  * respond when the user attempts to close the window. The default behavior
  52:  * is to simply hide the JFrame when the user closes the window. To change the
  53:  * default behavior, you invoke the method
  54:  * {@link #setDefaultCloseOperation}.
  55:  * To make the <code>JFrame</code> behave the same as a <code>Frame</code>
  56:  * instance, use
  57:  * <code>setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE)</code>.
  58:  * <p>
  59:  * For more information on content panes
  60:  * and other features that root panes provide,
  61:  * see <a
  62:  href="http://java.sun.com/docs/books/tutorial/uiswing/components/toplevel.html">Using Top-Level Containers</a> in <em>The Java Tutorial</em>.
  63:  * <p>
  64:  * In a multi-screen environment, you can create a <code>JFrame</code>
  65:  * on a different screen device.  See {@link java.awt.Frame} for more
  66:  * information.
  67:  * <p>
  68:  * <strong>Warning:</strong>
  69:  * Serialized objects of this class will not be compatible with
  70:  * future Swing releases. The current serialization support is
  71:  * appropriate for short term storage or RMI between applications running
  72:  * the same version of Swing.  As of 1.4, support for long term storage
  73:  * of all JavaBeans<sup><font size="-2">TM</font></sup>
  74:  * has been added to the <code>java.beans</code> package.
  75:  * Please see {@link java.beans.XMLEncoder}.
  76:  *
  77:  * @see JRootPane
  78:  * @see #setDefaultCloseOperation
  79:  * @see java.awt.event.WindowListener#windowClosing
  80:  * @see javax.swing.RootPaneContainer
  81:  *
  82:  * @beaninfo
  83:  *      attribute: isContainer true
  84:  *      attribute: containerDelegate getContentPane
  85:  *    description: A toplevel window which can be minimized to an icon.
  86:  *
  87:  * @version 1.104 12/19/03
  88:  * @author Jeff Dinkins
  89:  * @author Georges Saab
  90:  * @author David Kloba
  91:  */
  92: public class JFrame  extends Frame implements WindowConstants, Accessible, RootPaneContainer
  93:	  {
  94:    /**
  95:     * The exit application default window close operation. If a window
  96:     * has this set as the close operation and is closed in an applet,
  97:     * a <code>SecurityException</code> may be thrown.
  98:     * It is recommended you only use this in an application.
  99:     * <p>
 100:     * @since 1.3
 101:     */
 102:    public static final int EXIT_ON_CLOSE = 3;
 103:
 104:    /**
 105:     * Key into the AppContext, used to check if should provide decorations
 106:     * by default.
 107:     */
 108:    private static final Object defaultLookAndFeelDecoratedKey = 
 109:            new StringBuffer("JFrame.defaultLookAndFeelDecorated");
 110:
 111:    private int defaultCloseOperation = HIDE_ON_CLOSE;
 112:
 113:    /**
 114:     * The <code>JRootPane</code> instance that manages the
 115:     * <code>contentPane</code> 
 116:     * and optional <code>menuBar</code> for this frame, as well as the 
 117:     * <code>glassPane</code>.
 118:     *
 119:     * @see JRootPane
 120:     * @see RootPaneContainer
 121:     */
 122:    protected JRootPane rootPane;
 123:
 124:    /**
 125:     * If true then calls to <code>add</code> and <code>setLayout</code>
 126:     * will be forwarded to the <code>contentPane</code>. This is initially
 127:     * false, but is set to true when the <code>JFrame</code> is constructed.
 128:     *
 129:     * @see #isRootPaneCheckingEnabled
 130:     * @see #setRootPaneCheckingEnabled
 131:     * @see javax.swing.RootPaneContainer
 132:     */
 133:    protected boolean rootPaneCheckingEnabled = false;
 134:
 135:
 136:    /**
 137:     * Constructs a new frame that is initially invisible.
 138:     * <p>
 139:     * This constructor sets the component's locale property to the value 
 140:     * returned by <code>JComponent.getDefaultLocale</code>.
 141:     *
 142:     * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 143:     * returns true.
 144:     * @see java.awt.GraphicsEnvironment#isHeadless
 145:     * @see Component#setSize
 146:     * @see Component#setVisible
 147:     * @see JComponent#getDefaultLocale
 148:     */
 149:	      public JFrame() throws HeadlessException {
 150:        super();        
 151:        frameInit();
 152:    }
 153:
 154:    /**
 155:     * Creates a <code>Frame</code> in the specified
 156:     * <code>GraphicsConfiguration</code> of
 157:     * a screen device and a blank title.
 158:     * <p>
 159:     * This constructor sets the component's locale property to the value 
 160:     * returned by <code>JComponent.getDefaultLocale</code>.
 161:     *
 162:     * @param gc the <code>GraphicsConfiguration</code> that is used
 163:     *         to construct the new <code>Frame</code>;
 164:     *         if <code>gc</code> is <code>null</code>, the system
 165:     *         default <code>GraphicsConfiguration</code> is assumed
 166:     * @exception IllegalArgumentException if <code>gc</code> is not from
 167:     *         a screen device.  This exception is always thrown when
 168:     *      GraphicsEnvironment.isHeadless() returns true.
 169:     * @see java.awt.GraphicsEnvironment#isHeadless
 170:     * @see JComponent#getDefaultLocale
 171:     * @since     1.3
 172:     */
 173:	      public JFrame(GraphicsConfiguration gc) {
 174:        super(gc);
 175:        frameInit();
 176:    }
 177:
 178:    /**
 179:     * Creates a new, initially invisible <code>Frame</code> with the 
 180:     * specified title.
 181:     * <p>
 182:     * This constructor sets the component's locale property to the value 
 183:     * returned by <code>JComponent.getDefaultLocale</code>.
 184:     *
 185:     * @param title the title for the frame
 186:     * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 187:     * returns true.
 188:     * @see java.awt.GraphicsEnvironment#isHeadless
 189:     * @see Component#setSize
 190:     * @see Component#setVisible
 191:     * @see JComponent#getDefaultLocale
 192:     */
 193:	      public JFrame(String title) throws HeadlessException {
 194:        super(title);
 195:        frameInit();
 196:    }
 197:    
 198:    /**
 199:     * Creates a <code>JFrame</code> with the specified title and the
 200:     * specified <code>GraphicsConfiguration</code> of a screen device.
 201:     * <p>
 202:     * This constructor sets the component's locale property to the value 
 203:     * returned by <code>JComponent.getDefaultLocale</code>.
 204:     *
 205:     * @param title the title to be displayed in the
 206:     *         frame's border. A <code>null</code> value is treated as
 207:     *         an empty string, "".
 208:     * @param gc the <code>GraphicsConfiguration</code> that is used
 209:     *         to construct the new <code>JFrame</code> with;
 210:     *        if <code>gc</code> is <code>null</code>, the system
 211:     *         default <code>GraphicsConfiguration</code> is assumed
 212:     * @exception IllegalArgumentException if <code>gc</code> is not from
 213:     *         a screen device.  This exception is always thrown when
 214:     *      GraphicsEnvironment.isHeadless() returns true.
 215:     * @see java.awt.GraphicsEnvironment#isHeadless
 216:     * @see JComponent#getDefaultLocale
 217:     * @since     1.3
 218:     */
 219:	      public JFrame(String title, GraphicsConfiguration gc) {
 220:        super(title, gc);
 221:        frameInit();
 222:    }
 223:
 224:    /** Called by the constructors to init the <code>JFrame</code> properly. */
 225:	      protected void frameInit() {
 226:        enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.WINDOW_EVENT_MASK);
 227:        setLocale( JComponent.getDefaultLocale() );
 228:        setRootPane(createRootPane());
 229:        setBackground(UIManager.getColor("control"));
 230:        setRootPaneCheckingEnabled(true);
 231:	          if (JFrame.isDefaultLookAndFeelDecorated()) {
 232:            boolean supportsWindowDecorations = 
 233:            UIManager.getLookAndFeel().getSupportsWindowDecorations();
 234:	              if (supportsWindowDecorations) {
 235:                setUndecorated(true);
 236:                getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
 237:            }
 238:        }
 239:        sun.awt.SunToolkit.checkAndSetPolicy(this, true);
 240:    }
 241:
 242:    /**
 243:     * Called by the constructor methods to create the default
 244:     * <code>rootPane</code>.
 245:     */
 246:	      protected JRootPane createRootPane() {
 247:        JRootPane rp = new JRootPane();
 248:        // NOTE: this uses setOpaque vs LookAndFeel.installProperty as there
 249:        // is NO reason for the RootPane not to be opaque. For painting to
 250:        // work the contentPane must be opaque, therefor the RootPane can
 251:        // also be opaque.
 252:        rp.setOpaque(true);
 253:        return rp;
 254:    }
 255: 
 256:    /** 
 257:     * Processes window events occurring on this component.
 258:     * Hides the window or disposes of it, as specified by the setting
 259:     * of the <code>defaultCloseOperation</code> property.
 260:     *
 261:     * @param  e  the window event
 262:     * @see    #setDefaultCloseOperation
 263:     * @see    java.awt.Window#processWindowEvent
 264:     */
 265:	      protected void processWindowEvent(WindowEvent e) {
 266:        super.processWindowEvent(e);
 267:
 268:	          if (e.getID() == WindowEvent.WINDOW_CLOSING) {
 269:	              switch(defaultCloseOperation) {
 270:              case HIDE_ON_CLOSE:
 271:                 setVisible(false);
 272:                 break;
 273:              case DISPOSE_ON_CLOSE:
 274:                 setVisible(false);
 275:                 dispose();
 276:                 break;
 277:              case DO_NOTHING_ON_CLOSE:
 278:                 default: 
 279:                 break;
 280:          case EXIT_ON_CLOSE:
 281:                  // This needs to match the checkExit call in
 282:                  // setDefaultCloseOperation
 283:        System.exit(0);
 284:        break;
 285:            }
 286:        }
 287:    }
 288:
 289:	  //    public void setMenuBar(MenuBar menu) {  
 290://        throw new IllegalComponentStateException("Please use setJMenuBar() with JFrame.");
 291://    }
 292:
 293:    /**                   
 294:     * Sets the operation that will happen by default when
 295:     * the user initiates a "close" on this frame.
 296:     * You must specify one of the following choices:
 297:     * <p>
 298:     * <ul>
 299:     * <li><code>DO_NOTHING_ON_CLOSE</code>
 300:     * (defined in <code>WindowConstants</code>):
 301:     * Don't do anything; require the
 302:     * program to handle the operation in the <code>windowClosing</code>
 303:     * method of a registered <code>WindowListener</code> object.
 304:     *
 305:     * <li><code>HIDE_ON_CLOSE</code>
 306:     * (defined in <code>WindowConstants</code>):
 307:     * Automatically hide the frame after
 308:     * invoking any registered <code>WindowListener</code>
 309:     * objects.
 310:     *
 311:     * <li><code>DISPOSE_ON_CLOSE</code>
 312:     * (defined in <code>WindowConstants</code>):
 313:     * Automatically hide and dispose the 
 314:     * frame after invoking any registered <code>WindowListener</code>
 315:     * objects.
 316:     *
 317:     * <li><code>EXIT_ON_CLOSE</code>
 318:     * (defined in <code>JFrame</code>):
 319:     * Exit the application using the <code>System</code>
 320:     * <code>exit</code> method.  Use this only in applications.
 321:     * </ul>
 322:     * <p>
 323:     * The value is set to <code>HIDE_ON_CLOSE</code> by default.
 324:     * <p>
 325:     * <b>Note</b>: When the last displayable window within the
 326:     * Java virtual machine (VM) is disposed of, the VM may
 327:     * terminate.  See <a href="../../java/awt/doc-files/AWTThreadIssues.html">
 328:     * AWT Threading Issues</a> for more information.
 329:     *
 330:     * @param operation the operation which should be performed when the
 331:     *        user closes the frame
 332:     * @exception IllegalArgumentException if defaultCloseOperation value 
 333:     *             isn't one of the above valid values
 334:     * @see #addWindowListener
 335:     * @see #getDefaultCloseOperation
 336:     * @see WindowConstants
 337:     * @throws  SecurityException
 338:     *        if <code>EXIT_ON_CLOSE</code> has been specified and the
 339:     *        <code>SecurityManager</code> will
 340:     *        not allow the caller to invoke <code>System.exit</code>
 341:     * @see        java.lang.Runtime#exit(int)
 342:     *
 343:     * @beaninfo
 344:     *   preferred: true
 345:     *       bound: true
 346:     *        enum: DO_NOTHING_ON_CLOSE WindowConstants.DO_NOTHING_ON_CLOSE
 347:     *              HIDE_ON_CLOSE       WindowConstants.HIDE_ON_CLOSE
 348:     *              DISPOSE_ON_CLOSE    WindowConstants.DISPOSE_ON_CLOSE
 349:     *              EXIT_ON_CLOSE       WindowConstants.EXIT_ON_CLOSE
 350:     * description: The frame's default close operation.
 351:     */
 352:	      public void setDefaultCloseOperation(int operation) {
 353:    if (operation != DO_NOTHING_ON_CLOSE &&
 354:        operation != HIDE_ON_CLOSE &&
 355:        operation != DISPOSE_ON_CLOSE &&
 356:	          operation != EXIT_ON_CLOSE) {
 357:            throw new IllegalArgumentException("defaultCloseOperation must be one of: DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, DISPOSE_ON_CLOSE, or EXIT_ON_CLOSE");
 358:    }
 359:	          if (this.defaultCloseOperation != operation) {
 360:	              if (operation == EXIT_ON_CLOSE) {
 361:                SecurityManager security = System.getSecurityManager();
 362:	                  if (security != null) {
 363:                    security.checkExit(0);
 364:                }
 365:            }
 366:            int oldValue = this.defaultCloseOperation;
 367:            this.defaultCloseOperation = operation;
 368:            firePropertyChange("defaultCloseOperation", oldValue, operation);
 369:    }
 370:    }
 371:
 372:
 373:   /**
 374:    * Returns the operation that occurs when the user
 375:    * initiates a "close" on this frame.
 376:    *
 377:    * @return an integer indicating the window-close operation
 378:    * @see #setDefaultCloseOperation
 379:    */
 380:	      public int getDefaultCloseOperation() {
 381:        return defaultCloseOperation;
 382:    }
 383:
 384:
 385:    /** 
 386:     * Just calls <code>paint(g)</code>.  This method was overridden to 
 387:     * prevent an unnecessary call to clear the background.
 388:     *
 389:     * @param g the Graphics context in which to paint
 390:     */
 391:	      public void update(Graphics g) {
 392:        paint(g);
 393:    }
 394:
 395:   /**
 396:    * Sets the menubar for this frame.
 397:    * @param menubar the menubar being placed in the frame
 398:    *
 399:    * @see #getJMenuBar
 400:    *
 401:    * @beaninfo
 402:    *      hidden: true
 403:    * description: The menubar for accessing pulldown menus from this frame.
 404:    */
 405:	      public void setJMenuBar(JMenuBar menubar) {
 406:        getRootPane().setMenuBar(menubar);
 407:    }
 408:
 409:   /**
 410:    * Returns the menubar set on this frame.
 411:    * @return the menubar for this frame
 412:    *
 413:    * @see #setJMenuBar
 414:    */
 415:	      public JMenuBar getJMenuBar() { 
 416:        return getRootPane().getMenuBar(); 
 417:    }
 418:
 419:    /**
 420:     * Returns whether calls to <code>add</code> and 
 421:     * <code>setLayout</code> are forwarded to the <code>contentPane</code>.
 422:     *
 423:     * @return true if <code>add</code> and <code>setLayout</code> 
 424:     *         are fowarded; false otherwise
 425:     *
 426:     * @see #addImpl
 427:     * @see #setLayout
 428:     * @see #setRootPaneCheckingEnabled
 429:     * @see javax.swing.RootPaneContainer
 430:     */
 431:	      protected boolean isRootPaneCheckingEnabled() {
 432:        return rootPaneCheckingEnabled;
 433:    }
 434:
 435:
 436:    /**
 437:     * Sets whether calls to <code>add</code> and 
 438:     * <code>setLayout</code> are forwarded to the <code>contentPane</code>.
 439:     * 
 440:     * @param enabled  true if <code>add</code> and <code>setLayout</code>
 441:     *        are forwarded, false if they should operate directly on the
 442:     *        <code>JFrame</code>.
 443:     *
 444:     * @see #addImpl
 445:     * @see #setLayout
 446:     * @see #isRootPaneCheckingEnabled
 447:     * @see javax.swing.RootPaneContainer
 448:     * @beaninfo
 449:     *      hidden: true
 450:     * description: Whether the add and setLayout methods are forwarded
 451:     */
 452:	      protected void setRootPaneCheckingEnabled(boolean enabled) {
 453:        rootPaneCheckingEnabled = enabled;
 454:    }
 455:
 456:
 457:    /**
 458:     * Adds the specified child <code>Component</code>.
 459:     * This method is overridden to conditionally forwad calls to the
 460:     * <code>contentPane</code>.
 461:     * By default, children are added to the <code>contentPane</code> instead
 462:     * of the frame, refer to {@link javax.swing.RootPaneContainer} for
 463:     * details.
 464:     * 
 465:     * @param comp the component to be enhanced
 466:     * @param constraints the constraints to be respected
 467:     * @param index the index
 468:     * @exception IllegalArgumentException if <code>index</code> is invalid
 469:     * @exception IllegalArgumentException if adding the container's parent
 470:     *            to itself
 471:     * @exception IllegalArgumentException if adding a window to a container
 472:     * 
 473:     * @see #setRootPaneCheckingEnabled
 474:     * @see javax.swing.RootPaneContainer
 475:     */
 476:    protected void addImpl(Component comp, Object constraints, int index) 
 477:	      {
 478:	          if(isRootPaneCheckingEnabled()) {
 479:            getContentPane().add(comp, constraints, index);
 480:        }
 481:	          else {
 482:            super.addImpl(comp, constraints, index);
 483:        }
 484:    }
 485:
 486:    /** 
 487:     * Removes the specified component from the container. If
 488:     * <code>comp</code> is not the <code>rootPane</code>, this will forward
 489:     * the call to the <code>contentPane</code>. This will do nothing if
 490:     * <code>comp</code> is not a child of the <code>JFrame</code> or
 491:     * <code>contentPane</code>.
 492:     *
 493:     * @param comp the component to be removed
 494:     * @throws NullPointerException if <code>comp</code> is null
 495:     * @see #add
 496:     * @see javax.swing.RootPaneContainer
 497:     */
 498:	      public void remove(Component comp) {
 499:	      if (comp == rootPane) {
 500:        super.remove(comp);
 501:    } else {
 502:        getContentPane().remove(comp);
 503:    }
 504:    }
 505:
 506:
 507:    /**
 508:     * Sets the <code>LayoutManager</code>.
 509:     * Overridden to conditionally forward the call to the
 510:     * <code>contentPane</code>.
 511:     * Refer to {@link javax.swing.RootPaneContainer} for
 512:     * more information.
 513:     *
 514:     * @param manager the <code>LayoutManager</code>
 515:     * @see #setRootPaneCheckingEnabled
 516:     * @see javax.swing.RootPaneContainer
 517:     */
 518:	      public void setLayout(LayoutManager manager) {
 519:	          if(isRootPaneCheckingEnabled()) {
 520:            getContentPane().setLayout(manager);
 521:        }
 522:	          else {
 523:            super.setLayout(manager);
 524:        }
 525:    }
 526:
 527:
 528:    /**
 529:     * Returns the <code>rootPane</code> object for this frame.
 530:     * @return the <code>rootPane</code> property
 531:     *
 532:     * @see #setRootPane
 533:     * @see RootPaneContainer#getRootPane
 534:     */
 535:	      public JRootPane getRootPane() { 
 536:        return rootPane; 
 537:    }
 538:
 539:
 540:    /**
 541:     * Sets the <code>rootPane</code> property. 
 542:     * This method is called by the constructor.
 543:     * @param root the <code>rootPane</code> object for this frame
 544:     *
 545:     * @see #getRootPane
 546:     *
 547:     * @beaninfo
 548:     *   hidden: true
 549:     * description: the RootPane object for this frame.
 550:     */
 551:    protected void setRootPane(JRootPane root) 
 552:	      {
 553:	          if(rootPane != null) {
 554:            remove(rootPane);
 555:        }
 556:        rootPane = root;
 557:	          if(rootPane != null) {
 558:            boolean checkingEnabled = isRootPaneCheckingEnabled();
 559:	              try {
 560:                setRootPaneCheckingEnabled(false);
 561:                add(rootPane, BorderLayout.CENTER);
 562:            }
 563:	              finally {
 564:                setRootPaneCheckingEnabled(checkingEnabled);
 565:            }
 566:        }
 567:    }
 568:
 569:	      public void setIconImage(Image image) {
 570:        Image oldImage = getIconImage();
 571:        super.setIconImage(image);
 572:        firePropertyChange("iconImage", oldImage, image);
 573:    }
 574:
 575:    /**
 576:     * Returns the <code>contentPane</code> object for this frame.
 577:     * @return the <code>contentPane</code> property
 578:     *
 579:     * @see #setContentPane
 580:     * @see RootPaneContainer#getContentPane
 581:     */
 582:	      public Container getContentPane() { 
 583:        return getRootPane().getContentPane(); 
 584:    }
 585:
 586:    /**
 587:     * Sets the <code>contentPane</code> property. 
 588:     * This method is called by the constructor.
 589:     * <p>
 590:     * Swing's painting architecture requires an opaque <code>JComponent</code>
 591:     * in the containment hiearchy. This is typically provided by the
 592:     * content pane. If you replace the content pane it is recommended you
 593:     * replace it with an opaque <code>JComponent</code>.
 594:     *
 595:     * @param contentPane the <code>contentPane</code> object for this frame
 596:     *
 597:     * @exception java.awt.IllegalComponentStateException (a runtime
 598:     *            exception) if the content pane parameter is <code>null</code>
 599:     * @see #getContentPane
 600:     * @see RootPaneContainer#setContentPane
 601:     * @see JRootPane
 602:     *
 603:     * @beaninfo
 604:     *     hidden: true
 605:     *     description: The client area of the frame where child 
 606:     *                  components are normally inserted.
 607:     */
 608:	      public void setContentPane(Container contentPane) {
 609:        getRootPane().setContentPane(contentPane);
 610:    }
 611:
 612:    /**
 613:     * Returns the <code>layeredPane</code> object for this frame.
 614:     * @return the <code>layeredPane</code> property
 615:     *
 616:     * @see #setLayeredPane
 617:     * @see RootPaneContainer#getLayeredPane
 618:     */
 619:	      public JLayeredPane getLayeredPane() { 
 620:        return getRootPane().getLayeredPane(); 
 621:    }
 622:
 623:    /**
 624:     * Sets the <code>layeredPane</code> property.
 625:     * This method is called by the constructor.
 626:     * @param layeredPane the <code>layeredPane</code> object for this frame
 627:     *
 628:     * @exception java.awt.IllegalComponentStateException (a runtime
 629:     *            exception) if the layered pane parameter is <code>null</code>
 630:     * @see #getLayeredPane
 631:     * @see RootPaneContainer#setLayeredPane
 632:     *
 633:     * @beaninfo
 634:     *     hidden: true
 635:     *     description: The pane that holds the various frame layers.
 636:     */
 637:	      public void setLayeredPane(JLayeredPane layeredPane) {
 638:        getRootPane().setLayeredPane(layeredPane);
 639:    }
 640:
 641:    /**
 642:     * Returns the <code>glassPane</code> object for this frame.
 643:     * @return the <code>glassPane</code> property
 644:     *
 645:     * @see #setGlassPane
 646:     * @see RootPaneContainer#getGlassPane
 647:     */
 648:	      public Component getGlassPane() { 
 649:        return getRootPane().getGlassPane(); 
 650:    }
 651:
 652:    /**
 653:     * Sets the <code>glassPane</code> property. 
 654:     * This method is called by the constructor.
 655:     * @param glassPane the <code>glassPane</code> object for this frame
 656:     *
 657:     * @see #getGlassPane
 658:     * @see RootPaneContainer#setGlassPane
 659:     *
 660:     * @beaninfo
 661:     *     hidden: true
 662:     *     description: A transparent pane used for menu rendering.
 663:     */
 664:	      public void setGlassPane(Component glassPane) {
 665:        getRootPane().setGlassPane(glassPane);
 666:    }
 667:
 668:    /**
 669:     * Provides a hint as to whether or not newly created <code>JFrame</code>s
 670:     * should have their Window decorations (such as borders, widgets to
 671:     * close the window, title...) provided by the current look
 672:     * and feel. If <code>defaultLookAndFeelDecorated</code> is true,
 673:     * the current <code>LookAndFeel</code> supports providing window
 674:     * decorations, and the current window manager supports undecorated
 675:     * windows, then newly created <code>JFrame</code>s will have their
 676:     * Window decorations provided by the current <code>LookAndFeel</code>.
 677:     * Otherwise, newly created <code>JFrame</code>s will have their
 678:     * Window decorations provided by the current window manager.
 679:     * <p>
 680:     * You can get the same effect on a single JFrame by doing the following:
 681:     * <pre>
 682:     *    JFrame frame = new JFrame();
 683:     *    frame.setUndecorated(true);
 684:     *    frame.getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
 685:     * </pre>
 686:     *
 687:     * @param defaultLookAndFeelDecorated A hint as to whether or not current
 688:     *        look and feel should provide window decorations
 689:     * @see javax.swing.LookAndFeel#getSupportsWindowDecorations
 690:     * @since 1.4
 691:     */
 692:	      public static void setDefaultLookAndFeelDecorated(boolean defaultLookAndFeelDecorated) {
 693:	          if (defaultLookAndFeelDecorated) {
 694:            SwingUtilities.appContextPut(defaultLookAndFeelDecoratedKey, Boolean.TRUE);
 695:        } else {
 696:            SwingUtilities.appContextPut(defaultLookAndFeelDecoratedKey, Boolean.FALSE);
 697:        }
 698:    }
 699:
 700:
 701:    /**
 702:     * Returns true if newly created <code>JFrame</code>s should have their
 703:     * Window decorations provided by the current look and feel. This is only
 704:     * a hint, as certain look and feels may not support this feature.
 705:     *
 706:     * @return true if look and feel should provide Window decorations.
 707:     * @since 1.4
 708:     */
 709:	      public static boolean isDefaultLookAndFeelDecorated() {    
 710:        Boolean defaultLookAndFeelDecorated = 
 711:            (Boolean) SwingUtilities.appContextGet(defaultLookAndFeelDecoratedKey);
 712:	          if (defaultLookAndFeelDecorated == null) {
 713:            defaultLookAndFeelDecorated = Boolean.FALSE;
 714:        }
 715:        return defaultLookAndFeelDecorated.booleanValue();
 716:    }
 717:
 718:    /**
 719:     * Returns a string representation of this <code>JFrame</code>.
 720:     * This method 
 721:     * is intended to be used only for debugging purposes, and the 
 722:     * content and format of the returned string may vary between      
 723:     * implementations. The returned string may be empty but may not 
 724:     * be <code>null</code>.
 725:     * 
 726:     * @return  a string representation of this <code>JFrame</code>
 727:     */
 728:	      protected String paramString() {
 729:        String defaultCloseOperationString;
 730:	          if (defaultCloseOperation == HIDE_ON_CLOSE) {
 731:            defaultCloseOperationString = "HIDE_ON_CLOSE";
 732:        } else if (defaultCloseOperation == DISPOSE_ON_CLOSE) {
 733:            defaultCloseOperationString = "DISPOSE_ON_CLOSE";
 734:        } else if (defaultCloseOperation == DO_NOTHING_ON_CLOSE) {
 735:            defaultCloseOperationString = "DO_NOTHING_ON_CLOSE";
 736:        } else if (defaultCloseOperation == 3) {
 737:            defaultCloseOperationString = "EXIT_ON_CLOSE";
 738:        } else defaultCloseOperationString = "";
 739:    String rootPaneString = (rootPane != null ?
 740:                 rootPane.toString() : "");
 741:    String rootPaneCheckingEnabledString = (rootPaneCheckingEnabled ?
 742:                        "true" : "false");
 743:
 744:    return super.paramString() +
 745:    ",defaultCloseOperation=" + defaultCloseOperationString +
 746:    ",rootPane=" + rootPaneString +
 747:    ",rootPaneCheckingEnabled=" + rootPaneCheckingEnabledString;
 748:    }
 749:
 750:
 751:
 752://///////////////
 753:// Accessibility support
 754:////////////////
 755:
 756:    /** The accessible context property. */
 757:    protected AccessibleContext accessibleContext = null;
 758:
 759:    /**
 760:     * Gets the AccessibleContext associated with this JFrame. 
 761:     * For JFrames, the AccessibleContext takes the form of an 
 762:     * AccessibleJFrame. 
 763:     * A new AccessibleJFrame instance is created if necessary.
 764:     *
 765:     * @return an AccessibleJFrame that serves as the 
 766:     *         AccessibleContext of this JFrame
 767:     */
 768:	      public AccessibleContext getAccessibleContext() {
 769:	          if (accessibleContext == null) {
 770:            accessibleContext = new AccessibleJFrame();
 771:        }
 772:        return accessibleContext;
 773:    }
 774:
 775:    /**
 776:     * This class implements accessibility support for the 
 777:     * <code>JFrame</code> class.  It provides an implementation of the 
 778:     * Java Accessibility API appropriate to frame user-interface 
 779:     * elements.
 780:     */
 781:	      protected class AccessibleJFrame extends AccessibleAWTFrame {
 782:
 783:        // AccessibleContext methods
 784:        /**
 785:         * Get the accessible name of this object.  
 786:         *
 787:         * @return the localized name of the object -- can be null if this 
 788:         * object does not have a name
 789:         */
 790:	          public String getAccessibleName() {
 791:	              if (accessibleName != null) {
 792:                return accessibleName;
 793:            } else {
 794:	                  if (getTitle() == null) {
 795:                    return super.getAccessibleName();
 796:                } else {
 797:                    return getTitle();
 798:                }
 799:            }
 800:        }
 801:
 802:        /**
 803:         * Get the state of this object.
 804:         *
 805:         * @return an instance of AccessibleStateSet containing the current 
 806:         * state set of the object
 807:         * @see AccessibleState
 808:         */
 809:	          public AccessibleStateSet getAccessibleStateSet() {
 810:            AccessibleStateSet states = super.getAccessibleStateSet();
 811:
 812:	              if (isResizable()) {
 813:                states.add(AccessibleState.RESIZABLE);
 814:            }
 815:	              if (getFocusOwner() != null) {
 816:                states.add(AccessibleState.ACTIVE);
 817:            }   
 818:            // FIXME:  [[[WDW - should also return ICONIFIED and ICONIFIABLE
 819:            // if we can ever figure these out]]]
 820:            return states;
 821:        }
 822:    } // inner class AccessibleJFrame
 823:}