1 /*
2 * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javax.swing;
27
28 import java.awt.*;
29
30 import java.beans.PropertyVetoException;
31 import java.beans.PropertyChangeEvent;
32
33 import javax.swing.event.InternalFrameEvent;
34 import javax.swing.event.InternalFrameListener;
35 import javax.swing.plaf.*;
36
37 import javax.accessibility.*;
38
39 import java.io.ObjectOutputStream;
40 import java.io.IOException;
41 import java.lang.StringBuilder;
42 import java.beans.PropertyChangeListener;
43 import sun.awt.AppContext;
44 import sun.swing.SwingUtilities2;
45
46
47 /**
48 * A lightweight object that provides many of the features of
49 * a native frame, including dragging, closing, becoming an icon,
50 * resizing, title display, and support for a menu bar.
51 * For task-oriented documentation and examples of using internal frames,
52 * see <a
53 href="http://docs.oracle.com/javase/tutorial/uiswing/components/internalframe.html" target="_top">How to Use Internal Frames</a>,
54 * a section in <em>The Java Tutorial</em>.
55 *
56 * <p>
57 *
58 * Generally,
59 * you add <code>JInternalFrame</code>s to a <code>JDesktopPane</code>. The UI
60 * delegates the look-and-feel-specific actions to the
61 * <code>DesktopManager</code>
62 * object maintained by the <code>JDesktopPane</code>.
63 * <p>
64 * The <code>JInternalFrame</code> content pane
65 * is where you add child components.
66 * As a convenience, the {@code add}, {@code remove}, and {@code setLayout}
67 * methods of this class are overridden, so that they delegate calls
68 * to the corresponding methods of the {@code ContentPane}.
69 * For example, you can add a child component to an internal frame as follows:
70 * <pre>
71 * internalFrame.add(child);
72 * </pre>
73 * And the child will be added to the contentPane.
74 * The content pane is actually managed by an instance of
75 * <code>JRootPane</code>,
76 * which also manages a layout pane, glass pane, and
77 * optional menu bar for the internal frame. Please see the
78 * <code>JRootPane</code>
79 * documentation for a complete description of these components.
80 * Refer to {@link javax.swing.RootPaneContainer}
81 * for details on adding, removing and setting the <code>LayoutManager</code>
82 * of a <code>JInternalFrame</code>.
83 * <p>
84 * <strong>Warning:</strong> Swing is not thread safe. For more
85 * information see <a
86 * href="package-summary.html#threading">Swing's Threading
87 * Policy</a>.
88 * <p>
89 * <strong>Warning:</strong>
90 * Serialized objects of this class will not be compatible with
91 * future Swing releases. The current serialization support is
92 * appropriate for short term storage or RMI between applications running
93 * the same version of Swing. As of 1.4, support for long term storage
94 * of all JavaBeans™
95 * has been added to the <code>java.beans</code> package.
96 * Please see {@link java.beans.XMLEncoder}.
97 *
98 * @see InternalFrameEvent
99 * @see JDesktopPane
100 * @see DesktopManager
101 * @see JInternalFrame.JDesktopIcon
102 * @see JRootPane
103 * @see javax.swing.RootPaneContainer
104 *
105 * @author David Kloba
106 * @author Rich Schiavi
107 * @beaninfo
108 * attribute: isContainer true
109 * attribute: containerDelegate getContentPane
110 * description: A frame container which is contained within
111 * another window.
112 */
113 public class JInternalFrame extends JComponent implements
114 Accessible, WindowConstants,
115 RootPaneContainer
116 {
117 /**
118 * @see #getUIClassID
119 * @see #readObject
120 */
121 private static final String uiClassID = "InternalFrameUI";
122
123 /**
124 * The <code>JRootPane</code> instance that manages the
125 * content pane
126 * and optional menu bar for this internal frame, as well as the
127 * glass pane.
128 *
129 * @see JRootPane
130 * @see RootPaneContainer
131 */
132 protected JRootPane rootPane;
133
134 /**
135 * If true then calls to <code>add</code> and <code>setLayout</code>
136 * will be forwarded to the <code>contentPane</code>. This is initially
137 * false, but is set to true when the <code>JInternalFrame</code> is
138 * constructed.
139 *
140 * @see #isRootPaneCheckingEnabled
141 * @see #setRootPaneCheckingEnabled
142 * @see javax.swing.RootPaneContainer
143 */
144 protected boolean rootPaneCheckingEnabled = false;
145
146 /** The frame can be closed. */
147 protected boolean closable;
148 /** The frame has been closed. */
149 protected boolean isClosed;
150 /** The frame can be expanded to the size of the desktop pane. */
151 protected boolean maximizable;
152 /**
153 * The frame has been expanded to its maximum size.
154 * @see #maximizable
155 */
156 protected boolean isMaximum;
157 /**
158 * The frame can "iconified" (shrunk down and displayed as
159 * an icon-image).
160 * @see JInternalFrame.JDesktopIcon
161 * @see #setIconifiable
162 */
163 protected boolean iconable;
164 /**
165 * The frame has been iconified.
166 * @see #isIcon()
167 */
168 protected boolean isIcon;
169 /** The frame's size can be changed. */
170 protected boolean resizable;
171 /** The frame is currently selected. */
172 protected boolean isSelected;
173 /** The icon shown in the top-left corner of this internal frame. */
174 protected Icon frameIcon;
175 /** The title displayed in this internal frame's title bar. */
176 protected String title;
177 /**
178 * The icon that is displayed when this internal frame is iconified.
179 * @see #iconable
180 */
181 protected JDesktopIcon desktopIcon;
182
183 private Cursor lastCursor;
184
185 private boolean opened;
186
187 private Rectangle normalBounds = null;
188
189 private int defaultCloseOperation = DISPOSE_ON_CLOSE;
190
191 /**
192 * Contains the Component that focus is to go when
193 * <code>restoreSubcomponentFocus</code> is invoked, that is,
194 * <code>restoreSubcomponentFocus</code> sets this to the value returned
195 * from <code>getMostRecentFocusOwner</code>.
196 */
197 private Component lastFocusOwner;
198
199 /** Bound property name. */
200 public final static String CONTENT_PANE_PROPERTY = "contentPane";
201 /** Bound property name. */
202 public final static String MENU_BAR_PROPERTY = "JMenuBar";
203 /** Bound property name. */
204 public final static String TITLE_PROPERTY = "title";
205 /** Bound property name. */
206 public final static String LAYERED_PANE_PROPERTY = "layeredPane";
207 /** Bound property name. */
208 public final static String ROOT_PANE_PROPERTY = "rootPane";
209 /** Bound property name. */
210 public final static String GLASS_PANE_PROPERTY = "glassPane";
211 /** Bound property name. */
212 public final static String FRAME_ICON_PROPERTY = "frameIcon";
213
214 /**
215 * Constrained property name indicated that this frame has
216 * selected status.
217 */
218 public final static String IS_SELECTED_PROPERTY = "selected";
219 /** Constrained property name indicating that the internal frame is closed. */
220 public final static String IS_CLOSED_PROPERTY = "closed";
221 /** Constrained property name indicating that the internal frame is maximized. */
222 public final static String IS_MAXIMUM_PROPERTY = "maximum";
223 /** Constrained property name indicating that the internal frame is iconified. */
224 public final static String IS_ICON_PROPERTY = "icon";
225
226 private static final Object PROPERTY_CHANGE_LISTENER_KEY =
227 new StringBuilder("InternalFramePropertyChangeListener");
228
229 private static void addPropertyChangeListenerIfNecessary() {
230 if (AppContext.getAppContext().get(PROPERTY_CHANGE_LISTENER_KEY) ==
231 null) {
232 PropertyChangeListener focusListener =
233 new FocusPropertyChangeListener();
234
235 AppContext.getAppContext().put(PROPERTY_CHANGE_LISTENER_KEY,
236 focusListener);
237
238 KeyboardFocusManager.getCurrentKeyboardFocusManager().
239 addPropertyChangeListener(focusListener);
240 }
241 }
242
243 private static class FocusPropertyChangeListener implements
244 PropertyChangeListener {
245 public void propertyChange(PropertyChangeEvent e) {
246 if (e.getPropertyName() == "permanentFocusOwner") {
247 updateLastFocusOwner((Component)e.getNewValue());
248 }
249 }
250 }
251
252 private static void updateLastFocusOwner(Component component) {
253 if (component != null) {
254 Component parent = component;
255 while (parent != null && !(parent instanceof Window)) {
256 if (parent instanceof JInternalFrame) {
257 // Update lastFocusOwner for parent.
258 ((JInternalFrame)parent).setLastFocusOwner(component);
259 }
260 parent = parent.getParent();
261 }
262 }
263 }
264
265 /**
266 * Creates a non-resizable, non-closable, non-maximizable,
267 * non-iconifiable <code>JInternalFrame</code> with no title.
268 */
269 public JInternalFrame() {
270 this("", false, false, false, false);
271 }
272
273 /**
274 * Creates a non-resizable, non-closable, non-maximizable,
275 * non-iconifiable <code>JInternalFrame</code> with the specified title.
276 * Note that passing in a <code>null</code> <code>title</code> results in
277 * unspecified behavior and possibly an exception.
278 *
279 * @param title the non-<code>null</code> <code>String</code>
280 * to display in the title bar
281 */
282 public JInternalFrame(String title) {
283 this(title, false, false, false, false);
284 }
285
286 /**
287 * Creates a non-closable, non-maximizable, non-iconifiable
288 * <code>JInternalFrame</code> with the specified title
289 * and resizability.
290 *
291 * @param title the <code>String</code> to display in the title bar
292 * @param resizable if <code>true</code>, the internal frame can be resized
293 */
294 public JInternalFrame(String title, boolean resizable) {
295 this(title, resizable, false, false, false);
296 }
297
298 /**
299 * Creates a non-maximizable, non-iconifiable <code>JInternalFrame</code>
300 * with the specified title, resizability, and
301 * closability.
302 *
303 * @param title the <code>String</code> to display in the title bar
304 * @param resizable if <code>true</code>, the internal frame can be resized
305 * @param closable if <code>true</code>, the internal frame can be closed
306 */
307 public JInternalFrame(String title, boolean resizable, boolean closable) {
308 this(title, resizable, closable, false, false);
309 }
310
311 /**
312 * Creates a non-iconifiable <code>JInternalFrame</code>
313 * with the specified title,
314 * resizability, closability, and maximizability.
315 *
316 * @param title the <code>String</code> to display in the title bar
317 * @param resizable if <code>true</code>, the internal frame can be resized
318 * @param closable if <code>true</code>, the internal frame can be closed
319 * @param maximizable if <code>true</code>, the internal frame can be maximized
320 */
321 public JInternalFrame(String title, boolean resizable, boolean closable,
322 boolean maximizable) {
323 this(title, resizable, closable, maximizable, false);
324 }
325
326 /**
327 * Creates a <code>JInternalFrame</code> with the specified title,
328 * resizability, closability, maximizability, and iconifiability.
329 * All <code>JInternalFrame</code> constructors use this one.
330 *
331 * @param title the <code>String</code> to display in the title bar
332 * @param resizable if <code>true</code>, the internal frame can be resized
333 * @param closable if <code>true</code>, the internal frame can be closed
334 * @param maximizable if <code>true</code>, the internal frame can be maximized
335 * @param iconifiable if <code>true</code>, the internal frame can be iconified
336 */
337 public JInternalFrame(String title, boolean resizable, boolean closable,
338 boolean maximizable, boolean iconifiable) {
339
340 setRootPane(createRootPane());
341 setLayout(new BorderLayout());
342 this.title = title;
343 this.resizable = resizable;
344 this.closable = closable;
345 this.maximizable = maximizable;
346 isMaximum = false;
347 this.iconable = iconifiable;
348 isIcon = false;
349 setVisible(false);
350 setRootPaneCheckingEnabled(true);
351 desktopIcon = new JDesktopIcon(this);
352 updateUI();
353 sun.awt.SunToolkit.checkAndSetPolicy(this);
354 addPropertyChangeListenerIfNecessary();
355 }
356
357 /**
358 * Called by the constructor to set up the <code>JRootPane</code>.
359 * @return a new <code>JRootPane</code>
360 * @see JRootPane
361 */
362 protected JRootPane createRootPane() {
363 return new JRootPane();
364 }
365
366 /**
367 * Returns the look-and-feel object that renders this component.
368 *
369 * @return the <code>InternalFrameUI</code> object that renders
370 * this component
371 */
372 public InternalFrameUI getUI() {
373 return (InternalFrameUI)ui;
374 }
375
376 /**
377 * Sets the UI delegate for this <code>JInternalFrame</code>.
378 * @param ui the UI delegate
379 * @beaninfo
380 * bound: true
381 * hidden: true
382 * attribute: visualUpdate true
383 * description: The UI object that implements the Component's LookAndFeel.
384 */
385 public void setUI(InternalFrameUI ui) {
386 boolean checkingEnabled = isRootPaneCheckingEnabled();
387 try {
388 setRootPaneCheckingEnabled(false);
389 super.setUI(ui);
390 }
391 finally {
392 setRootPaneCheckingEnabled(checkingEnabled);
393 }
394 }
395
396 /**
397 * Notification from the <code>UIManager</code> that the look and feel
398 * has changed.
399 * Replaces the current UI object with the latest version from the
400 * <code>UIManager</code>.
401 *
402 * @see JComponent#updateUI
403 */
404 public void updateUI() {
405 setUI((InternalFrameUI)UIManager.getUI(this));
406 invalidate();
407 if (desktopIcon != null) {
408 desktopIcon.updateUIWhenHidden();
409 }
410 }
411
412 /* This method is called if <code>updateUI</code> was called
413 * on the associated
414 * JDesktopIcon. It's necessary to avoid infinite recursion.
415 */
416 void updateUIWhenHidden() {
417 setUI((InternalFrameUI)UIManager.getUI(this));
418 invalidate();
419 Component[] children = getComponents();
420 if (children != null) {
421 for (Component child : children) {
422 SwingUtilities.updateComponentTreeUI(child);
423 }
424 }
425 }
426
427
428 /**
429 * Returns the name of the look-and-feel
430 * class that renders this component.
431 *
432 * @return the string "InternalFrameUI"
433 *
434 * @see JComponent#getUIClassID
435 * @see UIDefaults#getUI
436 *
437 * @beaninfo
438 * description: UIClassID
439 */
440 public String getUIClassID() {
441 return uiClassID;
442 }
443
444 /**
445 * Returns whether calls to <code>add</code> and
446 * <code>setLayout</code> are forwarded to the <code>contentPane</code>.
447 *
448 * @return true if <code>add</code> and <code>setLayout</code>
449 * are forwarded; false otherwise
450 *
451 * @see #addImpl
452 * @see #setLayout
453 * @see #setRootPaneCheckingEnabled
454 * @see javax.swing.RootPaneContainer
455 */
456 protected boolean isRootPaneCheckingEnabled() {
457 return rootPaneCheckingEnabled;
458 }
459
460 /**
461 * Sets whether calls to <code>add</code> and
462 * <code>setLayout</code> are forwarded to the <code>contentPane</code>.
463 *
464 * @param enabled true if <code>add</code> and <code>setLayout</code>
465 * are forwarded, false if they should operate directly on the
466 * <code>JInternalFrame</code>.
467 *
468 * @see #addImpl
469 * @see #setLayout
470 * @see #isRootPaneCheckingEnabled
471 * @see javax.swing.RootPaneContainer
472 * @beaninfo
473 * hidden: true
474 * description: Whether the add and setLayout methods are forwarded
475 */
476 protected void setRootPaneCheckingEnabled(boolean enabled) {
477 rootPaneCheckingEnabled = enabled;
478 }
479
480 /**
481 * Adds the specified child <code>Component</code>.
482 * This method is overridden to conditionally forward calls to the
483 * <code>contentPane</code>.
484 * By default, children are added to the <code>contentPane</code> instead
485 * of the frame, refer to {@link javax.swing.RootPaneContainer} for
486 * details.
487 *
488 * @param comp the component to be enhanced
489 * @param constraints the constraints to be respected
490 * @param index the index
491 * @exception IllegalArgumentException if <code>index</code> is invalid
492 * @exception IllegalArgumentException if adding the container's parent
493 * to itself
494 * @exception IllegalArgumentException if adding a window to a container
495 *
496 * @see #setRootPaneCheckingEnabled
497 * @see javax.swing.RootPaneContainer
498 */
499 protected void addImpl(Component comp, Object constraints, int index) {
500 if(isRootPaneCheckingEnabled()) {
501 getContentPane().add(comp, constraints, index);
502 }
503 else {
504 super.addImpl(comp, constraints, index);
505 }
506 }
507
508 /**
509 * Removes the specified component from the container. If
510 * <code>comp</code> is not a child of the <code>JInternalFrame</code>
511 * this will forward the call to the <code>contentPane</code>.
512 *
513 * @param comp the component to be removed
514 * @throws NullPointerException if <code>comp</code> is null
515 * @see #add
516 * @see javax.swing.RootPaneContainer
517 */
518 public void remove(Component comp) {
519 int oldCount = getComponentCount();
520 super.remove(comp);
521 if (oldCount == getComponentCount()) {
522 getContentPane().remove(comp);
523 }
524 }
525
526
527 /**
528 * Ensures that, by default, the layout of this component cannot be set.
529 * Overridden to conditionally forward the call to the
530 * <code>contentPane</code>.
531 * Refer to {@link javax.swing.RootPaneContainer} for
532 * more information.
533 *
534 * @param manager the <code>LayoutManager</code>
535 * @see #setRootPaneCheckingEnabled
536 */
537 public void setLayout(LayoutManager manager) {
538 if(isRootPaneCheckingEnabled()) {
539 getContentPane().setLayout(manager);
540 }
541 else {
542 super.setLayout(manager);
543 }
544 }
545
546
547 //////////////////////////////////////////////////////////////////////////
548 /// Property Methods
549 //////////////////////////////////////////////////////////////////////////
550
551 /**
552 * Returns the current <code>JMenuBar</code> for this
553 * <code>JInternalFrame</code>, or <code>null</code>
554 * if no menu bar has been set.
555 * @return the current menu bar, or <code>null</code> if none has been set
556 *
557 * @deprecated As of Swing version 1.0.3,
558 * replaced by <code>getJMenuBar()</code>.
559 */
560 @Deprecated
561 public JMenuBar getMenuBar() {
562 return getRootPane().getMenuBar();
563 }
564
565 /**
566 * Returns the current <code>JMenuBar</code> for this
567 * <code>JInternalFrame</code>, or <code>null</code>
568 * if no menu bar has been set.
569 *
570 * @return the <code>JMenuBar</code> used by this internal frame
571 * @see #setJMenuBar
572 */
573 public JMenuBar getJMenuBar() {
574 return getRootPane().getJMenuBar();
575 }
576
577 /**
578 * Sets the <code>menuBar</code> property for this <code>JInternalFrame</code>.
579 *
580 * @param m the <code>JMenuBar</code> to use in this internal frame
581 * @see #getJMenuBar
582 * @deprecated As of Swing version 1.0.3
583 * replaced by <code>setJMenuBar(JMenuBar m)</code>.
584 */
585 @Deprecated
586 public void setMenuBar(JMenuBar m) {
587 JMenuBar oldValue = getMenuBar();
588 getRootPane().setJMenuBar(m);
589 firePropertyChange(MENU_BAR_PROPERTY, oldValue, m);
590 }
591
592 /**
593 * Sets the <code>menuBar</code> property for this <code>JInternalFrame</code>.
594 *
595 * @param m the <code>JMenuBar</code> to use in this internal frame
596 * @see #getJMenuBar
597 * @beaninfo
598 * bound: true
599 * preferred: true
600 * description: The menu bar for accessing pulldown menus
601 * from this internal frame.
602 */
603 public void setJMenuBar(JMenuBar m){
604 JMenuBar oldValue = getMenuBar();
605 getRootPane().setJMenuBar(m);
606 firePropertyChange(MENU_BAR_PROPERTY, oldValue, m);
607 }
608
609 // implements javax.swing.RootPaneContainer
610 /**
611 * Returns the content pane for this internal frame.
612 * @return the content pane
613 */
614 public Container getContentPane() {
615 return getRootPane().getContentPane();
616 }
617
618
619 /**
620 * Sets this <code>JInternalFrame</code>'s <code>contentPane</code>
621 * property.
622 *
623 * @param c the content pane for this internal frame
624 *
625 * @exception java.awt.IllegalComponentStateException (a runtime
626 * exception) if the content pane parameter is <code>null</code>
627 * @see RootPaneContainer#getContentPane
628 * @beaninfo
629 * bound: true
630 * hidden: true
631 * description: The client area of the internal frame where child
632 * components are normally inserted.
633 */
634 public void setContentPane(Container c) {
635 Container oldValue = getContentPane();
636 getRootPane().setContentPane(c);
637 firePropertyChange(CONTENT_PANE_PROPERTY, oldValue, c);
638 }
639
640 /**
641 * Returns the layered pane for this internal frame.
642 *
643 * @return a <code>JLayeredPane</code> object
644 * @see RootPaneContainer#setLayeredPane
645 * @see RootPaneContainer#getLayeredPane
646 */
647 public JLayeredPane getLayeredPane() {
648 return getRootPane().getLayeredPane();
649 }
650
651 /**
652 * Sets this <code>JInternalFrame</code>'s
653 * <code>layeredPane</code> property.
654 *
655 * @param layered the <code>JLayeredPane</code> for this internal frame
656 *
657 * @exception java.awt.IllegalComponentStateException (a runtime
658 * exception) if the layered pane parameter is <code>null</code>
659 * @see RootPaneContainer#setLayeredPane
660 * @beaninfo
661 * hidden: true
662 * bound: true
663 * description: The pane which holds the various desktop layers.
664 */
665 public void setLayeredPane(JLayeredPane layered) {
666 JLayeredPane oldValue = getLayeredPane();
667 getRootPane().setLayeredPane(layered);
668 firePropertyChange(LAYERED_PANE_PROPERTY, oldValue, layered);
669 }
670
671 /**
672 * Returns the glass pane for this internal frame.
673 *
674 * @return the glass pane
675 * @see RootPaneContainer#setGlassPane
676 */
677 public Component getGlassPane() {
678 return getRootPane().getGlassPane();
679 }
680
681 /**
682 * Sets this <code>JInternalFrame</code>'s
683 * <code>glassPane</code> property.
684 *
685 * @param glass the glass pane for this internal frame
686 * @see RootPaneContainer#getGlassPane
687 * @beaninfo
688 * bound: true
689 * hidden: true
690 * description: A transparent pane used for menu rendering.
691 */
692 public void setGlassPane(Component glass) {
693 Component oldValue = getGlassPane();
694 getRootPane().setGlassPane(glass);
695 firePropertyChange(GLASS_PANE_PROPERTY, oldValue, glass);
696 }
697
698 /**
699 * Returns the <code>rootPane</code> object for this internal frame.
700 *
701 * @return the <code>rootPane</code> property
702 * @see RootPaneContainer#getRootPane
703 */
704 public JRootPane getRootPane() {
705 return rootPane;
706 }
707
708
709 /**
710 * Sets the <code>rootPane</code> property
711 * for this <code>JInternalFrame</code>.
712 * This method is called by the constructor.
713 *
714 * @param root the new <code>JRootPane</code> object
715 * @beaninfo
716 * bound: true
717 * hidden: true
718 * description: The root pane used by this internal frame.
719 */
720 protected void setRootPane(JRootPane root) {
721 if(rootPane != null) {
722 remove(rootPane);
723 }
724 JRootPane oldValue = getRootPane();
725 rootPane = root;
726 if(rootPane != null) {
727 boolean checkingEnabled = isRootPaneCheckingEnabled();
728 try {
729 setRootPaneCheckingEnabled(false);
730 add(rootPane, BorderLayout.CENTER);
731 }
732 finally {
733 setRootPaneCheckingEnabled(checkingEnabled);
734 }
735 }
736 firePropertyChange(ROOT_PANE_PROPERTY, oldValue, root);
737 }
738
739 /**
740 * Sets whether this <code>JInternalFrame</code> can be closed by
741 * some user action.
742 * @param b a boolean value, where <code>true</code> means this internal frame can be closed
743 * @beaninfo
744 * preferred: true
745 * bound: true
746 * description: Indicates whether this internal frame can be closed.
747 */
748 public void setClosable(boolean b) {
749 Boolean oldValue = closable ? Boolean.TRUE : Boolean.FALSE;
750 Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
751 closable = b;
752 firePropertyChange("closable", oldValue, newValue);
753 }
754
755 /**
756 * Returns whether this <code>JInternalFrame</code> can be closed by
757 * some user action.
758 * @return <code>true</code> if this internal frame can be closed
759 */
760 public boolean isClosable() {
761 return closable;
762 }
763
764 /**
765 * Returns whether this <code>JInternalFrame</code> is currently closed.
766 * @return <code>true</code> if this internal frame is closed, <code>false</code> otherwise
767 */
768 public boolean isClosed() {
769 return isClosed;
770 }
771
772 /**
773 * Closes this internal frame if the argument is <code>true</code>.
774 * Do not invoke this method with a <code>false</code> argument;
775 * the result of invoking <code>setClosed(false)</code>
776 * is unspecified.
777 *
778 * <p>
779 *
780 * If the internal frame is already closed,
781 * this method does nothing and returns immediately.
782 * Otherwise,
783 * this method begins by firing
784 * an <code>INTERNAL_FRAME_CLOSING</code> event.
785 * Then this method sets the <code>closed</code> property to <code>true</code>
786 * unless a listener vetoes the property change.
787 * This method finishes by making the internal frame
788 * invisible and unselected,
789 * and then firing an <code>INTERNAL_FRAME_CLOSED</code> event.
790 *
791 * <p>
792 *
793 * <b>Note:</b>
794 * To reuse an internal frame that has been closed,
795 * you must add it to a container
796 * (even if you never removed it from its previous container).
797 * Typically, this container will be the <code>JDesktopPane</code>
798 * that previously contained the internal frame.
799 *
800 * @param b must be <code>true</code>
801 *
802 * @exception PropertyVetoException when the attempt to set the
803 * property is vetoed by the <code>JInternalFrame</code>
804 *
805 * @see #isClosed()
806 * @see #setDefaultCloseOperation
807 * @see #dispose
808 * @see javax.swing.event.InternalFrameEvent#INTERNAL_FRAME_CLOSING
809 *
810 * @beaninfo
811 * bound: true
812 * constrained: true
813 * description: Indicates whether this internal frame has been closed.
814 */
815 public void setClosed(boolean b) throws PropertyVetoException {
816 if (isClosed == b) {
817 return;
818 }
819
820 Boolean oldValue = isClosed ? Boolean.TRUE : Boolean.FALSE;
821 Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
822 if (b) {
823 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
824 }
825 fireVetoableChange(IS_CLOSED_PROPERTY, oldValue, newValue);
826 isClosed = b;
827 if (isClosed) {
828 setVisible(false);
829 }
830 firePropertyChange(IS_CLOSED_PROPERTY, oldValue, newValue);
831 if (isClosed) {
832 dispose();
833 } else if (!opened) {
834 /* this bogus -- we haven't defined what
835 setClosed(false) means. */
836 // fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
837 // opened = true;
838 }
839 }
840
841 /**
842 * Sets whether the <code>JInternalFrame</code> can be resized by some
843 * user action.
844 *
845 * @param b a boolean, where <code>true</code> means this internal frame can be resized
846 * @beaninfo
847 * preferred: true
848 * bound: true
849 * description: Determines whether this internal frame can be resized
850 * by the user.
851 */
852 public void setResizable(boolean b) {
853 Boolean oldValue = resizable ? Boolean.TRUE : Boolean.FALSE;
854 Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
855 resizable = b;
856 firePropertyChange("resizable", oldValue, newValue);
857 }
858
859 /**
860 * Returns whether the <code>JInternalFrame</code> can be resized
861 * by some user action.
862 *
863 * @return <code>true</code> if this internal frame can be resized, <code>false</code> otherwise
864 */
865 public boolean isResizable() {
866 // don't allow resizing when maximized.
867 return isMaximum ? false : resizable;
868 }
869
870 /**
871 * Sets the <code>iconable</code> property,
872 * which must be <code>true</code>
873 * for the user to be able to
874 * make the <code>JInternalFrame</code> an icon.
875 * Some look and feels might not implement iconification;
876 * they will ignore this property.
877 *
878 * @param b a boolean, where <code>true</code> means this internal frame can be iconified
879 * @beaninfo
880 * preferred: true
881 bound: true
882 * description: Determines whether this internal frame can be iconified.
883 */
884 public void setIconifiable(boolean b) {
885 Boolean oldValue = iconable ? Boolean.TRUE : Boolean.FALSE;
886 Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
887 iconable = b;
888 firePropertyChange("iconable", oldValue, newValue);
889 }
890
891 /**
892 * Gets the <code>iconable</code> property,
893 * which by default is <code>false</code>.
894 *
895 * @return the value of the <code>iconable</code> property.
896 *
897 * @see #setIconifiable
898 */
899 public boolean isIconifiable() {
900 return iconable;
901 }
902
903 /**
904 * Returns whether the <code>JInternalFrame</code> is currently iconified.
905 *
906 * @return <code>true</code> if this internal frame is iconified
907 */
908 public boolean isIcon() {
909 return isIcon;
910 }
911
912 /**
913 * Iconifies or de-iconifies this internal frame,
914 * if the look and feel supports iconification.
915 * If the internal frame's state changes to iconified,
916 * this method fires an <code>INTERNAL_FRAME_ICONIFIED</code> event.
917 * If the state changes to de-iconified,
918 * an <code>INTERNAL_FRAME_DEICONIFIED</code> event is fired.
919 *
920 * @param b a boolean, where <code>true</code> means to iconify this internal frame and
921 * <code>false</code> means to de-iconify it
922 * @exception PropertyVetoException when the attempt to set the
923 * property is vetoed by the <code>JInternalFrame</code>
924 *
925 * @see InternalFrameEvent#INTERNAL_FRAME_ICONIFIED
926 * @see InternalFrameEvent#INTERNAL_FRAME_DEICONIFIED
927 *
928 * @beaninfo
929 * bound: true
930 * constrained: true
931 * description: The image displayed when this internal frame is minimized.
932 */
933 public void setIcon(boolean b) throws PropertyVetoException {
934 if (isIcon == b) {
935 return;
936 }
937
938 /* If an internal frame is being iconified before it has a
939 parent, (e.g., client wants it to start iconic), create the
940 parent if possible so that we can place the icon in its
941 proper place on the desktop. I am not sure the call to
942 validate() is necessary, since we are not going to display
943 this frame yet */
944 firePropertyChange("ancestor", null, getParent());
945
946 Boolean oldValue = isIcon ? Boolean.TRUE : Boolean.FALSE;
947 Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
948 fireVetoableChange(IS_ICON_PROPERTY, oldValue, newValue);
949 isIcon = b;
950 firePropertyChange(IS_ICON_PROPERTY, oldValue, newValue);
951 if (b)
952 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED);
953 else
954 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);
955 }
956
957 /**
958 * Sets the <code>maximizable</code> property,
959 * which determines whether the <code>JInternalFrame</code>
960 * can be maximized by
961 * some user action.
962 * Some look and feels might not support maximizing internal frames;
963 * they will ignore this property.
964 *
965 * @param b <code>true</code> to specify that this internal frame should be maximizable; <code>false</code> to specify that it should not be
966 * @beaninfo
967 * bound: true
968 * preferred: true
969 * description: Determines whether this internal frame can be maximized.
970 */
971 public void setMaximizable(boolean b) {
972 Boolean oldValue = maximizable ? Boolean.TRUE : Boolean.FALSE;
973 Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
974 maximizable = b;
975 firePropertyChange("maximizable", oldValue, newValue);
976 }
977
978 /**
979 * Gets the value of the <code>maximizable</code> property.
980 *
981 * @return the value of the <code>maximizable</code> property
982 * @see #setMaximizable
983 */
984 public boolean isMaximizable() {
985 return maximizable;
986 }
987
988 /**
989 * Returns whether the <code>JInternalFrame</code> is currently maximized.
990 *
991 * @return <code>true</code> if this internal frame is maximized, <code>false</code> otherwise
992 */
993 public boolean isMaximum() {
994 return isMaximum;
995 }
996
997 /**
998 * Maximizes and restores this internal frame. A maximized frame is resized to
999 * fully fit the <code>JDesktopPane</code> area associated with the
1000 * <code>JInternalFrame</code>.
1001 * A restored frame's size is set to the <code>JInternalFrame</code>'s
1002 * actual size.
1003 *
1004 * @param b a boolean, where <code>true</code> maximizes this internal frame and <code>false</code>
1005 * restores it
1006 * @exception PropertyVetoException when the attempt to set the
1007 * property is vetoed by the <code>JInternalFrame</code>
1008 * @beaninfo
1009 * bound: true
1010 * constrained: true
1011 * description: Indicates whether this internal frame is maximized.
1012 */
1013 public void setMaximum(boolean b) throws PropertyVetoException {
1014 if (isMaximum == b) {
1015 return;
1016 }
1017
1018 Boolean oldValue = isMaximum ? Boolean.TRUE : Boolean.FALSE;
1019 Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
1020 fireVetoableChange(IS_MAXIMUM_PROPERTY, oldValue, newValue);
1021 /* setting isMaximum above the event firing means that
1022 property listeners that, for some reason, test it will
1023 get it wrong... See, for example, getNormalBounds() */
1024 isMaximum = b;
1025 firePropertyChange(IS_MAXIMUM_PROPERTY, oldValue, newValue);
1026 }
1027
1028 /**
1029 * Returns the title of the <code>JInternalFrame</code>.
1030 *
1031 * @return a <code>String</code> containing this internal frame's title
1032 * @see #setTitle
1033 */
1034 public String getTitle() {
1035 return title;
1036 }
1037
1038 /**
1039 * Sets the <code>JInternalFrame</code> title. <code>title</code>
1040 * may have a <code>null</code> value.
1041 * @see #getTitle
1042 *
1043 * @param title the <code>String</code> to display in the title bar
1044 * @beaninfo
1045 * preferred: true
1046 * bound: true
1047 * description: The text displayed in the title bar.
1048 */
1049 public void setTitle(String title) {
1050 String oldValue = this.title;
1051 this.title = title;
1052 firePropertyChange(TITLE_PROPERTY, oldValue, title);
1053 }
1054
1055 /**
1056 * Selects or deselects the internal frame
1057 * if it's showing.
1058 * A <code>JInternalFrame</code> normally draws its title bar
1059 * differently if it is
1060 * the selected frame, which indicates to the user that this
1061 * internal frame has the focus.
1062 * When this method changes the state of the internal frame
1063 * from deselected to selected, it fires an
1064 * <code>InternalFrameEvent.INTERNAL_FRAME_ACTIVATED</code> event.
1065 * If the change is from selected to deselected,
1066 * an <code>InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED</code> event
1067 * is fired.
1068 *
1069 * @param selected a boolean, where <code>true</code> means this internal frame
1070 * should become selected (currently active)
1071 * and <code>false</code> means it should become deselected
1072 * @exception PropertyVetoException when the attempt to set the
1073 * property is vetoed by the <code>JInternalFrame</code>
1074 *
1075 * @see #isShowing
1076 * @see InternalFrameEvent#INTERNAL_FRAME_ACTIVATED
1077 * @see InternalFrameEvent#INTERNAL_FRAME_DEACTIVATED
1078 *
1079 * @beaninfo
1080 * constrained: true
1081 * bound: true
1082 * description: Indicates whether this internal frame is currently
1083 * the active frame.
1084 */
1085 public void setSelected(boolean selected) throws PropertyVetoException {
1086 // The InternalFrame may already be selected, but the focus
1087 // may be outside it, so restore the focus to the subcomponent
1088 // which previously had it. See Bug 4302764.
1089 if (selected && isSelected) {
1090 restoreSubcomponentFocus();
1091 return;
1092 }
1093 // The internal frame or the desktop icon must be showing to allow
1094 // selection. We may deselect even if neither is showing.
1095 if ((isSelected == selected) || (selected &&
1096 (isIcon ? !desktopIcon.isShowing() : !isShowing()))) {
1097 return;
1098 }
1099
1100 Boolean oldValue = isSelected ? Boolean.TRUE : Boolean.FALSE;
1101 Boolean newValue = selected ? Boolean.TRUE : Boolean.FALSE;
1102 fireVetoableChange(IS_SELECTED_PROPERTY, oldValue, newValue);
1103
1104 /* We don't want to leave focus in the previously selected
1105 frame, so we have to set it to *something* in case it
1106 doesn't get set in some other way (as if a user clicked on
1107 a component that doesn't request focus). If this call is
1108 happening because the user clicked on a component that will
1109 want focus, then it will get transfered there later.
1110
1111 We test for parent.isShowing() above, because AWT throws a
1112 NPE if you try to request focus on a lightweight before its
1113 parent has been made visible */
1114
1115 if (selected) {
1116 restoreSubcomponentFocus();
1117 }
1118
1119 isSelected = selected;
1120 firePropertyChange(IS_SELECTED_PROPERTY, oldValue, newValue);
1121 if (isSelected)
1122 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED);
1123 else
1124 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED);
1125 repaint();
1126 }
1127
1128 /**
1129 * Returns whether the <code>JInternalFrame</code> is the
1130 * currently "selected" or active frame.
1131 *
1132 * @return <code>true</code> if this internal frame is currently selected (active)
1133 * @see #setSelected
1134 */
1135 public boolean isSelected() {
1136 return isSelected;
1137 }
1138
1139 /**
1140 * Sets an image to be displayed in the titlebar of this internal frame (usually
1141 * in the top-left corner).
1142 * This image is not the <code>desktopIcon</code> object, which
1143 * is the image displayed in the <code>JDesktop</code> when
1144 * this internal frame is iconified.
1145 *
1146 * Passing <code>null</code> to this function is valid,
1147 * but the look and feel
1148 * can choose the
1149 * appropriate behavior for that situation, such as displaying no icon
1150 * or a default icon for the look and feel.
1151 *
1152 * @param icon the <code>Icon</code> to display in the title bar
1153 * @see #getFrameIcon
1154 * @beaninfo
1155 * bound: true
1156 * description: The icon shown in the top-left corner of this internal frame.
1157 */
1158 public void setFrameIcon(Icon icon) {
1159 Icon oldIcon = frameIcon;
1160 frameIcon = icon;
1161 firePropertyChange(FRAME_ICON_PROPERTY, oldIcon, icon);
1162 }
1163
1164 /**
1165 * Returns the image displayed in the title bar of this internal frame (usually
1166 * in the top-left corner).
1167 *
1168 * @return the <code>Icon</code> displayed in the title bar
1169 * @see #setFrameIcon
1170 */
1171 public Icon getFrameIcon() {
1172 return frameIcon;
1173 }
1174
1175 /**
1176 * Convenience method that moves this component to position 0 if its
1177 * parent is a <code>JLayeredPane</code>.
1178 */
1179 public void moveToFront() {
1180 if (isIcon()) {
1181 if (getDesktopIcon().getParent() instanceof JLayeredPane) {
1182 ((JLayeredPane)getDesktopIcon().getParent()).
1183 moveToFront(getDesktopIcon());
1184 }
1185 }
1186 else if (getParent() instanceof JLayeredPane) {
1187 ((JLayeredPane)getParent()).moveToFront(this);
1188 }
1189 }
1190
1191 /**
1192 * Convenience method that moves this component to position -1 if its
1193 * parent is a <code>JLayeredPane</code>.
1194 */
1195 public void moveToBack() {
1196 if (isIcon()) {
1197 if (getDesktopIcon().getParent() instanceof JLayeredPane) {
1198 ((JLayeredPane)getDesktopIcon().getParent()).
1199 moveToBack(getDesktopIcon());
1200 }
1201 }
1202 else if (getParent() instanceof JLayeredPane) {
1203 ((JLayeredPane)getParent()).moveToBack(this);
1204 }
1205 }
1206
1207 /**
1208 * Returns the last <code>Cursor</code> that was set by the
1209 * <code>setCursor</code> method that is not a resizable
1210 * <code>Cursor</code>.
1211 *
1212 * @return the last non-resizable <code>Cursor</code>
1213 * @since 1.6
1214 */
1215 public Cursor getLastCursor() {
1216 return lastCursor;
1217 }
1218
1219 /**
1220 * {@inheritDoc}
1221 * @since 1.6
1222 */
1223 public void setCursor(Cursor cursor) {
1224 if (cursor == null) {
1225 lastCursor = null;
1226 super.setCursor(cursor);
1227 return;
1228 }
1229 int type = cursor.getType();
1230 if (!(type == Cursor.SW_RESIZE_CURSOR ||
1231 type == Cursor.SE_RESIZE_CURSOR ||
1232 type == Cursor.NW_RESIZE_CURSOR ||
1233 type == Cursor.NE_RESIZE_CURSOR ||
1234 type == Cursor.N_RESIZE_CURSOR ||
1235 type == Cursor.S_RESIZE_CURSOR ||
1236 type == Cursor.W_RESIZE_CURSOR ||
1237 type == Cursor.E_RESIZE_CURSOR)) {
1238 lastCursor = cursor;
1239 }
1240 super.setCursor(cursor);
1241 }
1242
1243 /**
1244 * Convenience method for setting the layer attribute of this component.
1245 *
1246 * @param layer an <code>Integer</code> object specifying this
1247 * frame's desktop layer
1248 * @see JLayeredPane
1249 * @beaninfo
1250 * expert: true
1251 * description: Specifies what desktop layer is used.
1252 */
1253 public void setLayer(Integer layer) {
1254 if(getParent() != null && getParent() instanceof JLayeredPane) {
1255 // Normally we want to do this, as it causes the LayeredPane
1256 // to draw properly.
1257 JLayeredPane p = (JLayeredPane)getParent();
1258 p.setLayer(this, layer.intValue(), p.getPosition(this));
1259 } else {
1260 // Try to do the right thing
1261 JLayeredPane.putLayer(this, layer.intValue());
1262 if(getParent() != null)
1263 getParent().repaint(getX(), getY(), getWidth(), getHeight());
1264 }
1265 }
1266
1267 /**
1268 * Convenience method for setting the layer attribute of this component.
1269 * The method <code>setLayer(Integer)</code> should be used for
1270 * layer values predefined in <code>JLayeredPane</code>.
1271 * When using <code>setLayer(int)</code>, care must be taken not to
1272 * accidentally clash with those values.
1273 *
1274 * @param layer an integer specifying this internal frame's desktop layer
1275 *
1276 * @since 1.3
1277 *
1278 * @see #setLayer(Integer)
1279 * @see JLayeredPane
1280 * @beaninfo
1281 * expert: true
1282 * description: Specifies what desktop layer is used.
1283 */
1284 public void setLayer(int layer) {
1285 this.setLayer(Integer.valueOf(layer));
1286 }
1287
1288 /**
1289 * Convenience method for getting the layer attribute of this component.
1290 *
1291 * @return an <code>Integer</code> object specifying this
1292 * frame's desktop layer
1293 * @see JLayeredPane
1294 */
1295 public int getLayer() {
1296 return JLayeredPane.getLayer(this);
1297 }
1298
1299 /**
1300 * Convenience method that searches the ancestor hierarchy for a
1301 * <code>JDesktop</code> instance. If <code>JInternalFrame</code>
1302 * finds none, the <code>desktopIcon</code> tree is searched.
1303 *
1304 * @return the <code>JDesktopPane</code> this internal frame belongs to,
1305 * or <code>null</code> if none is found
1306 */
1307 public JDesktopPane getDesktopPane() {
1308 Container p;
1309
1310 // Search upward for desktop
1311 p = getParent();
1312 while(p != null && !(p instanceof JDesktopPane))
1313 p = p.getParent();
1314
1315 if(p == null) {
1316 // search its icon parent for desktop
1317 p = getDesktopIcon().getParent();
1318 while(p != null && !(p instanceof JDesktopPane))
1319 p = p.getParent();
1320 }
1321
1322 return (JDesktopPane)p;
1323 }
1324
1325 /**
1326 * Sets the <code>JDesktopIcon</code> associated with this
1327 * <code>JInternalFrame</code>.
1328 *
1329 * @param d the <code>JDesktopIcon</code> to display on the desktop
1330 * @see #getDesktopIcon
1331 * @beaninfo
1332 * bound: true
1333 * description: The icon shown when this internal frame is minimized.
1334 */
1335 public void setDesktopIcon(JDesktopIcon d) {
1336 JDesktopIcon oldValue = getDesktopIcon();
1337 desktopIcon = d;
1338 firePropertyChange("desktopIcon", oldValue, d);
1339 }
1340
1341 /**
1342 * Returns the <code>JDesktopIcon</code> used when this
1343 * <code>JInternalFrame</code> is iconified.
1344 *
1345 * @return the <code>JDesktopIcon</code> displayed on the desktop
1346 * @see #setDesktopIcon
1347 */
1348 public JDesktopIcon getDesktopIcon() {
1349 return desktopIcon;
1350 }
1351
1352 /**
1353 * If the <code>JInternalFrame</code> is not in maximized state, returns
1354 * <code>getBounds()</code>; otherwise, returns the bounds that the
1355 * <code>JInternalFrame</code> would be restored to.
1356 *
1357 * @return a <code>Rectangle</code> containing the bounds of this
1358 * frame when in the normal state
1359 * @since 1.3
1360 */
1361 public Rectangle getNormalBounds() {
1362
1363 /* we used to test (!isMaximum) here, but since this
1364 method is used by the property listener for the
1365 IS_MAXIMUM_PROPERTY, it ended up getting the wrong
1366 answer... Since normalBounds get set to null when the
1367 frame is restored, this should work better */
1368
1369 if (normalBounds != null) {
1370 return normalBounds;
1371 } else {
1372 return getBounds();
1373 }
1374 }
1375
1376 /**
1377 * Sets the normal bounds for this internal frame, the bounds that
1378 * this internal frame would be restored to from its maximized state.
1379 * This method is intended for use only by desktop managers.
1380 *
1381 * @param r the bounds that this internal frame should be restored to
1382 * @since 1.3
1383 */
1384 public void setNormalBounds(Rectangle r) {
1385 normalBounds = r;
1386 }
1387
1388 /**
1389 * If this <code>JInternalFrame</code> is active,
1390 * returns the child that has focus.
1391 * Otherwise, returns <code>null</code>.
1392 *
1393 * @return the component with focus, or <code>null</code> if no children have focus
1394 * @since 1.3
1395 */
1396 public Component getFocusOwner() {
1397 if (isSelected()) {
1398 return lastFocusOwner;
1399 }
1400 return null;
1401 }
1402
1403 /**
1404 * Returns the child component of this <code>JInternalFrame</code>
1405 * that will receive the
1406 * focus when this <code>JInternalFrame</code> is selected.
1407 * If this <code>JInternalFrame</code> is
1408 * currently selected, this method returns the same component as
1409 * the <code>getFocusOwner</code> method.
1410 * If this <code>JInternalFrame</code> is not selected,
1411 * then the child component that most recently requested focus will be
1412 * returned. If no child component has ever requested focus, then this
1413 * <code>JInternalFrame</code>'s initial focusable component is returned.
1414 * If no such
1415 * child exists, then this <code>JInternalFrame</code>'s default component
1416 * to focus is returned.
1417 *
1418 * @return the child component that will receive focus when this
1419 * <code>JInternalFrame</code> is selected
1420 * @see #getFocusOwner
1421 * @see #isSelected
1422 * @since 1.4
1423 */
1424 public Component getMostRecentFocusOwner() {
1425 if (isSelected()) {
1426 return getFocusOwner();
1427 }
1428
1429 if (lastFocusOwner != null) {
1430 return lastFocusOwner;
1431 }
1432
1433 FocusTraversalPolicy policy = getFocusTraversalPolicy();
1434 if (policy instanceof InternalFrameFocusTraversalPolicy) {
1435 return ((InternalFrameFocusTraversalPolicy)policy).
1436 getInitialComponent(this);
1437 }
1438
1439 Component toFocus = policy.getDefaultComponent(this);
1440 if (toFocus != null) {
1441 return toFocus;
1442 }
1443 return getContentPane();
1444 }
1445
1446 /**
1447 * Requests the internal frame to restore focus to the
1448 * last subcomponent that had focus. This is used by the UI when
1449 * the user selected this internal frame --
1450 * for example, by clicking on the title bar.
1451 *
1452 * @since 1.3
1453 */
1454 public void restoreSubcomponentFocus() {
1455 if (isIcon()) {
1456 SwingUtilities2.compositeRequestFocus(getDesktopIcon());
1457 }
1458 else {
1459 Component component = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner();
1460 if ((component == null) || !SwingUtilities.isDescendingFrom(component, this)) {
1461 // FocusPropertyChangeListener will eventually update
1462 // lastFocusOwner. As focus requests are asynchronous
1463 // lastFocusOwner may be accessed before it has been correctly
1464 // updated. To avoid any problems, lastFocusOwner is immediately
1465 // set, assuming the request will succeed.
1466 setLastFocusOwner(getMostRecentFocusOwner());
1467 if (lastFocusOwner == null) {
1468 // Make sure focus is restored somewhere, so that
1469 // we don't leave a focused component in another frame while
1470 // this frame is selected.
1471 setLastFocusOwner(getContentPane());
1472 }
1473 lastFocusOwner.requestFocus();
1474 }
1475 }
1476 }
1477
1478 private void setLastFocusOwner(Component component) {
1479 lastFocusOwner = component;
1480 }
1481
1482 /**
1483 * Moves and resizes this component. Unlike other components,
1484 * this implementation also forces re-layout, so that frame
1485 * decorations such as the title bar are always redisplayed.
1486 *
1487 * @param x an integer giving the component's new horizontal position
1488 * measured in pixels from the left of its container
1489 * @param y an integer giving the component's new vertical position,
1490 * measured in pixels from the bottom of its container
1491 * @param width an integer giving the component's new width in pixels
1492 * @param height an integer giving the component's new height in pixels
1493 */
1494 public void reshape(int x, int y, int width, int height) {
1495 super.reshape(x, y, width, height);
1496 validate();
1497 repaint();
1498 }
1499
1500 ///////////////////////////
1501 // Frame/Window equivalents
1502 ///////////////////////////
1503
1504 /**
1505 * Adds the specified listener to receive internal
1506 * frame events from this internal frame.
1507 *
1508 * @param l the internal frame listener
1509 */
1510 public void addInternalFrameListener(InternalFrameListener l) { // remind: sync ??
1511 listenerList.add(InternalFrameListener.class, l);
1512 // remind: needed?
1513 enableEvents(0); // turn on the newEventsOnly flag in Component.
1514 }
1515
1516 /**
1517 * Removes the specified internal frame listener so that it no longer
1518 * receives internal frame events from this internal frame.
1519 *
1520 * @param l the internal frame listener
1521 */
1522 public void removeInternalFrameListener(InternalFrameListener l) { // remind: sync??
1523 listenerList.remove(InternalFrameListener.class, l);
1524 }
1525
1526 /**
1527 * Returns an array of all the <code>InternalFrameListener</code>s added
1528 * to this <code>JInternalFrame</code> with
1529 * <code>addInternalFrameListener</code>.
1530 *
1531 * @return all of the <code>InternalFrameListener</code>s added or an empty
1532 * array if no listeners have been added
1533 * @since 1.4
1534 *
1535 * @see #addInternalFrameListener
1536 */
1537 public InternalFrameListener[] getInternalFrameListeners() {
1538 return listenerList.getListeners(InternalFrameListener.class);
1539 }
1540
1541 // remind: name ok? all one method ok? need to be synchronized?
1542 /**
1543 * Fires an internal frame event.
1544 *
1545 * @param id the type of the event being fired; one of the following:
1546 * <ul>
1547 * <li><code>InternalFrameEvent.INTERNAL_FRAME_OPENED</code>
1548 * <li><code>InternalFrameEvent.INTERNAL_FRAME_CLOSING</code>
1549 * <li><code>InternalFrameEvent.INTERNAL_FRAME_CLOSED</code>
1550 * <li><code>InternalFrameEvent.INTERNAL_FRAME_ICONIFIED</code>
1551 * <li><code>InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED</code>
1552 * <li><code>InternalFrameEvent.INTERNAL_FRAME_ACTIVATED</code>
1553 * <li><code>InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED</code>
1554 * </ul>
1555 * If the event type is not one of the above, nothing happens.
1556 */
1557 protected void fireInternalFrameEvent(int id){
1558 Object[] listeners = listenerList.getListenerList();
1559 InternalFrameEvent e = null;
1560 for (int i = listeners.length -2; i >=0; i -= 2){
1561 if (listeners[i] == InternalFrameListener.class){
1562 if (e == null){
1563 e = new InternalFrameEvent(this, id);
1564 // System.out.println("InternalFrameEvent: " + e.paramString());
1565 }
1566 switch(e.getID()) {
1567 case InternalFrameEvent.INTERNAL_FRAME_OPENED:
1568 ((InternalFrameListener)listeners[i+1]).internalFrameOpened(e);
1569 break;
1570 case InternalFrameEvent.INTERNAL_FRAME_CLOSING:
1571 ((InternalFrameListener)listeners[i+1]).internalFrameClosing(e);
1572 break;
1573 case InternalFrameEvent.INTERNAL_FRAME_CLOSED:
1574 ((InternalFrameListener)listeners[i+1]).internalFrameClosed(e);
1575 break;
1576 case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED:
1577 ((InternalFrameListener)listeners[i+1]).internalFrameIconified(e);
1578 break;
1579 case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED:
1580 ((InternalFrameListener)listeners[i+1]).internalFrameDeiconified(e);
1581 break;
1582 case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED:
1583 ((InternalFrameListener)listeners[i+1]).internalFrameActivated(e);
1584 break;
1585 case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED:
1586 ((InternalFrameListener)listeners[i+1]).internalFrameDeactivated(e);
1587 break;
1588 default:
1589 break;
1590 }
1591 }
1592 }
1593 /* we could do it off the event, but at the moment, that's not how
1594 I'm implementing it */
1595 // if (id == InternalFrameEvent.INTERNAL_FRAME_CLOSING) {
1596 // doDefaultCloseAction();
1597 // }
1598 }
1599
1600 /**
1601 * Fires an
1602 * <code>INTERNAL_FRAME_CLOSING</code> event
1603 * and then performs the action specified by
1604 * the internal frame's default close operation.
1605 * This method is typically invoked by the
1606 * look-and-feel-implemented action handler
1607 * for the internal frame's close button.
1608 *
1609 * @since 1.3
1610 * @see #setDefaultCloseOperation
1611 * @see javax.swing.event.InternalFrameEvent#INTERNAL_FRAME_CLOSING
1612 */
1613 public void doDefaultCloseAction() {
1614 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
1615 switch(defaultCloseOperation) {
1616 case DO_NOTHING_ON_CLOSE:
1617 break;
1618 case HIDE_ON_CLOSE:
1619 setVisible(false);
1620 if (isSelected())
1621 try {
1622 setSelected(false);
1623 } catch (PropertyVetoException pve) {}
1624
1625 /* should this activate the next frame? that's really
1626 desktopmanager's policy... */
1627 break;
1628 case DISPOSE_ON_CLOSE:
1629 try {
1630 fireVetoableChange(IS_CLOSED_PROPERTY, Boolean.FALSE,
1631 Boolean.TRUE);
1632 isClosed = true;
1633 setVisible(false);
1634 firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE,
1635 Boolean.TRUE);
1636 dispose();
1637 } catch (PropertyVetoException pve) {}
1638 break;
1639 default:
1640 break;
1641 }
1642 }
1643
1644 /**
1645 * Sets the operation that will happen by default when
1646 * the user initiates a "close" on this internal frame.
1647 * The possible choices are:
1648 * <br><br>
1649 * <dl>
1650 * <dt><code>DO_NOTHING_ON_CLOSE</code>
1651 * <dd> Do nothing.
1652 * This requires the program to handle the operation
1653 * in the <code>windowClosing</code> method
1654 * of a registered <code>InternalFrameListener</code> object.
1655 * <dt><code>HIDE_ON_CLOSE</code>
1656 * <dd> Automatically make the internal frame invisible.
1657 * <dt><code>DISPOSE_ON_CLOSE</code>
1658 * <dd> Automatically dispose of the internal frame.
1659 * </dl>
1660 * <p>
1661 * The default value is <code>DISPOSE_ON_CLOSE</code>.
1662 * Before performing the specified close operation,
1663 * the internal frame fires
1664 * an <code>INTERNAL_FRAME_CLOSING</code> event.
1665 *
1666 * @param operation one of the following constants defined in
1667 * <code>javax.swing.WindowConstants</code>
1668 * (an interface implemented by
1669 * <code>JInternalFrame</code>):
1670 * <code>DO_NOTHING_ON_CLOSE</code>,
1671 * <code>HIDE_ON_CLOSE</code>, or
1672 * <code>DISPOSE_ON_CLOSE</code>
1673 *
1674 * @see #addInternalFrameListener
1675 * @see #getDefaultCloseOperation
1676 * @see #setVisible
1677 * @see #dispose
1678 * @see InternalFrameEvent#INTERNAL_FRAME_CLOSING
1679 */
1680 public void setDefaultCloseOperation(int operation) {
1681 this.defaultCloseOperation = operation;
1682 }
1683
1684 /**
1685 * Returns the default operation that occurs when the user
1686 * initiates a "close" on this internal frame.
1687 * @return the operation that will occur when the user closes the internal
1688 * frame
1689 * @see #setDefaultCloseOperation
1690 */
1691 public int getDefaultCloseOperation() {
1692 return defaultCloseOperation;
1693 }
1694
1695 /**
1696 * Causes subcomponents of this <code>JInternalFrame</code>
1697 * to be laid out at their preferred size. Internal frames that are
1698 * iconized or maximized are first restored and then packed. If the
1699 * internal frame is unable to be restored its state is not changed
1700 * and will not be packed.
1701 *
1702 * @see java.awt.Window#pack
1703 */
1704 public void pack() {
1705 try {
1706 if (isIcon()) {
1707 setIcon(false);
1708 } else if (isMaximum()) {
1709 setMaximum(false);
1710 }
1711 } catch(PropertyVetoException e) {
1712 return;
1713 }
1714 setSize(getPreferredSize());
1715 validate();
1716 }
1717
1718 /**
1719 * If the internal frame is not visible,
1720 * brings the internal frame to the front,
1721 * makes it visible,
1722 * and attempts to select it.
1723 * The first time the internal frame is made visible,
1724 * this method also fires an <code>INTERNAL_FRAME_OPENED</code> event.
1725 * This method does nothing if the internal frame is already visible.
1726 * Invoking this method
1727 * has the same result as invoking
1728 * <code>setVisible(true)</code>.
1729 *
1730 * @see #moveToFront
1731 * @see #setSelected
1732 * @see InternalFrameEvent#INTERNAL_FRAME_OPENED
1733 * @see #setVisible
1734 */
1735 public void show() {
1736 // bug 4312922
1737 if (isVisible()) {
1738 //match the behavior of setVisible(true): do nothing
1739 return;
1740 }
1741
1742 // bug 4149505
1743 if (!opened) {
1744 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
1745 opened = true;
1746 }
1747
1748 /* icon default visibility is false; set it to true so that it shows
1749 up when user iconifies frame */
1750 getDesktopIcon().setVisible(true);
1751
1752 toFront();
1753 super.show();
1754
1755 if (isIcon) {
1756 return;
1757 }
1758
1759 if (!isSelected()) {
1760 try {
1761 setSelected(true);
1762 } catch (PropertyVetoException pve) {}
1763 }
1764 }
1765
1766 public void hide() {
1767 if (isIcon()) {
1768 getDesktopIcon().setVisible(false);
1769 }
1770 super.hide();
1771 }
1772
1773 /**
1774 * Makes this internal frame
1775 * invisible, unselected, and closed.
1776 * If the frame is not already closed,
1777 * this method fires an
1778 * <code>INTERNAL_FRAME_CLOSED</code> event.
1779 * The results of invoking this method are similar to
1780 * <code>setClosed(true)</code>,
1781 * but <code>dispose</code> always succeeds in closing
1782 * the internal frame and does not fire
1783 * an <code>INTERNAL_FRAME_CLOSING</code> event.
1784 *
1785 * @see javax.swing.event.InternalFrameEvent#INTERNAL_FRAME_CLOSED
1786 * @see #setVisible
1787 * @see #setSelected
1788 * @see #setClosed
1789 */
1790 public void dispose() {
1791 if (isVisible()) {
1792 setVisible(false);
1793 }
1794 if (isSelected()) {
1795 try {
1796 setSelected(false);
1797 } catch (PropertyVetoException pve) {}
1798 }
1799 if (!isClosed) {
1800 firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE, Boolean.TRUE);
1801 isClosed = true;
1802 }
1803 fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
1804 }
1805
1806 /**
1807 * Brings this internal frame to the front.
1808 * Places this internal frame at the top of the stacking order
1809 * and makes the corresponding adjustment to other visible internal
1810 * frames.
1811 *
1812 * @see java.awt.Window#toFront
1813 * @see #moveToFront
1814 */
1815 public void toFront() {
1816 moveToFront();
1817 }
1818
1819 /**
1820 * Sends this internal frame to the back.
1821 * Places this internal frame at the bottom of the stacking order
1822 * and makes the corresponding adjustment to other visible
1823 * internal frames.
1824 *
1825 * @see java.awt.Window#toBack
1826 * @see #moveToBack
1827 */
1828 public void toBack() {
1829 moveToBack();
1830 }
1831
1832 /**
1833 * Does nothing because <code>JInternalFrame</code>s must always be roots of a focus
1834 * traversal cycle.
1835 *
1836 * @param focusCycleRoot this value is ignored
1837 * @see #isFocusCycleRoot
1838 * @see java.awt.Container#setFocusTraversalPolicy
1839 * @see java.awt.Container#getFocusTraversalPolicy
1840 * @since 1.4
1841 */
1842 public final void setFocusCycleRoot(boolean focusCycleRoot) {
1843 }
1844
1845 /**
1846 * Always returns <code>true</code> because all <code>JInternalFrame</code>s must be
1847 * roots of a focus traversal cycle.
1848 *
1849 * @return <code>true</code>
1850 * @see #setFocusCycleRoot
1851 * @see java.awt.Container#setFocusTraversalPolicy
1852 * @see java.awt.Container#getFocusTraversalPolicy
1853 * @since 1.4
1854 */
1855 public final boolean isFocusCycleRoot() {
1856 return true;
1857 }
1858
1859 /**
1860 * Always returns <code>null</code> because <code>JInternalFrame</code>s
1861 * must always be roots of a focus
1862 * traversal cycle.
1863 *
1864 * @return <code>null</code>
1865 * @see java.awt.Container#isFocusCycleRoot()
1866 * @since 1.4
1867 */
1868 public final Container getFocusCycleRootAncestor() {
1869 return null;
1870 }
1871
1872 /**
1873 * Gets the warning string that is displayed with this internal frame.
1874 * Since an internal frame is always secure (since it's fully
1875 * contained within a window that might need a warning string)
1876 * this method always returns <code>null</code>.
1877 * @return <code>null</code>
1878 * @see java.awt.Window#getWarningString
1879 */
1880 public final String getWarningString() {
1881 return null;
1882 }
1883
1884 /**
1885 * See <code>readObject</code> and <code>writeObject</code>
1886 * in <code>JComponent</code> for more
1887 * information about serialization in Swing.
1888 */
1889 private void writeObject(ObjectOutputStream s) throws IOException {
1890 s.defaultWriteObject();
1891 if (getUIClassID().equals(uiClassID)) {
1892 byte count = JComponent.getWriteObjCounter(this);
1893 JComponent.setWriteObjCounter(this, --count);
1894 if (count == 0 && ui != null) {
1895 boolean old = isRootPaneCheckingEnabled();
1896 try {
1897 setRootPaneCheckingEnabled(false);
1898 ui.installUI(this);
1899 } finally {
1900 setRootPaneCheckingEnabled(old);
1901 }
1902 }
1903 }
1904 }
1905
1906 /* Called from the JComponent's EnableSerializationFocusListener to
1907 * do any Swing-specific pre-serialization configuration.
1908 */
1909 void compWriteObjectNotify() {
1910 // need to disable rootpane checking for InternalFrame: 4172083
1911 boolean old = isRootPaneCheckingEnabled();
1912 try {
1913 setRootPaneCheckingEnabled(false);
1914 super.compWriteObjectNotify();
1915 }
1916 finally {
1917 setRootPaneCheckingEnabled(old);
1918 }
1919 }
1920
1921 /**
1922 * Returns a string representation of this <code>JInternalFrame</code>.
1923 * This method
1924 * is intended to be used only for debugging purposes, and the
1925 * content and format of the returned string may vary between
1926 * implementations. The returned string may be empty but may not
1927 * be <code>null</code>.
1928 *
1929 * @return a string representation of this <code>JInternalFrame</code>
1930 */
1931 protected String paramString() {
1932 String rootPaneString = (rootPane != null ?
1933 rootPane.toString() : "");
1934 String rootPaneCheckingEnabledString = (rootPaneCheckingEnabled ?
1935 "true" : "false");
1936 String closableString = (closable ? "true" : "false");
1937 String isClosedString = (isClosed ? "true" : "false");
1938 String maximizableString = (maximizable ? "true" : "false");
1939 String isMaximumString = (isMaximum ? "true" : "false");
1940 String iconableString = (iconable ? "true" : "false");
1941 String isIconString = (isIcon ? "true" : "false");
1942 String resizableString = (resizable ? "true" : "false");
1943 String isSelectedString = (isSelected ? "true" : "false");
1944 String frameIconString = (frameIcon != null ?
1945 frameIcon.toString() : "");
1946 String titleString = (title != null ?
1947 title : "");
1948 String desktopIconString = (desktopIcon != null ?
1949 desktopIcon.toString() : "");
1950 String openedString = (opened ? "true" : "false");
1951 String defaultCloseOperationString;
1952 if (defaultCloseOperation == HIDE_ON_CLOSE) {
1953 defaultCloseOperationString = "HIDE_ON_CLOSE";
1954 } else if (defaultCloseOperation == DISPOSE_ON_CLOSE) {
1955 defaultCloseOperationString = "DISPOSE_ON_CLOSE";
1956 } else if (defaultCloseOperation == DO_NOTHING_ON_CLOSE) {
1957 defaultCloseOperationString = "DO_NOTHING_ON_CLOSE";
1958 } else defaultCloseOperationString = "";
1959
1960 return super.paramString() +
1961 ",closable=" + closableString +
1962 ",defaultCloseOperation=" + defaultCloseOperationString +
1963 ",desktopIcon=" + desktopIconString +
1964 ",frameIcon=" + frameIconString +
1965 ",iconable=" + iconableString +
1966 ",isClosed=" + isClosedString +
1967 ",isIcon=" + isIconString +
1968 ",isMaximum=" + isMaximumString +
1969 ",isSelected=" + isSelectedString +
1970 ",maximizable=" + maximizableString +
1971 ",opened=" + openedString +
1972 ",resizable=" + resizableString +
1973 ",rootPane=" + rootPaneString +
1974 ",rootPaneCheckingEnabled=" + rootPaneCheckingEnabledString +
1975 ",title=" + titleString;
1976 }
1977
1978 // ======= begin optimized frame dragging defence code ==============
1979
1980 boolean isDragging = false;
1981 boolean danger = false;
1982
1983 /**
1984 * Overridden to allow optimized painting when the
1985 * internal frame is being dragged.
1986 */
1987 protected void paintComponent(Graphics g) {
1988 if (isDragging) {
1989 // System.out.println("ouch");
1990 danger = true;
1991 }
1992
1993 super.paintComponent(g);
1994 }
1995
1996 // ======= end optimized frame dragging defence code ==============
1997
1998 /////////////////
1999 // Accessibility support
2000 ////////////////
2001
2002 /**
2003 * Gets the <code>AccessibleContext</code> associated with this
2004 * <code>JInternalFrame</code>.
2005 * For internal frames, the <code>AccessibleContext</code>
2006 * takes the form of an
2007 * <code>AccessibleJInternalFrame</code> object.
2008 * A new <code>AccessibleJInternalFrame</code> instance is created if necessary.
2009 *
2010 * @return an <code>AccessibleJInternalFrame</code> that serves as the
2011 * <code>AccessibleContext</code> of this
2012 * <code>JInternalFrame</code>
2013 * @see AccessibleJInternalFrame
2014 */
2015 public AccessibleContext getAccessibleContext() {
2016 if (accessibleContext == null) {
2017 accessibleContext = new AccessibleJInternalFrame();
2018 }
2019 return accessibleContext;
2020 }
2021
2022 /**
2023 * This class implements accessibility support for the
2024 * <code>JInternalFrame</code> class. It provides an implementation of the
2025 * Java Accessibility API appropriate to internal frame user-interface
2026 * elements.
2027 * <p>
2028 * <strong>Warning:</strong>
2029 * Serialized objects of this class will not be compatible with
2030 * future Swing releases. The current serialization support is
2031 * appropriate for short term storage or RMI between applications running
2032 * the same version of Swing. As of 1.4, support for long term storage
2033 * of all JavaBeans™
2034 * has been added to the <code>java.beans</code> package.
2035 * Please see {@link java.beans.XMLEncoder}.
2036 */
2037 protected class AccessibleJInternalFrame extends AccessibleJComponent
2038 implements AccessibleValue {
2039
2040 /**
2041 * Get the accessible name of this object.
2042 *
2043 * @return the localized name of the object -- can be <code>null</code> if this
2044 * object does not have a name
2045 * @see #setAccessibleName
2046 */
2047 public String getAccessibleName() {
2048 String name = accessibleName;
2049
2050 if (name == null) {
2051 name = (String)getClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY);
2052 }
2053 if (name == null) {
2054 name = getTitle();
2055 }
2056 return name;
2057 }
2058
2059 /**
2060 * Get the role of this object.
2061 *
2062 * @return an instance of AccessibleRole describing the role of the
2063 * object
2064 * @see AccessibleRole
2065 */
2066 public AccessibleRole getAccessibleRole() {
2067 return AccessibleRole.INTERNAL_FRAME;
2068 }
2069
2070 /**
2071 * Gets the AccessibleValue associated with this object. In the
2072 * implementation of the Java Accessibility API for this class,
2073 * returns this object, which is responsible for implementing the
2074 * <code>AccessibleValue</code> interface on behalf of itself.
2075 *
2076 * @return this object
2077 */
2078 public AccessibleValue getAccessibleValue() {
2079 return this;
2080 }
2081
2082
2083 //
2084 // AccessibleValue methods
2085 //
2086
2087 /**
2088 * Get the value of this object as a Number.
2089 *
2090 * @return value of the object -- can be <code>null</code> if this object does not
2091 * have a value
2092 */
2093 public Number getCurrentAccessibleValue() {
2094 return Integer.valueOf(getLayer());
2095 }
2096
2097 /**
2098 * Set the value of this object as a Number.
2099 *
2100 * @return <code>true</code> if the value was set
2101 */
2102 public boolean setCurrentAccessibleValue(Number n) {
2103 // TIGER - 4422535
2104 if (n == null) {
2105 return false;
2106 }
2107 setLayer(new Integer(n.intValue()));
2108 return true;
2109 }
2110
2111 /**
2112 * Get the minimum value of this object as a Number.
2113 *
2114 * @return Minimum value of the object; <code>null</code> if this object does not
2115 * have a minimum value
2116 */
2117 public Number getMinimumAccessibleValue() {
2118 return Integer.MIN_VALUE;
2119 }
2120
2121 /**
2122 * Get the maximum value of this object as a Number.
2123 *
2124 * @return Maximum value of the object; <code>null</code> if this object does not
2125 * have a maximum value
2126 */
2127 public Number getMaximumAccessibleValue() {
2128 return Integer.MAX_VALUE;
2129 }
2130
2131 } // AccessibleJInternalFrame
2132
2133 /**
2134 * This component represents an iconified version of a
2135 * <code>JInternalFrame</code>.
2136 * This API should NOT BE USED by Swing applications, as it will go
2137 * away in future versions of Swing as its functionality is moved into
2138 * <code>JInternalFrame</code>. This class is public only so that
2139 * UI objects can display a desktop icon. If an application
2140 * wants to display a desktop icon, it should create a
2141 * <code>JInternalFrame</code> instance and iconify it.
2142 * <p>
2143 * <strong>Warning:</strong>
2144 * Serialized objects of this class will not be compatible with
2145 * future Swing releases. The current serialization support is
2146 * appropriate for short term storage or RMI between applications running
2147 * the same version of Swing. As of 1.4, support for long term storage
2148 * of all JavaBeans™
2149 * has been added to the <code>java.beans</code> package.
2150 * Please see {@link java.beans.XMLEncoder}.
2151 *
2152 * @author David Kloba
2153 */
2154 static public class JDesktopIcon extends JComponent implements Accessible
2155 {
2156 JInternalFrame internalFrame;
2157
2158 /**
2159 * Creates an icon for an internal frame.
2160 *
2161 * @param f the <code>JInternalFrame</code>
2162 * for which the icon is created
2163 */
2164 public JDesktopIcon(JInternalFrame f) {
2165 setVisible(false);
2166 setInternalFrame(f);
2167 updateUI();
2168 }
2169
2170 /**
2171 * Returns the look-and-feel object that renders this component.
2172 *
2173 * @return the <code>DesktopIconUI</code> object that renders
2174 * this component
2175 */
2176 public DesktopIconUI getUI() {
2177 return (DesktopIconUI)ui;
2178 }
2179
2180 /**
2181 * Sets the look-and-feel object that renders this component.
2182 *
2183 * @param ui the <code>DesktopIconUI</code> look-and-feel object
2184 * @see UIDefaults#getUI
2185 */
2186 public void setUI(DesktopIconUI ui) {
2187 super.setUI(ui);
2188 }
2189
2190 /**
2191 * Returns the <code>JInternalFrame</code> that this
2192 * <code>DesktopIcon</code> is associated with.
2193 *
2194 * @return the <code>JInternalFrame</code> with which this icon
2195 * is associated
2196 */
2197 public JInternalFrame getInternalFrame() {
2198 return internalFrame;
2199 }
2200
2201 /**
2202 * Sets the <code>JInternalFrame</code> with which this
2203 * <code>DesktopIcon</code> is associated.
2204 *
2205 * @param f the <code>JInternalFrame</code> with which this icon
2206 * is associated
2207 */
2208 public void setInternalFrame(JInternalFrame f) {
2209 internalFrame = f;
2210 }
2211
2212 /**
2213 * Convenience method to ask the icon for the <code>Desktop</code>
2214 * object it belongs to.
2215 *
2216 * @return the <code>JDesktopPane</code> that contains this
2217 * icon's internal frame, or <code>null</code> if none found
2218 */
2219 public JDesktopPane getDesktopPane() {
2220 if(getInternalFrame() != null)
2221 return getInternalFrame().getDesktopPane();
2222 return null;
2223 }
2224
2225 /**
2226 * Notification from the <code>UIManager</code> that the look and feel
2227 * has changed.
2228 * Replaces the current UI object with the latest version from the
2229 * <code>UIManager</code>.
2230 *
2231 * @see JComponent#updateUI
2232 */
2233 public void updateUI() {
2234 boolean hadUI = (ui != null);
2235 setUI((DesktopIconUI)UIManager.getUI(this));
2236 invalidate();
2237
2238 Dimension r = getPreferredSize();
2239 setSize(r.width, r.height);
2240
2241
2242 if (internalFrame != null && internalFrame.getUI() != null) { // don't do this if UI not created yet
2243 SwingUtilities.updateComponentTreeUI(internalFrame);
2244 }
2245 }
2246
2247 /* This method is called if updateUI was called on the associated
2248 * JInternalFrame. It's necessary to avoid infinite recursion.
2249 */
2250 void updateUIWhenHidden() {
2251 /* Update this UI and any associated internal frame */
2252 setUI((DesktopIconUI)UIManager.getUI(this));
2253
2254 Dimension r = getPreferredSize();
2255 setSize(r.width, r.height);
2256
2257 invalidate();
2258 Component[] children = getComponents();
2259 if (children != null) {
2260 for (Component child : children) {
2261 SwingUtilities.updateComponentTreeUI(child);
2262 }
2263 }
2264 }
2265
2266 /**
2267 * Returns the name of the look-and-feel
2268 * class that renders this component.
2269 *
2270 * @return the string "DesktopIconUI"
2271 * @see JComponent#getUIClassID
2272 * @see UIDefaults#getUI
2273 */
2274 public String getUIClassID() {
2275 return "DesktopIconUI";
2276 }
2277 ////////////////
2278 // Serialization support
2279 ////////////////
2280 private void writeObject(ObjectOutputStream s) throws IOException {
2281 s.defaultWriteObject();
2282 if (getUIClassID().equals("DesktopIconUI")) {
2283 byte count = JComponent.getWriteObjCounter(this);
2284 JComponent.setWriteObjCounter(this, --count);
2285 if (count == 0 && ui != null) {
2286 ui.installUI(this);
2287 }
2288 }
2289 }
2290
2291 /////////////////
2292 // Accessibility support
2293 ////////////////
2294
2295 /**
2296 * Gets the AccessibleContext associated with this JDesktopIcon.
2297 * For desktop icons, the AccessibleContext takes the form of an
2298 * AccessibleJDesktopIcon.
2299 * A new AccessibleJDesktopIcon instance is created if necessary.
2300 *
2301 * @return an AccessibleJDesktopIcon that serves as the
2302 * AccessibleContext of this JDesktopIcon
2303 */
2304 public AccessibleContext getAccessibleContext() {
2305 if (accessibleContext == null) {
2306 accessibleContext = new AccessibleJDesktopIcon();
2307 }
2308 return accessibleContext;
2309 }
2310
2311 /**
2312 * This class implements accessibility support for the
2313 * <code>JInternalFrame.JDesktopIcon</code> class. It provides an
2314 * implementation of the Java Accessibility API appropriate to
2315 * desktop icon user-interface elements.
2316 * <p>
2317 * <strong>Warning:</strong>
2318 * Serialized objects of this class will not be compatible with
2319 * future Swing releases. The current serialization support is
2320 * appropriate for short term storage or RMI between applications running
2321 * the same version of Swing. As of 1.4, support for long term storage
2322 * of all JavaBeans™
2323 * has been added to the <code>java.beans</code> package.
2324 * Please see {@link java.beans.XMLEncoder}.
2325 */
2326 protected class AccessibleJDesktopIcon extends AccessibleJComponent
2327 implements AccessibleValue {
2328
2329 /**
2330 * Gets the role of this object.
2331 *
2332 * @return an instance of AccessibleRole describing the role of the
2333 * object
2334 * @see AccessibleRole
2335 */
2336 public AccessibleRole getAccessibleRole() {
2337 return AccessibleRole.DESKTOP_ICON;
2338 }
2339
2340 /**
2341 * Gets the AccessibleValue associated with this object. In the
2342 * implementation of the Java Accessibility API for this class,
2343 * returns this object, which is responsible for implementing the
2344 * <code>AccessibleValue</code> interface on behalf of itself.
2345 *
2346 * @return this object
2347 */
2348 public AccessibleValue getAccessibleValue() {
2349 return this;
2350 }
2351
2352 //
2353 // AccessibleValue methods
2354 //
2355
2356 /**
2357 * Gets the value of this object as a <code>Number</code>.
2358 *
2359 * @return value of the object -- can be <code>null</code> if this object does not
2360 * have a value
2361 */
2362 public Number getCurrentAccessibleValue() {
2363 AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
2364 AccessibleValue v = a.getAccessibleValue();
2365 if (v != null) {
2366 return v.getCurrentAccessibleValue();
2367 } else {
2368 return null;
2369 }
2370 }
2371
2372 /**
2373 * Sets the value of this object as a <code>Number</code>.
2374 *
2375 * @return <code>true</code> if the value was set
2376 */
2377 public boolean setCurrentAccessibleValue(Number n) {
2378 // TIGER - 4422535
2379 if (n == null) {
2380 return false;
2381 }
2382 AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
2383 AccessibleValue v = a.getAccessibleValue();
2384 if (v != null) {
2385 return v.setCurrentAccessibleValue(n);
2386 } else {
2387 return false;
2388 }
2389 }
2390
2391 /**
2392 * Gets the minimum value of this object as a <code>Number</code>.
2393 *
2394 * @return minimum value of the object; <code>null</code> if this object does not
2395 * have a minimum value
2396 */
2397 public Number getMinimumAccessibleValue() {
2398 AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
2399 if (a instanceof AccessibleValue) {
2400 return ((AccessibleValue)a).getMinimumAccessibleValue();
2401 } else {
2402 return null;
2403 }
2404 }
2405
2406 /**
2407 * Gets the maximum value of this object as a <code>Number</code>.
2408 *
2409 * @return maximum value of the object; <code>null</code> if this object does not
2410 * have a maximum value
2411 */
2412 public Number getMaximumAccessibleValue() {
2413 AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
2414 if (a instanceof AccessibleValue) {
2415 return ((AccessibleValue)a).getMaximumAccessibleValue();
2416 } else {
2417 return null;
2418 }
2419 }
2420
2421 } // AccessibleJDesktopIcon
2422 }
2423 }