KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > 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 JavaDoc;
12 import java.util.Locale JavaDoc;
13 import java.util.Vector JavaDoc;
14 import java.io.Serializable JavaDoc;
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 JavaDoc, Accessible, RootPaneContainer JavaDoc
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 JavaDoc defaultLookAndFeelDecoratedKey =
109             new StringBuffer JavaDoc("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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc createRootPane() {
247         JRootPane JavaDoc rp = new JRootPane JavaDoc();
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 JavaDoc("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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc 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 JavaDoc defaultLookAndFeelDecorated =
711             (Boolean JavaDoc) 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 JavaDoc paramString() {
729         String JavaDoc 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 JavaDoc rootPaneString = (rootPane != null ?
740                  rootPane.toString() : "");
741     String JavaDoc 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 JavaDoc 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
Popular Tags