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 }
824
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags