1 /*

     2  * Copyright 1997-2006 Sun Microsystems, Inc.  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.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package javax.swing;

    27 

    28 import java.awt.*;

    29 import java.awt.event.*;

    30 

    31 import java.beans.PropertyVetoException;

    32 import java.beans.PropertyChangeEvent;

    33 import java.util.EventListener;

    34 

    35 import javax.swing.border.Border;

    36 import javax.swing.event.InternalFrameEvent;

    37 import javax.swing.event.InternalFrameListener;

    38 import javax.swing.plaf.*;

    39 

    40 import javax.accessibility.*;

    41 

    42 import java.io.ObjectOutputStream;

    43 import java.io.ObjectInputStream;

    44 import java.io.IOException;

    45 import java.lang.StringBuilder;

    46 import java.beans.PropertyChangeListener;

    47 import sun.awt.AppContext;

    48 import sun.swing.SwingUtilities2;

    49 

    50 

    51 /**

    52  * A lightweight object that provides many of the features of

    53  * a native frame, including dragging, closing, becoming an icon,

    54  * resizing, title display, and support for a menu bar.

    55  * For task-oriented documentation and examples of using internal frames,

    56  * see <a

    57  href="http://java.sun.com/docs/books/tutorial/uiswing/components/internalframe.html" target="_top">How to Use Internal Frames</a>,

    58  * a section in <em>The Java Tutorial</em>.

    59  *

    60  * <p>

    61  *

    62  * Generally,

    63  * you add <code>JInternalFrame</code>s to a <code>JDesktopPane</code>. The UI

    64  * delegates the look-and-feel-specific actions to the

    65  * <code>DesktopManager</code>

    66  * object maintained by the <code>JDesktopPane</code>.

    67  * <p>

    68  * The <code>JInternalFrame</code> content pane

    69  * is where you add child components.

    70  * As a conveniance <code>add</code> and its variants, <code>remove</code> and

    71  * <code>setLayout</code> have been overridden to forward to the

    72  * <code>contentPane</code> as necessary. This means you can write:

    73  * <pre>

    74  *       internalFrame.add(child);

    75  * </pre>

    76  * And the child will be added to the contentPane.

    77  * The content pane is actually managed by an instance of

    78  * <code>JRootPane</code>,

    79  * which also manages a layout pane, glass pane, and

    80  * optional menu bar for the internal frame. Please see the

    81  * <code>JRootPane</code>

    82  * documentation for a complete description of these components.

    83  * Refer to {@link javax.swing.RootPaneContainer}

    84  * for details on adding, removing and setting the <code>LayoutManager</code>

    85  * of a <code>JInternalFrame</code>.

    86  * <p>

    87  * <strong>Warning:</strong> Swing is not thread safe. For more

    88  * information see <a

    89  * href="package-summary.html#threading">Swing's Threading

    90  * Policy</a>.

    91  * <p>

    92  * <strong>Warning:</strong>

    93  * Serialized objects of this class will not be compatible with

    94  * future Swing releases. The current serialization support is

    95  * appropriate for short term storage or RMI between applications running

    96  * the same version of Swing.  As of 1.4, support for long term storage

    97  * of all JavaBeans<sup><font size="-2">TM</font></sup>

    98  * has been added to the <code>java.beans</code> package.

    99  * Please see {@link java.beans.XMLEncoder}.

   100  *

   101  * @see InternalFrameEvent

   102  * @see JDesktopPane

   103  * @see DesktopManager

   104  * @see JInternalFrame.JDesktopIcon

   105  * @see JRootPane

   106  * @see javax.swing.RootPaneContainer

   107  *

   108  * @author David Kloba

   109  * @author Rich Schiavi

   110  * @beaninfo

   111  *      attribute: isContainer true

   112  *      attribute: containerDelegate getContentPane

   113  *      description: A frame container which is contained within

   114  *                   another window.

   115  */

   116 public class JInternalFrame extends JComponent implements

   117         Accessible, WindowConstants,

   118         RootPaneContainer

   119 {

   120     /**

   121      * @see #getUIClassID

   122      * @see #readObject

   123      */

   124     private static final String uiClassID = "InternalFrameUI";

   125 

   126     /**

   127      * The <code>JRootPane</code> instance that manages the

   128      * content pane

   129      * and optional menu bar for this internal frame, as well as the

   130      * glass pane.

   131      *

   132      * @see JRootPane

   133      * @see RootPaneContainer

   134      */

   135     protected JRootPane rootPane;

   136 

   137     /**

   138      * If true then calls to <code>add</code> and <code>setLayout</code>

   139      * will be forwarded to the <code>contentPane</code>. This is initially

   140      * false, but is set to true when the <code>JInternalFrame</code> is

   141      * constructed.

   142      *

   143      * @see #isRootPaneCheckingEnabled

   144      * @see #setRootPaneCheckingEnabled

   145      * @see javax.swing.RootPaneContainer

   146      */

   147     protected boolean rootPaneCheckingEnabled = false;

   148 

   149     /** The frame can be closed. */

   150     protected boolean closable;

   151     /** The frame has been closed. */

   152     protected boolean isClosed;

   153     /** The frame can be expanded to the size of the desktop pane. */

   154     protected boolean maximizable;

   155     /**

   156      * The frame has been expanded to its maximum size.

   157      * @see #maximizable

   158      */

   159     protected boolean isMaximum;

   160     /**

   161      * The frame can "iconified" (shrunk down and displayed as

   162      * an icon-image).

   163      * @see JInternalFrame.JDesktopIcon

   164      * @see #setIconifiable

   165      */

   166     protected boolean iconable;

   167     /**

   168      * The frame has been iconified.

   169      * @see #isIcon()

   170      */

   171     protected boolean isIcon;

   172     /** The frame's size can be changed. */

   173     protected boolean resizable;

   174     /** The frame is currently selected. */

   175     protected boolean isSelected;

   176     /** The icon shown in the top-left corner of this internal frame. */

   177     protected Icon frameIcon;

   178     /** The title displayed in this internal frame's title bar. */

   179     protected String  title;

   180     /**

   181      * The icon that is displayed when this internal frame is iconified.

   182      * @see #iconable

   183      */

   184     protected JDesktopIcon desktopIcon;

   185 

   186     private Cursor lastCursor;

   187 

   188     private boolean opened;

   189 

   190     private Rectangle normalBounds = null;

   191 

   192     private int defaultCloseOperation = DISPOSE_ON_CLOSE;

   193 

   194     /**

   195      * Contains the Component that focus is to go when

   196      * <code>restoreSubcomponentFocus</code> is invoked, that is,

   197      * <code>restoreSubcomponentFocus</code> sets this to the value returned

   198      * from <code>getMostRecentFocusOwner</code>.

   199      */

   200     private Component lastFocusOwner;

   201 

   202     /** Bound property name. */

   203     public final static String CONTENT_PANE_PROPERTY = "contentPane";

   204     /** Bound property name. */

   205     public final static String MENU_BAR_PROPERTY = "JMenuBar";

   206     /** Bound property name. */

   207     public final static String TITLE_PROPERTY = "title";

   208     /** Bound property name. */

   209     public final static String LAYERED_PANE_PROPERTY = "layeredPane";

   210     /** Bound property name. */

   211     public final static String ROOT_PANE_PROPERTY = "rootPane";

   212     /** Bound property name. */

   213     public final static String GLASS_PANE_PROPERTY = "glassPane";

   214     /** Bound property name. */

   215     public final static String FRAME_ICON_PROPERTY = "frameIcon";

   216 

   217     /**

   218      * Constrained property name indicated that this frame has

   219      * selected status.

   220      */

   221     public final static String IS_SELECTED_PROPERTY = "selected";

   222     /** Constrained property name indicating that the internal frame is closed. */

   223     public final static String IS_CLOSED_PROPERTY = "closed";

   224     /** Constrained property name indicating that the internal frame is maximized. */

   225     public final static String IS_MAXIMUM_PROPERTY = "maximum";

   226     /** Constrained property name indicating that the internal frame is iconified. */

   227     public final static String IS_ICON_PROPERTY = "icon";

   228 

   229     private static final Object PROPERTY_CHANGE_LISTENER_KEY =

   230         new StringBuilder("InternalFramePropertyChangeListener");

   231 

   232     private static void addPropertyChangeListenerIfNecessary() {

   233         if (AppContext.getAppContext().get(PROPERTY_CHANGE_LISTENER_KEY) ==

   234             null) {

   235             PropertyChangeListener focusListener =

   236                 new FocusPropertyChangeListener();

   237 

   238             AppContext.getAppContext().put(PROPERTY_CHANGE_LISTENER_KEY,

   239                 focusListener);

   240 

   241             KeyboardFocusManager.getCurrentKeyboardFocusManager().

   242                 addPropertyChangeListener(focusListener);

   243         }

   244     }

   245 

   246     private static class FocusPropertyChangeListener implements

   247         PropertyChangeListener {

   248         public void propertyChange(PropertyChangeEvent e) {

   249             if (e.getPropertyName() == "permanentFocusOwner") {

   250                 updateLastFocusOwner((Component)e.getNewValue());

   251             }

   252         }

   253     }

   254 

   255     private static void updateLastFocusOwner(Component component) {

   256         if (component != null) {

   257             Component parent = component;

   258             while (parent != null && !(parent instanceof Window)) {

   259                 if (parent instanceof JInternalFrame) {

   260                     // Update lastFocusOwner for parent.

   261                     ((JInternalFrame)parent).setLastFocusOwner(component);

   262                 }

   263                 parent = parent.getParent();

   264             }

   265         }

   266     }

   267 

   268     /**

   269      * Creates a non-resizable, non-closable, non-maximizable,

   270      * non-iconifiable <code>JInternalFrame</code> with no title.

   271      */

   272     public JInternalFrame() {

   273         this("", false, false, false, false);

   274     }

   275 

   276     /**

   277      * Creates a non-resizable, non-closable, non-maximizable,

   278      * non-iconifiable <code>JInternalFrame</code> with the specified title.

   279      * Note that passing in a <code>null</code> <code>title</code> results in

   280      * unspecified behavior and possibly an exception.

   281      *

   282      * @param title  the non-<code>null</code> <code>String</code>

   283      *     to display in the title bar

   284      */

   285     public JInternalFrame(String title) {

   286         this(title, false, false, false, false);

   287     }

   288 

   289     /**

   290      * Creates a non-closable, non-maximizable, non-iconifiable

   291      * <code>JInternalFrame</code> with the specified title

   292      * and resizability.

   293      *

   294      * @param title      the <code>String</code> to display in the title bar

   295      * @param resizable  if <code>true</code>, the internal frame can be resized

   296      */

   297     public JInternalFrame(String title, boolean resizable) {

   298         this(title, resizable, false, false, false);

   299     }

   300 

   301     /**

   302      * Creates a non-maximizable, non-iconifiable <code>JInternalFrame</code>

   303      * with the specified title, resizability, and

   304      * closability.

   305      *

   306      * @param title      the <code>String</code> to display in the title bar

   307      * @param resizable  if <code>true</code>, the internal frame can be resized

   308      * @param closable   if <code>true</code>, the internal frame can be closed

   309      */

   310     public JInternalFrame(String title, boolean resizable, boolean closable) {

   311         this(title, resizable, closable, false, false);

   312     }

   313 

   314     /**

   315      * Creates a non-iconifiable <code>JInternalFrame</code>

   316      * with the specified title,

   317      * resizability, closability, and maximizability.

   318      *

   319      * @param title       the <code>String</code> to display in the title bar

   320      * @param resizable   if <code>true</code>, the internal frame can be resized

   321      * @param closable    if <code>true</code>, the internal frame can be closed

   322      * @param maximizable if <code>true</code>, the internal frame can be maximized

   323      */

   324     public JInternalFrame(String title, boolean resizable, boolean closable,

   325                           boolean maximizable) {

   326         this(title, resizable, closable, maximizable, false);

   327     }

   328 

   329     /**

   330      * Creates a <code>JInternalFrame</code> with the specified title,

   331      * resizability, closability, maximizability, and iconifiability.

   332      * All <code>JInternalFrame</code> constructors use this one.

   333      *

   334      * @param title       the <code>String</code> to display in the title bar

   335      * @param resizable   if <code>true</code>, the internal frame can be resized

   336      * @param closable    if <code>true</code>, the internal frame can be closed

   337      * @param maximizable if <code>true</code>, the internal frame can be maximized

   338      * @param iconifiable if <code>true</code>, the internal frame can be iconified

   339      */

   340     public JInternalFrame(String title, boolean resizable, boolean closable,

   341                                 boolean maximizable, boolean iconifiable) {

   342 

   343         setRootPane(createRootPane());

   344         setLayout(new BorderLayout());

   345         this.title = title;

   346         this.resizable = resizable;

   347         this.closable = closable;

   348         this.maximizable = maximizable;

   349         isMaximum = false;

   350         this.iconable = iconifiable;

   351         isIcon = false;

   352         setVisible(false);

   353         setRootPaneCheckingEnabled(true);

   354         desktopIcon = new JDesktopIcon(this);

   355         updateUI();

   356         sun.awt.SunToolkit.checkAndSetPolicy(this, true);

   357         addPropertyChangeListenerIfNecessary();

   358     }

   359 

   360     /**

   361      * Called by the constructor to set up the <code>JRootPane</code>.

   362      * @return  a new <code>JRootPane</code>

   363      * @see JRootPane

   364      */

   365     protected JRootPane createRootPane() {

   366         return new JRootPane();

   367     }

   368 

   369     /**

   370      * Returns the look-and-feel object that renders this component.

   371      *

   372      * @return the <code>InternalFrameUI</code> object that renders

   373      *          this component

   374      */

   375     public InternalFrameUI getUI() {

   376         return (InternalFrameUI)ui;

   377     }

   378 

   379     /**

   380      * Sets the UI delegate for this <code>JInternalFrame</code>.

   381      * @param ui  the UI delegate

   382      * @beaninfo

   383      *        bound: true

   384      *       hidden: true

   385      *    attribute: visualUpdate true

   386      *  description: The UI object that implements the Component's LookAndFeel.

   387      */

   388     public void setUI(InternalFrameUI ui) {

   389         boolean checkingEnabled = isRootPaneCheckingEnabled();

   390         try {

   391             setRootPaneCheckingEnabled(false);

   392             super.setUI(ui);

   393         }

   394         finally {

   395             setRootPaneCheckingEnabled(checkingEnabled);

   396         }

   397     }

   398 

   399     /**

   400      * Notification from the <code>UIManager</code> that the look and feel

   401      * has changed.

   402      * Replaces the current UI object with the latest version from the

   403      * <code>UIManager</code>.

   404      *

   405      * @see JComponent#updateUI

   406      */

   407     public void updateUI() {

   408         setUI((InternalFrameUI)UIManager.getUI(this));

   409         invalidate();

   410         if (desktopIcon != null) {

   411             desktopIcon.updateUIWhenHidden();

   412         }

   413     }

   414 

   415     /* This method is called if <code>updateUI</code> was called

   416      * on the associated

   417      * JDesktopIcon.  It's necessary to avoid infinite recursion.

   418      */

   419     void updateUIWhenHidden() {

   420         setUI((InternalFrameUI)UIManager.getUI(this));

   421         invalidate();

   422         Component[] children = getComponents();

   423         if (children != null) {

   424             for(int i = 0; i < children.length; i++) {

   425                 SwingUtilities.updateComponentTreeUI(children[i]);

   426             }

   427         }

   428     }

   429 

   430 

   431     /**

   432      * Returns the name of the look-and-feel

   433      * class that renders this component.

   434      *

   435      * @return the string "InternalFrameUI"

   436      *

   437      * @see JComponent#getUIClassID

   438      * @see UIDefaults#getUI

   439      *

   440      * @beaninfo

   441      *     description: UIClassID

   442      */

   443     public String getUIClassID() {

   444         return uiClassID;

   445     }

   446 

   447     /**

   448      * Returns whether calls to <code>add</code> and

   449      * <code>setLayout</code> are forwarded to the <code>contentPane</code>.

   450      *

   451      * @return true if <code>add</code> and <code>setLayout</code>

   452      *         are fowarded; false otherwise

   453      *

   454      * @see #addImpl

   455      * @see #setLayout

   456      * @see #setRootPaneCheckingEnabled

   457      * @see javax.swing.RootPaneContainer

   458      */

   459     protected boolean isRootPaneCheckingEnabled() {

   460         return rootPaneCheckingEnabled;

   461     }

   462 

   463     /**

   464      * Sets whether calls to <code>add</code> and

   465      * <code>setLayout</code> are forwarded to the <code>contentPane</code>.

   466      *

   467      * @param enabled  true if <code>add</code> and <code>setLayout</code>

   468      *        are forwarded, false if they should operate directly on the

   469      *        <code>JInternalFrame</code>.

   470      *

   471      * @see #addImpl

   472      * @see #setLayout

   473      * @see #isRootPaneCheckingEnabled

   474      * @see javax.swing.RootPaneContainer

   475      * @beaninfo

   476      *      hidden: true

   477      * description: Whether the add and setLayout methods are forwarded

   478      */

   479     protected void setRootPaneCheckingEnabled(boolean enabled) {

   480         rootPaneCheckingEnabled = enabled;

   481     }

   482 

   483     /**

   484      * Adds the specified child <code>Component</code>.

   485      * This method is overridden to conditionally forward calls to the

   486      * <code>contentPane</code>.

   487      * By default, children are added to the <code>contentPane</code> instead

   488      * of the frame, refer to {@link javax.swing.RootPaneContainer} for

   489      * details.

   490      *

   491      * @param comp the component to be enhanced

   492      * @param constraints the constraints to be respected

   493      * @param index the index

   494      * @exception IllegalArgumentException if <code>index</code> is invalid

   495      * @exception IllegalArgumentException if adding the container's parent

   496      *                  to itself

   497      * @exception IllegalArgumentException if adding a window to a container

   498      *

   499      * @see #setRootPaneCheckingEnabled

   500      * @see javax.swing.RootPaneContainer

   501      */

   502     protected void addImpl(Component comp, Object constraints, int index) {

   503         if(isRootPaneCheckingEnabled()) {

   504             getContentPane().add(comp, constraints, index);

   505         }

   506         else {

   507             super.addImpl(comp, constraints, index);

   508         }

   509     }

   510 

   511     /**

   512      * Removes the specified component from the container. If

   513      * <code>comp</code> is not a child of the <code>JInternalFrame</code>

   514      * this will forward the call to the <code>contentPane</code>.

   515      *

   516      * @param comp the component to be removed

   517      * @throws NullPointerException if <code>comp</code> is null

   518      * @see #add

   519      * @see javax.swing.RootPaneContainer

   520      */

   521     public void remove(Component comp) {

   522         int oldCount = getComponentCount();

   523         super.remove(comp);

   524         if (oldCount == getComponentCount()) {

   525             getContentPane().remove(comp);

   526         }

   527     }

   528 

   529 

   530     /**

   531      * Ensures that, by default, the layout of this component cannot be set.

   532      * Overridden to conditionally forward the call to the

   533      * <code>contentPane</code>.

   534      * Refer to {@link javax.swing.RootPaneContainer} for

   535      * more information.

   536      *

   537      * @param manager the <code>LayoutManager</code>

   538      * @see #setRootPaneCheckingEnabled

   539      */

   540     public void setLayout(LayoutManager manager) {

   541         if(isRootPaneCheckingEnabled()) {

   542             getContentPane().setLayout(manager);

   543         }

   544         else {

   545             super.setLayout(manager);

   546         }

   547     }

   548 

   549 

   550 //////////////////////////////////////////////////////////////////////////

   551 /// Property Methods

   552 //////////////////////////////////////////////////////////////////////////

   553 

   554     /**

   555      * Returns the current <code>JMenuBar</code> for this

   556      * <code>JInternalFrame</code>, or <code>null</code>

   557      * if no menu bar has been set.

   558      * @return the current menu bar, or <code>null</code> if none has been set

   559      *

   560      * @deprecated As of Swing version 1.0.3,

   561      * replaced by <code>getJMenuBar()</code>.

   562      */

   563     @Deprecated

   564     public JMenuBar getMenuBar() {

   565       return getRootPane().getMenuBar();

   566     }

   567 

   568     /**

   569      * Returns the current <code>JMenuBar</code> for this

   570      * <code>JInternalFrame</code>, or <code>null</code>

   571      * if no menu bar has been set.

   572      *

   573      * @return  the <code>JMenuBar</code> used by this internal frame

   574      * @see #setJMenuBar

   575      */

   576     public JMenuBar getJMenuBar() {

   577         return getRootPane().getJMenuBar();

   578     }

   579 

   580     /**

   581      * Sets the <code>menuBar</code> property for this <code>JInternalFrame</code>.

   582      *

   583      * @param m  the <code>JMenuBar</code> to use in this internal frame

   584      * @see #getJMenuBar

   585      * @deprecated As of Swing version 1.0.3

   586      *  replaced by <code>setJMenuBar(JMenuBar m)</code>.

   587      */

   588     @Deprecated

   589     public void setMenuBar(JMenuBar m) {

   590         JMenuBar oldValue = getMenuBar();

   591         getRootPane().setJMenuBar(m);

   592         firePropertyChange(MENU_BAR_PROPERTY, oldValue, m);

   593     }

   594 

   595     /**

   596      * Sets the <code>menuBar</code> property for this <code>JInternalFrame</code>.

   597      *

   598      * @param m  the <code>JMenuBar</code> to use in this internal frame

   599      * @see #getJMenuBar

   600      * @beaninfo

   601      *     bound: true

   602      *     preferred: true

   603      *     description: The menu bar for accessing pulldown menus

   604      *                  from this internal frame.

   605      */

   606     public void setJMenuBar(JMenuBar m){

   607         JMenuBar oldValue = getMenuBar();

   608         getRootPane().setJMenuBar(m);

   609         firePropertyChange(MENU_BAR_PROPERTY, oldValue, m);

   610     }

   611 

   612     // implements javax.swing.RootPaneContainer

   613     /**

   614      * Returns the content pane for this internal frame.

   615      * @return the content pane

   616      */

   617     public Container getContentPane() {

   618         return getRootPane().getContentPane();

   619     }

   620 

   621 

   622     /**

   623      * Sets this <code>JInternalFrame</code>'s <code>contentPane</code>

   624      * property.

   625      *

   626      * @param c  the content pane for this internal frame

   627      *

   628      * @exception java.awt.IllegalComponentStateException (a runtime

   629      *           exception) if the content pane parameter is <code>null</code>

   630      * @see RootPaneContainer#getContentPane

   631      * @beaninfo

   632      *     bound: true

   633      *     hidden: true

   634      *     description: The client area of the internal frame where child

   635      *                  components are normally inserted.

   636      */

   637     public void setContentPane(Container c) {

   638         Container oldValue = getContentPane();

   639         getRootPane().setContentPane(c);

   640         firePropertyChange(CONTENT_PANE_PROPERTY, oldValue, c);

   641     }

   642 

   643     /**

   644      * Returns the layered pane for this internal frame.

   645      *

   646      * @return a <code>JLayeredPane</code> object

   647      * @see RootPaneContainer#setLayeredPane

   648      * @see RootPaneContainer#getLayeredPane

   649      */

   650     public JLayeredPane getLayeredPane() {

   651         return getRootPane().getLayeredPane();

   652     }

   653 

   654     /**

   655      * Sets this <code>JInternalFrame</code>'s

   656      * <code>layeredPane</code> property.

   657      *

   658      * @param layered the <code>JLayeredPane</code> for this internal frame

   659      *

   660      * @exception java.awt.IllegalComponentStateException (a runtime

   661      *           exception) if the layered pane parameter is <code>null</code>

   662      * @see RootPaneContainer#setLayeredPane

   663      * @beaninfo

   664      *     hidden: true

   665      *     bound: true

   666      *     description: The pane which holds the various desktop layers.

   667      */

   668     public void setLayeredPane(JLayeredPane layered) {

   669         JLayeredPane oldValue = getLayeredPane();

   670         getRootPane().setLayeredPane(layered);

   671         firePropertyChange(LAYERED_PANE_PROPERTY, oldValue, layered);

   672     }

   673 

   674     /**

   675      * Returns the glass pane for this internal frame.

   676      *

   677      * @return the glass pane

   678      * @see RootPaneContainer#setGlassPane

   679      */

   680     public Component getGlassPane() {

   681         return getRootPane().getGlassPane();

   682     }

   683 

   684     /**

   685      * Sets this <code>JInternalFrame</code>'s

   686      * <code>glassPane</code> property.

   687      *

   688      * @param glass the glass pane for this internal frame

   689      * @see RootPaneContainer#getGlassPane

   690      * @beaninfo

   691      *     bound: true

   692      *     hidden: true

   693      *     description: A transparent pane used for menu rendering.

   694      */

   695     public void setGlassPane(Component glass) {

   696         Component oldValue = getGlassPane();

   697         getRootPane().setGlassPane(glass);

   698         firePropertyChange(GLASS_PANE_PROPERTY, oldValue, glass);

   699     }

   700 

   701     /**

   702      * Returns the <code>rootPane</code> object for this internal frame.

   703      *

   704      * @return the <code>rootPane</code> property

   705      * @see RootPaneContainer#getRootPane

   706      */

   707     public JRootPane getRootPane() {

   708         return rootPane;

   709     }

   710 

   711 

   712     /**

   713      * Sets the <code>rootPane</code> property

   714      * for this <code>JInternalFrame</code>.

   715      * This method is called by the constructor.

   716      *

   717      * @param root  the new <code>JRootPane</code> object

   718      * @beaninfo

   719      *     bound: true

   720      *     hidden: true

   721      *     description: The root pane used by this internal frame.

   722      */

   723     protected void setRootPane(JRootPane root) {

   724         if(rootPane != null) {

   725             remove(rootPane);

   726         }

   727         JRootPane oldValue = getRootPane();

   728         rootPane = root;

   729         if(rootPane != null) {

   730             boolean checkingEnabled = isRootPaneCheckingEnabled();

   731             try {

   732                 setRootPaneCheckingEnabled(false);

   733                 add(rootPane, BorderLayout.CENTER);

   734             }

   735             finally {

   736                 setRootPaneCheckingEnabled(checkingEnabled);

   737             }

   738         }

   739         firePropertyChange(ROOT_PANE_PROPERTY, oldValue, root);

   740     }

   741 

   742     /**

   743      * Sets whether this <code>JInternalFrame</code> can be closed by

   744      * some user action.

   745      * @param b a boolean value, where <code>true</code> means this internal frame can be closed

   746      * @beaninfo

   747      *     preferred: true

   748      *           bound: true

   749      *     description: Indicates whether this internal frame can be closed.

   750      */

   751     public void setClosable(boolean b) {

   752         Boolean oldValue = closable ? Boolean.TRUE : Boolean.FALSE;

   753         Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;

   754         closable = b;

   755         firePropertyChange("closable", oldValue, newValue);

   756     }

   757 

   758     /**

   759      * Returns whether this <code>JInternalFrame</code> can be closed by

   760      * some user action.

   761      * @return <code>true</code> if this internal frame can be closed

   762      */

   763     public boolean isClosable() {

   764         return closable;

   765     }

   766 

   767     /**

   768      * Returns whether this <code>JInternalFrame</code> is currently closed.

   769      * @return <code>true</code> if this internal frame is closed, <code>false</code> otherwise

   770      */

   771     public boolean isClosed() {

   772         return isClosed;

   773     }

   774 

   775     /**

   776      * Closes this internal frame if the argument is <code>true</code>.

   777      * Do not invoke this method with a <code>false</code> argument;

   778      * the result of invoking <code>setClosed(false)</code>

   779      * is unspecified.

   780      *

   781      * <p>

   782      *

   783      * If the internal frame is already closed,

   784      * this method does nothing and returns immediately.

   785      * Otherwise,

   786      * this method begins by firing

   787      * an <code>INTERNAL_FRAME_CLOSING</code> event.

   788      * Then this method sets the <code>closed</code> property to <code>true</code>

   789      * unless a listener vetoes the property change.

   790      * This method finishes by making the internal frame

   791      * invisible and unselected,

   792      * and then firing an <code>INTERNAL_FRAME_CLOSED</code> event.

   793      *

   794      * <p>

   795      *

   796      * <b>Note:</b>

   797      * To reuse an internal frame that has been closed,

   798      * you must add it to a container

   799      * (even if you never removed it from its previous container).

   800      * Typically, this container will be the <code>JDesktopPane</code>

   801      * that previously contained the internal frame.

   802      *

   803      * @param b must be <code>true</code>

   804      *

   805      * @exception PropertyVetoException when the attempt to set the

   806      *            property is vetoed by the <code>JInternalFrame</code>

   807      *

   808      * @see #isClosed()

   809      * @see #setDefaultCloseOperation

   810      * @see #dispose

   811      * @see javax.swing.event.InternalFrameEvent#INTERNAL_FRAME_CLOSING

   812      *

   813      * @beaninfo

   814      *           bound: true

   815      *     constrained: true

   816      *     description: Indicates whether this internal frame has been closed.

   817      */

   818     public void setClosed(boolean b) throws PropertyVetoException {

   819         if (isClosed == b) {

   820             return;

   821         }

   822 

   823         Boolean oldValue = isClosed ? Boolean.TRUE : Boolean.FALSE;

   824         Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;

   825         if (b) {

   826           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);

   827         }

   828         fireVetoableChange(IS_CLOSED_PROPERTY, oldValue, newValue);

   829         isClosed = b;

   830         if (isClosed) {

   831           setVisible(false);

   832         }

   833         firePropertyChange(IS_CLOSED_PROPERTY, oldValue, newValue);

   834         if (isClosed) {

   835           dispose();

   836         } else if (!opened) {

   837           /* this bogus -- we haven't defined what

   838              setClosed(false) means. */

   839           //        fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);

   840           //            opened = true;

   841         }

   842     }

   843 

   844     /**

   845      * Sets whether the <code>JInternalFrame</code> can be resized by some

   846      * user action.

   847      *

   848      * @param b  a boolean, where <code>true</code> means this internal frame can be resized

   849      * @beaninfo

   850      *     preferred: true

   851      *           bound: true

   852      *     description: Determines whether this internal frame can be resized

   853      *                  by the user.

   854      */

   855     public void setResizable(boolean b) {

   856         Boolean oldValue = resizable ? Boolean.TRUE : Boolean.FALSE;

   857         Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;

   858         resizable = b;

   859         firePropertyChange("resizable", oldValue, newValue);

   860     }

   861 

   862     /**

   863      * Returns whether the <code>JInternalFrame</code> can be resized

   864      * by some user action.

   865      *

   866      * @return <code>true</code> if this internal frame can be resized, <code>false</code> otherwise

   867      */

   868     public boolean isResizable() {

   869         // don't allow resizing when maximized.

   870         return isMaximum ? false : resizable;

   871     }

   872 

   873     /**

   874      * Sets the <code>iconable</code> property,

   875      * which must be <code>true</code>

   876      * for the user to be able to

   877      * make the <code>JInternalFrame</code> an icon.

   878      * Some look and feels might not implement iconification;

   879      * they will ignore this property.

   880      *

   881      * @param b  a boolean, where <code>true</code> means this internal frame can be iconified

   882      * @beaninfo

   883      *     preferred: true

   884                bound: true

   885      *     description: Determines whether this internal frame can be iconified.

   886      */

   887     public void setIconifiable(boolean b) {

   888         Boolean oldValue = iconable ? Boolean.TRUE : Boolean.FALSE;

   889         Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;

   890         iconable = b;

   891         firePropertyChange("iconable", oldValue, newValue);

   892     }

   893 

   894     /**

   895      * Gets the <code>iconable</code> property,

   896      * which by default is <code>false</code>.

   897      *

   898      * @return the value of the <code>iconable</code> property.

   899      *

   900      * @see #setIconifiable

   901      */

   902     public boolean isIconifiable() {

   903         return iconable;

   904     }

   905 

   906     /**

   907      * Returns whether the <code>JInternalFrame</code> is currently iconified.

   908      *

   909      * @return <code>true</code> if this internal frame is iconified

   910      */

   911     public boolean isIcon() {

   912         return isIcon;

   913     }

   914 

   915     /**

   916      * Iconifies or de-iconifies this internal frame,

   917      * if the look and feel supports iconification.

   918      * If the internal frame's state changes to iconified,

   919      * this method fires an <code>INTERNAL_FRAME_ICONIFIED</code> event.

   920      * If the state changes to de-iconified,

   921      * an <code>INTERNAL_FRAME_DEICONIFIED</code> event is fired.

   922      *

   923      * @param b a boolean, where <code>true</code> means to iconify this internal frame and

   924      *          <code>false</code> means to de-iconify it

   925      * @exception PropertyVetoException when the attempt to set the

   926      *            property is vetoed by the <code>JInternalFrame</code>

   927      *

   928      * @see InternalFrameEvent#INTERNAL_FRAME_ICONIFIED

   929      * @see InternalFrameEvent#INTERNAL_FRAME_DEICONIFIED

   930      *

   931      * @beaninfo

   932      *           bound: true

   933      *     constrained: true

   934      *     description: The image displayed when this internal frame is minimized.

   935      */

   936     public void setIcon(boolean b) throws PropertyVetoException {

   937         if (isIcon == b) {

   938             return;

   939         }

   940 

   941         /* If an internal frame is being iconified before it has a

   942            parent, (e.g., client wants it to start iconic), create the

   943            parent if possible so that we can place the icon in its

   944            proper place on the desktop. I am not sure the call to

   945            validate() is necessary, since we are not going to display

   946            this frame yet */

   947         firePropertyChange("ancestor", null, getParent());

   948 

   949         Boolean oldValue = isIcon ? Boolean.TRUE : Boolean.FALSE;

   950         Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;

   951         fireVetoableChange(IS_ICON_PROPERTY, oldValue, newValue);

   952         isIcon = b;

   953         firePropertyChange(IS_ICON_PROPERTY, oldValue, newValue);

   954         if (b)

   955           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED);

   956         else

   957           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);

   958     }

   959 

   960     /**

   961      * Sets the <code>maximizable</code> property,

   962      * which determines whether the <code>JInternalFrame</code>

   963      * can be maximized by

   964      * some user action.

   965      * Some look and feels might not support maximizing internal frames;

   966      * they will ignore this property.

   967      *

   968      * @param b <code>true</code> to specify that this internal frame should be maximizable; <code>false</code> to specify that it should not be

   969      * @beaninfo

   970      *         bound: true

   971      *     preferred: true

   972      *     description: Determines whether this internal frame can be maximized.

   973      */

   974     public void setMaximizable(boolean b) {

   975         Boolean oldValue = maximizable ? Boolean.TRUE : Boolean.FALSE;

   976         Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;

   977         maximizable = b;

   978         firePropertyChange("maximizable", oldValue, newValue);

   979     }

   980 

   981     /**

   982      * Gets the value of the <code>maximizable</code> property.

   983      *

   984      * @return the value of the <code>maximizable</code> property

   985      * @see #setMaximizable

   986      */

   987     public boolean isMaximizable() {

   988         return maximizable;

   989     }

   990 

   991     /**

   992      * Returns whether the <code>JInternalFrame</code> is currently maximized.

   993      *

   994      * @return <code>true</code> if this internal frame is maximized, <code>false</code> otherwise

   995      */

   996     public boolean isMaximum() {

   997         return isMaximum;

   998     }

   999 

  1000     /**

  1001      * Maximizes and restores this internal frame.  A maximized frame is resized to

  1002      * fully fit the <code>JDesktopPane</code> area associated with the

  1003      * <code>JInternalFrame</code>.

  1004      * A restored frame's size is set to the <code>JInternalFrame</code>'s

  1005      * actual size.

  1006      *

  1007      * @param b  a boolean, where <code>true</code> maximizes this internal frame and <code>false</code>

  1008      *           restores it

  1009      * @exception PropertyVetoException when the attempt to set the

  1010      *            property is vetoed by the <code>JInternalFrame</code>

  1011      * @beaninfo

  1012      *     bound: true

  1013      *     constrained: true

  1014      *     description: Indicates whether this internal frame is maximized.

  1015      */

  1016     public void setMaximum(boolean b) throws PropertyVetoException {

  1017         if (isMaximum == b) {

  1018             return;

  1019         }

  1020 

  1021         Boolean oldValue = isMaximum ? Boolean.TRUE : Boolean.FALSE;

  1022         Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;

  1023         fireVetoableChange(IS_MAXIMUM_PROPERTY, oldValue, newValue);

  1024         /* setting isMaximum above the event firing means that

  1025            property listeners that, for some reason, test it will

  1026            get it wrong... See, for example, getNormalBounds() */

  1027         isMaximum = b;

  1028         firePropertyChange(IS_MAXIMUM_PROPERTY, oldValue, newValue);

  1029     }

  1030 

  1031     /**

  1032      * Returns the title of the <code>JInternalFrame</code>.

  1033      *

  1034      * @return a <code>String</code> containing this internal frame's title

  1035      * @see #setTitle

  1036      */

  1037     public String getTitle() {

  1038         return title;

  1039     }

  1040 

  1041     /**

  1042      * Sets the <code>JInternalFrame</code> title. <code>title</code>

  1043      * may have a <code>null</code> value.

  1044      * @see #getTitle

  1045      *

  1046      * @param title  the <code>String</code> to display in the title bar

  1047      * @beaninfo

  1048      *     preferred: true

  1049      *     bound: true

  1050      *     description: The text displayed in the title bar.

  1051      */

  1052     public void setTitle(String title) {

  1053         String oldValue = this.title;

  1054         this.title = title;

  1055         firePropertyChange(TITLE_PROPERTY, oldValue, title);

  1056     }

  1057 

  1058     /**

  1059      * Selects or deselects the internal frame

  1060      * if it's showing.

  1061      * A <code>JInternalFrame</code> normally draws its title bar

  1062      * differently if it is

  1063      * the selected frame, which indicates to the user that this

  1064      * internal frame has the focus.

  1065      * When this method changes the state of the internal frame

  1066      * from deselected to selected, it fires an

  1067      * <code>InternalFrameEvent.INTERNAL_FRAME_ACTIVATED</code> event.

  1068      * If the change is from selected to deselected,

  1069      * an <code>InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED</code> event

  1070      * is fired.

  1071      *

  1072      * @param selected  a boolean, where <code>true</code> means this internal frame

  1073      *                  should become selected (currently active)

  1074      *                  and <code>false</code> means it should become deselected

  1075      * @exception PropertyVetoException when the attempt to set the

  1076      *            property is vetoed by the <code>JInternalFrame</code>

  1077      *

  1078      * @see #isShowing

  1079      * @see InternalFrameEvent#INTERNAL_FRAME_ACTIVATED

  1080      * @see InternalFrameEvent#INTERNAL_FRAME_DEACTIVATED

  1081      *

  1082      * @beaninfo

  1083      *     constrained: true

  1084      *           bound: true

  1085      *     description: Indicates whether this internal frame is currently

  1086      *                  the active frame.

  1087      */

  1088     public void setSelected(boolean selected) throws PropertyVetoException {

  1089        // The InternalFrame may already be selected, but the focus

  1090        // may be outside it, so restore the focus to the subcomponent

  1091        // which previously had it. See Bug 4302764.

  1092         if (selected && isSelected) {

  1093             restoreSubcomponentFocus();

  1094             return;

  1095         }

  1096         // The internal frame or the desktop icon must be showing to allow

  1097         // selection.  We may deselect even if neither is showing.

  1098         if ((isSelected == selected) || (selected &&

  1099             (isIcon ? !desktopIcon.isShowing() : !isShowing()))) {

  1100             return;

  1101         }

  1102 

  1103         Boolean oldValue = isSelected ? Boolean.TRUE : Boolean.FALSE;

  1104         Boolean newValue = selected ? Boolean.TRUE : Boolean.FALSE;

  1105         fireVetoableChange(IS_SELECTED_PROPERTY, oldValue, newValue);

  1106 

  1107         /* We don't want to leave focus in the previously selected

  1108            frame, so we have to set it to *something* in case it

  1109            doesn't get set in some other way (as if a user clicked on

  1110            a component that doesn't request focus).  If this call is

  1111            happening because the user clicked on a component that will

  1112            want focus, then it will get transfered there later.

  1113 

  1114            We test for parent.isShowing() above, because AWT throws a

  1115            NPE if you try to request focus on a lightweight before its

  1116            parent has been made visible */

  1117 

  1118         if (selected) {

  1119             restoreSubcomponentFocus();

  1120         }

  1121 

  1122         isSelected = selected;

  1123         firePropertyChange(IS_SELECTED_PROPERTY, oldValue, newValue);

  1124         if (isSelected)

  1125           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED);

  1126         else

  1127           fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED);

  1128         repaint();

  1129     }

  1130 

  1131     /**

  1132      * Returns whether the <code>JInternalFrame</code> is the

  1133      * currently "selected" or active frame.

  1134      *

  1135      * @return <code>true</code> if this internal frame is currently selected (active)