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 }
LinkBack URL
About LinkBacks
Changing how a Window is drawn.
Reply With Quote
Related threads:
Re: Changing how a Window is drawn.