--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.desktop/share/classes/javax/swing/JInternalFrame.java Sun Aug 17 15:54:13 2014 +0100
@@ -0,0 +1,2428 @@
+/*
+ * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package javax.swing;
+
+import java.awt.*;
+
+import java.beans.PropertyVetoException;
+import java.beans.PropertyChangeEvent;
+
+import javax.swing.event.InternalFrameEvent;
+import javax.swing.event.InternalFrameListener;
+import javax.swing.plaf.*;
+
+import javax.accessibility.*;
+
+import java.io.ObjectOutputStream;
+import java.io.IOException;
+import java.lang.StringBuilder;
+import java.beans.PropertyChangeListener;
+import sun.awt.AppContext;
+import sun.swing.SwingUtilities2;
+
+
+/**
+ * A lightweight object that provides many of the features of
+ * a native frame, including dragging, closing, becoming an icon,
+ * resizing, title display, and support for a menu bar.
+ * For task-oriented documentation and examples of using internal frames,
+ * see <a
+ href="http://docs.oracle.com/javase/tutorial/uiswing/components/internalframe.html" target="_top">How to Use Internal Frames</a>,
+ * a section in <em>The Java Tutorial</em>.
+ *
+ * <p>
+ *
+ * Generally,
+ * you add <code>JInternalFrame</code>s to a <code>JDesktopPane</code>. The UI
+ * delegates the look-and-feel-specific actions to the
+ * <code>DesktopManager</code>
+ * object maintained by the <code>JDesktopPane</code>.
+ * <p>
+ * The <code>JInternalFrame</code> content pane
+ * is where you add child components.
+ * As a convenience, the {@code add}, {@code remove}, and {@code setLayout}
+ * methods of this class are overridden, so that they delegate calls
+ * to the corresponding methods of the {@code ContentPane}.
+ * For example, you can add a child component to an internal frame as follows:
+ * <pre>
+ * internalFrame.add(child);
+ * </pre>
+ * And the child will be added to the contentPane.
+ * The content pane is actually managed by an instance of
+ * <code>JRootPane</code>,
+ * which also manages a layout pane, glass pane, and
+ * optional menu bar for the internal frame. Please see the
+ * <code>JRootPane</code>
+ * documentation for a complete description of these components.
+ * Refer to {@link javax.swing.RootPaneContainer}
+ * for details on adding, removing and setting the <code>LayoutManager</code>
+ * of a <code>JInternalFrame</code>.
+ * <p>
+ * <strong>Warning:</strong> Swing is not thread safe. For more
+ * information see <a
+ * href="package-summary.html#threading">Swing's Threading
+ * Policy</a>.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing. As of 1.4, support for long term storage
+ * of all JavaBeans™
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ *
+ * @see InternalFrameEvent
+ * @see JDesktopPane
+ * @see DesktopManager
+ * @see JInternalFrame.JDesktopIcon
+ * @see JRootPane
+ * @see javax.swing.RootPaneContainer
+ *
+ * @author David Kloba
+ * @author Rich Schiavi
+ * @since 1.2
+ * @beaninfo
+ * attribute: isContainer true
+ * attribute: containerDelegate getContentPane
+ * description: A frame container which is contained within
+ * another window.
+ */
+@SuppressWarnings("serial") // Same-version serialization only
+public class JInternalFrame extends JComponent implements
+ Accessible, WindowConstants,
+ RootPaneContainer
+{
+ /**
+ * @see #getUIClassID
+ * @see #readObject
+ */
+ private static final String uiClassID = "InternalFrameUI";
+
+ /**
+ * The <code>JRootPane</code> instance that manages the
+ * content pane
+ * and optional menu bar for this internal frame, as well as the
+ * glass pane.
+ *
+ * @see JRootPane
+ * @see RootPaneContainer
+ */
+ protected JRootPane rootPane;
+
+ /**
+ * If true then calls to <code>add</code> and <code>setLayout</code>
+ * will be forwarded to the <code>contentPane</code>. This is initially
+ * false, but is set to true when the <code>JInternalFrame</code> is
+ * constructed.
+ *
+ * @see #isRootPaneCheckingEnabled
+ * @see #setRootPaneCheckingEnabled
+ * @see javax.swing.RootPaneContainer
+ */
+ protected boolean rootPaneCheckingEnabled = false;
+
+ /** The frame can be closed. */
+ protected boolean closable;
+ /** The frame has been closed. */
+ protected boolean isClosed;
+ /** The frame can be expanded to the size of the desktop pane. */
+ protected boolean maximizable;
+ /**
+ * The frame has been expanded to its maximum size.
+ * @see #maximizable
+ */
+ protected boolean isMaximum;
+ /**
+ * The frame can "iconified" (shrunk down and displayed as
+ * an icon-image).
+ * @see JInternalFrame.JDesktopIcon
+ * @see #setIconifiable
+ */
+ protected boolean iconable;
+ /**
+ * The frame has been iconified.
+ * @see #isIcon()
+ */
+ protected boolean isIcon;
+ /** The frame's size can be changed. */
+ protected boolean resizable;
+ /** The frame is currently selected. */
+ protected boolean isSelected;
+ /** The icon shown in the top-left corner of this internal frame. */
+ protected Icon frameIcon;
+ /** The title displayed in this internal frame's title bar. */
+ protected String title;
+ /**
+ * The icon that is displayed when this internal frame is iconified.
+ * @see #iconable
+ */
+ protected JDesktopIcon desktopIcon;
+
+ private Cursor lastCursor;
+
+ private boolean opened;
+
+ private Rectangle normalBounds = null;
+
+ private int defaultCloseOperation = DISPOSE_ON_CLOSE;
+
+ /**
+ * Contains the Component that focus is to go when
+ * <code>restoreSubcomponentFocus</code> is invoked, that is,
+ * <code>restoreSubcomponentFocus</code> sets this to the value returned
+ * from <code>getMostRecentFocusOwner</code>.
+ */
+ private Component lastFocusOwner;
+
+ /** Bound property name. */
+ public final static String CONTENT_PANE_PROPERTY = "contentPane";
+ /** Bound property name. */
+ public final static String MENU_BAR_PROPERTY = "JMenuBar";
+ /** Bound property name. */
+ public final static String TITLE_PROPERTY = "title";
+ /** Bound property name. */
+ public final static String LAYERED_PANE_PROPERTY = "layeredPane";
+ /** Bound property name. */
+ public final static String ROOT_PANE_PROPERTY = "rootPane";
+ /** Bound property name. */
+ public final static String GLASS_PANE_PROPERTY = "glassPane";
+ /** Bound property name. */
+ public final static String FRAME_ICON_PROPERTY = "frameIcon";
+
+ /**
+ * Constrained property name indicated that this frame has
+ * selected status.
+ */
+ public final static String IS_SELECTED_PROPERTY = "selected";
+ /** Constrained property name indicating that the internal frame is closed. */
+ public final static String IS_CLOSED_PROPERTY = "closed";
+ /** Constrained property name indicating that the internal frame is maximized. */
+ public final static String IS_MAXIMUM_PROPERTY = "maximum";
+ /** Constrained property name indicating that the internal frame is iconified. */
+ public final static String IS_ICON_PROPERTY = "icon";
+
+ private static final Object PROPERTY_CHANGE_LISTENER_KEY =
+ new StringBuilder("InternalFramePropertyChangeListener");
+
+ private static void addPropertyChangeListenerIfNecessary() {
+ if (AppContext.getAppContext().get(PROPERTY_CHANGE_LISTENER_KEY) ==
+ null) {
+ PropertyChangeListener focusListener =
+ new FocusPropertyChangeListener();
+
+ AppContext.getAppContext().put(PROPERTY_CHANGE_LISTENER_KEY,
+ focusListener);
+
+ KeyboardFocusManager.getCurrentKeyboardFocusManager().
+ addPropertyChangeListener(focusListener);
+ }
+ }
+
+ private static class FocusPropertyChangeListener implements
+ PropertyChangeListener {
+ public void propertyChange(PropertyChangeEvent e) {
+ if (e.getPropertyName() == "permanentFocusOwner") {
+ updateLastFocusOwner((Component)e.getNewValue());
+ }
+ }
+ }
+
+ private static void updateLastFocusOwner(Component component) {
+ if (component != null) {
+ Component parent = component;
+ while (parent != null && !(parent instanceof Window)) {
+ if (parent instanceof JInternalFrame) {
+ // Update lastFocusOwner for parent.
+ ((JInternalFrame)parent).setLastFocusOwner(component);
+ }
+ parent = parent.getParent();
+ }
+ }
+ }
+
+ /**
+ * Creates a non-resizable, non-closable, non-maximizable,
+ * non-iconifiable <code>JInternalFrame</code> with no title.
+ */
+ public JInternalFrame() {
+ this("", false, false, false, false);
+ }
+
+ /**
+ * Creates a non-resizable, non-closable, non-maximizable,
+ * non-iconifiable <code>JInternalFrame</code> with the specified title.
+ * Note that passing in a <code>null</code> <code>title</code> results in
+ * unspecified behavior and possibly an exception.
+ *
+ * @param title the non-<code>null</code> <code>String</code>
+ * to display in the title bar
+ */
+ public JInternalFrame(String title) {
+ this(title, false, false, false, false);
+ }
+
+ /**
+ * Creates a non-closable, non-maximizable, non-iconifiable
+ * <code>JInternalFrame</code> with the specified title
+ * and resizability.
+ *
+ * @param title the <code>String</code> to display in the title bar
+ * @param resizable if <code>true</code>, the internal frame can be resized
+ */
+ public JInternalFrame(String title, boolean resizable) {
+ this(title, resizable, false, false, false);
+ }
+
+ /**
+ * Creates a non-maximizable, non-iconifiable <code>JInternalFrame</code>
+ * with the specified title, resizability, and
+ * closability.
+ *
+ * @param title the <code>String</code> to display in the title bar
+ * @param resizable if <code>true</code>, the internal frame can be resized
+ * @param closable if <code>true</code>, the internal frame can be closed
+ */
+ public JInternalFrame(String title, boolean resizable, boolean closable) {
+ this(title, resizable, closable, false, false);
+ }
+
+ /**
+ * Creates a non-iconifiable <code>JInternalFrame</code>
+ * with the specified title,
+ * resizability, closability, and maximizability.
+ *
+ * @param title the <code>String</code> to display in the title bar
+ * @param resizable if <code>true</code>, the internal frame can be resized
+ * @param closable if <code>true</code>, the internal frame can be closed
+ * @param maximizable if <code>true</code>, the internal frame can be maximized
+ */
+ public JInternalFrame(String title, boolean resizable, boolean closable,
+ boolean maximizable) {
+ this(title, resizable, closable, maximizable, false);
+ }
+
+ /**
+ * Creates a <code>JInternalFrame</code> with the specified title,
+ * resizability, closability, maximizability, and iconifiability.
+ * All <code>JInternalFrame</code> constructors use this one.
+ *
+ * @param title the <code>String</code> to display in the title bar
+ * @param resizable if <code>true</code>, the internal frame can be resized
+ * @param closable if <code>true</code>, the internal frame can be closed
+ * @param maximizable if <code>true</code>, the internal frame can be maximized
+ * @param iconifiable if <code>true</code>, the internal frame can be iconified
+ */
+ public JInternalFrame(String title, boolean resizable, boolean closable,
+ boolean maximizable, boolean iconifiable) {
+
+ setRootPane(createRootPane());
+ setLayout(new BorderLayout());
+ this.title = title;
+ this.resizable = resizable;
+ this.closable = closable;
+ this.maximizable = maximizable;
+ isMaximum = false;
+ this.iconable = iconifiable;
+ isIcon = false;
+ setVisible(false);
+ setRootPaneCheckingEnabled(true);
+ desktopIcon = new JDesktopIcon(this);
+ updateUI();
+ sun.awt.SunToolkit.checkAndSetPolicy(this);
+ addPropertyChangeListenerIfNecessary();
+ }
+
+ /**
+ * Called by the constructor to set up the <code>JRootPane</code>.
+ * @return a new <code>JRootPane</code>
+ * @see JRootPane
+ */
+ protected JRootPane createRootPane() {
+ return new JRootPane();
+ }
+
+ /**
+ * Returns the look-and-feel object that renders this component.
+ *
+ * @return the <code>InternalFrameUI</code> object that renders
+ * this component
+ */
+ public InternalFrameUI getUI() {
+ return (InternalFrameUI)ui;
+ }
+
+ /**
+ * Sets the UI delegate for this <code>JInternalFrame</code>.
+ * @param ui the UI delegate
+ * @beaninfo
+ * bound: true
+ * hidden: true
+ * attribute: visualUpdate true
+ * description: The UI object that implements the Component's LookAndFeel.
+ */
+ public void setUI(InternalFrameUI ui) {
+ boolean checkingEnabled = isRootPaneCheckingEnabled();
+ try {
+ setRootPaneCheckingEnabled(false);
+ super.setUI(ui);
+ }
+ finally {
+ setRootPaneCheckingEnabled(checkingEnabled);
+ }
+ }
+
+ /**
+ * Notification from the <code>UIManager</code> that the look and feel
+ * has changed.
+ * Replaces the current UI object with the latest version from the
+ * <code>UIManager</code>.
+ *
+ * @see JComponent#updateUI
+ */
+ public void updateUI() {
+ setUI((InternalFrameUI)UIManager.getUI(this));
+ invalidate();
+ if (desktopIcon != null) {
+ desktopIcon.updateUIWhenHidden();
+ }
+ }
+
+ /* This method is called if <code>updateUI</code> was called
+ * on the associated
+ * JDesktopIcon. It's necessary to avoid infinite recursion.
+ */
+ void updateUIWhenHidden() {
+ setUI((InternalFrameUI)UIManager.getUI(this));
+ invalidate();
+ Component[] children = getComponents();
+ if (children != null) {
+ for (Component child : children) {
+ SwingUtilities.updateComponentTreeUI(child);
+ }
+ }
+ }
+
+
+ /**
+ * Returns the name of the look-and-feel
+ * class that renders this component.
+ *
+ * @return the string "InternalFrameUI"
+ *
+ * @see JComponent#getUIClassID
+ * @see UIDefaults#getUI
+ *
+ * @beaninfo
+ * description: UIClassID
+ */
+ public String getUIClassID() {
+ return uiClassID;
+ }
+
+ /**
+ * Returns whether calls to <code>add</code> and
+ * <code>setLayout</code> are forwarded to the <code>contentPane</code>.
+ *
+ * @return true if <code>add</code> and <code>setLayout</code>
+ * are forwarded; false otherwise
+ *
+ * @see #addImpl
+ * @see #setLayout
+ * @see #setRootPaneCheckingEnabled
+ * @see javax.swing.RootPaneContainer
+ */
+ protected boolean isRootPaneCheckingEnabled() {
+ return rootPaneCheckingEnabled;
+ }
+
+ /**
+ * Sets whether calls to <code>add</code> and
+ * <code>setLayout</code> are forwarded to the <code>contentPane</code>.
+ *
+ * @param enabled true if <code>add</code> and <code>setLayout</code>
+ * are forwarded, false if they should operate directly on the
+ * <code>JInternalFrame</code>.
+ *
+ * @see #addImpl
+ * @see #setLayout
+ * @see #isRootPaneCheckingEnabled
+ * @see javax.swing.RootPaneContainer
+ * @beaninfo
+ * hidden: true
+ * description: Whether the add and setLayout methods are forwarded
+ */
+ protected void setRootPaneCheckingEnabled(boolean enabled) {
+ rootPaneCheckingEnabled = enabled;
+ }
+
+ /**
+ * Adds the specified child <code>Component</code>.
+ * This method is overridden to conditionally forward calls to the
+ * <code>contentPane</code>.
+ * By default, children are added to the <code>contentPane</code> instead
+ * of the frame, refer to {@link javax.swing.RootPaneContainer} for
+ * details.
+ *
+ * @param comp the component to be enhanced
+ * @param constraints the constraints to be respected
+ * @param index the index
+ * @exception IllegalArgumentException if <code>index</code> is invalid
+ * @exception IllegalArgumentException if adding the container's parent
+ * to itself
+ * @exception IllegalArgumentException if adding a window to a container
+ *
+ * @see #setRootPaneCheckingEnabled
+ * @see javax.swing.RootPaneContainer
+ */
+ protected void addImpl(Component comp, Object constraints, int index) {
+ if(isRootPaneCheckingEnabled()) {
+ getContentPane().add(comp, constraints, index);
+ }
+ else {
+ super.addImpl(comp, constraints, index);
+ }
+ }
+
+ /**
+ * Removes the specified component from the container. If
+ * <code>comp</code> is not a child of the <code>JInternalFrame</code>
+ * this will forward the call to the <code>contentPane</code>.
+ *
+ * @param comp the component to be removed
+ * @throws NullPointerException if <code>comp</code> is null
+ * @see #add
+ * @see javax.swing.RootPaneContainer
+ */
+ public void remove(Component comp) {
+ int oldCount = getComponentCount();
+ super.remove(comp);
+ if (oldCount == getComponentCount()) {
+ getContentPane().remove(comp);
+ }
+ }
+
+
+ /**
+ * Ensures that, by default, the layout of this component cannot be set.
+ * Overridden to conditionally forward the call to the
+ * <code>contentPane</code>.
+ * Refer to {@link javax.swing.RootPaneContainer} for
+ * more information.
+ *
+ * @param manager the <code>LayoutManager</code>
+ * @see #setRootPaneCheckingEnabled
+ */
+ public void setLayout(LayoutManager manager) {
+ if(isRootPaneCheckingEnabled()) {
+ getContentPane().setLayout(manager);
+ }
+ else {
+ super.setLayout(manager);
+ }
+ }
+
+
+//////////////////////////////////////////////////////////////////////////
+/// Property Methods
+//////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Returns the current <code>JMenuBar</code> for this
+ * <code>JInternalFrame</code>, or <code>null</code>
+ * if no menu bar has been set.
+ * @return the current menu bar, or <code>null</code> if none has been set
+ *
+ * @deprecated As of Swing version 1.0.3,
+ * replaced by <code>getJMenuBar()</code>.
+ */
+ @Deprecated
+ public JMenuBar getMenuBar() {
+ return getRootPane().getMenuBar();
+ }
+
+ /**
+ * Returns the current <code>JMenuBar</code> for this
+ * <code>JInternalFrame</code>, or <code>null</code>
+ * if no menu bar has been set.
+ *
+ * @return the <code>JMenuBar</code> used by this internal frame
+ * @see #setJMenuBar
+ */
+ public JMenuBar getJMenuBar() {
+ return getRootPane().getJMenuBar();
+ }
+
+ /**
+ * Sets the <code>menuBar</code> property for this <code>JInternalFrame</code>.
+ *
+ * @param m the <code>JMenuBar</code> to use in this internal frame
+ * @see #getJMenuBar
+ * @deprecated As of Swing version 1.0.3
+ * replaced by <code>setJMenuBar(JMenuBar m)</code>.
+ */
+ @Deprecated
+ public void setMenuBar(JMenuBar m) {
+ JMenuBar oldValue = getMenuBar();
+ getRootPane().setJMenuBar(m);
+ firePropertyChange(MENU_BAR_PROPERTY, oldValue, m);
+ }
+
+ /**
+ * Sets the <code>menuBar</code> property for this <code>JInternalFrame</code>.
+ *
+ * @param m the <code>JMenuBar</code> to use in this internal frame
+ * @see #getJMenuBar
+ * @beaninfo
+ * bound: true
+ * preferred: true
+ * description: The menu bar for accessing pulldown menus
+ * from this internal frame.
+ */
+ public void setJMenuBar(JMenuBar m){
+ JMenuBar oldValue = getMenuBar();
+ getRootPane().setJMenuBar(m);
+ firePropertyChange(MENU_BAR_PROPERTY, oldValue, m);
+ }
+
+ // implements javax.swing.RootPaneContainer
+ /**
+ * Returns the content pane for this internal frame.
+ * @return the content pane
+ */
+ public Container getContentPane() {
+ return getRootPane().getContentPane();
+ }
+
+
+ /**
+ * Sets this <code>JInternalFrame</code>'s <code>contentPane</code>
+ * property.
+ *
+ * @param c the content pane for this internal frame
+ *
+ * @exception java.awt.IllegalComponentStateException (a runtime
+ * exception) if the content pane parameter is <code>null</code>
+ * @see RootPaneContainer#getContentPane
+ * @beaninfo
+ * bound: true
+ * hidden: true
+ * description: The client area of the internal frame where child
+ * components are normally inserted.
+ */
+ public void setContentPane(Container c) {
+ Container oldValue = getContentPane();
+ getRootPane().setContentPane(c);
+ firePropertyChange(CONTENT_PANE_PROPERTY, oldValue, c);
+ }
+
+ /**
+ * Returns the layered pane for this internal frame.
+ *
+ * @return a <code>JLayeredPane</code> object
+ * @see RootPaneContainer#setLayeredPane
+ * @see RootPaneContainer#getLayeredPane
+ */
+ public JLayeredPane getLayeredPane() {
+ return getRootPane().getLayeredPane();
+ }
+
+ /**
+ * Sets this <code>JInternalFrame</code>'s
+ * <code>layeredPane</code> property.
+ *
+ * @param layered the <code>JLayeredPane</code> for this internal frame
+ *
+ * @exception java.awt.IllegalComponentStateException (a runtime
+ * exception) if the layered pane parameter is <code>null</code>
+ * @see RootPaneContainer#setLayeredPane
+ * @beaninfo
+ * hidden: true
+ * bound: true
+ * description: The pane which holds the various desktop layers.
+ */
+ public void setLayeredPane(JLayeredPane layered) {
+ JLayeredPane oldValue = getLayeredPane();
+ getRootPane().setLayeredPane(layered);
+ firePropertyChange(LAYERED_PANE_PROPERTY, oldValue, layered);
+ }
+
+ /**
+ * Returns the glass pane for this internal frame.
+ *
+ * @return the glass pane
+ * @see RootPaneContainer#setGlassPane
+ */
+ public Component getGlassPane() {
+ return getRootPane().getGlassPane();
+ }
+
+ /**
+ * Sets this <code>JInternalFrame</code>'s
+ * <code>glassPane</code> property.
+ *
+ * @param glass the glass pane for this internal frame
+ * @see RootPaneContainer#getGlassPane
+ * @beaninfo
+ * bound: true
+ * hidden: true
+ * description: A transparent pane used for menu rendering.
+ */
+ public void setGlassPane(Component glass) {
+ Component oldValue = getGlassPane();
+ getRootPane().setGlassPane(glass);
+ firePropertyChange(GLASS_PANE_PROPERTY, oldValue, glass);
+ }
+
+ /**
+ * Returns the <code>rootPane</code> object for this internal frame.
+ *
+ * @return the <code>rootPane</code> property
+ * @see RootPaneContainer#getRootPane
+ */
+ public JRootPane getRootPane() {
+ return rootPane;
+ }
+
+
+ /**
+ * Sets the <code>rootPane</code> property
+ * for this <code>JInternalFrame</code>.
+ * This method is called by the constructor.
+ *
+ * @param root the new <code>JRootPane</code> object
+ * @beaninfo
+ * bound: true
+ * hidden: true
+ * description: The root pane used by this internal frame.
+ */
+ protected void setRootPane(JRootPane root) {
+ if(rootPane != null) {
+ remove(rootPane);
+ }
+ JRootPane oldValue = getRootPane();
+ rootPane = root;
+ if(rootPane != null) {
+ boolean checkingEnabled = isRootPaneCheckingEnabled();
+ try {
+ setRootPaneCheckingEnabled(false);
+ add(rootPane, BorderLayout.CENTER);
+ }
+ finally {
+ setRootPaneCheckingEnabled(checkingEnabled);
+ }
+ }
+ firePropertyChange(ROOT_PANE_PROPERTY, oldValue, root);
+ }
+
+ /**
+ * Sets whether this <code>JInternalFrame</code> can be closed by
+ * some user action.
+ * @param b a boolean value, where <code>true</code> means this internal frame can be closed
+ * @beaninfo
+ * preferred: true
+ * bound: true
+ * description: Indicates whether this internal frame can be closed.
+ */
+ public void setClosable(boolean b) {
+ Boolean oldValue = closable ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
+ closable = b;
+ firePropertyChange("closable", oldValue, newValue);
+ }
+
+ /**
+ * Returns whether this <code>JInternalFrame</code> can be closed by
+ * some user action.
+ * @return <code>true</code> if this internal frame can be closed
+ */
+ public boolean isClosable() {
+ return closable;
+ }
+
+ /**
+ * Returns whether this <code>JInternalFrame</code> is currently closed.
+ * @return <code>true</code> if this internal frame is closed, <code>false</code> otherwise
+ */
+ public boolean isClosed() {
+ return isClosed;
+ }
+
+ /**
+ * Closes this internal frame if the argument is <code>true</code>.
+ * Do not invoke this method with a <code>false</code> argument;
+ * the result of invoking <code>setClosed(false)</code>
+ * is unspecified.
+ *
+ * <p>
+ *
+ * If the internal frame is already closed,
+ * this method does nothing and returns immediately.
+ * Otherwise,
+ * this method begins by firing
+ * an <code>INTERNAL_FRAME_CLOSING</code> event.
+ * Then this method sets the <code>closed</code> property to <code>true</code>
+ * unless a listener vetoes the property change.
+ * This method finishes by making the internal frame
+ * invisible and unselected,
+ * and then firing an <code>INTERNAL_FRAME_CLOSED</code> event.
+ *
+ * <p>
+ *
+ * <b>Note:</b>
+ * To reuse an internal frame that has been closed,
+ * you must add it to a container
+ * (even if you never removed it from its previous container).
+ * Typically, this container will be the <code>JDesktopPane</code>
+ * that previously contained the internal frame.
+ *
+ * @param b must be <code>true</code>
+ *
+ * @exception PropertyVetoException when the attempt to set the
+ * property is vetoed by the <code>JInternalFrame</code>
+ *
+ * @see #isClosed()
+ * @see #setDefaultCloseOperation
+ * @see #dispose
+ * @see javax.swing.event.InternalFrameEvent#INTERNAL_FRAME_CLOSING
+ *
+ * @beaninfo
+ * bound: true
+ * constrained: true
+ * description: Indicates whether this internal frame has been closed.
+ */
+ public void setClosed(boolean b) throws PropertyVetoException {
+ if (isClosed == b) {
+ return;
+ }
+
+ Boolean oldValue = isClosed ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
+ if (b) {
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+ }
+ fireVetoableChange(IS_CLOSED_PROPERTY, oldValue, newValue);
+ isClosed = b;
+ if (isClosed) {
+ setVisible(false);
+ }
+ firePropertyChange(IS_CLOSED_PROPERTY, oldValue, newValue);
+ if (isClosed) {
+ dispose();
+ } else if (!opened) {
+ /* this bogus -- we haven't defined what
+ setClosed(false) means. */
+ // fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
+ // opened = true;
+ }
+ }
+
+ /**
+ * Sets whether the <code>JInternalFrame</code> can be resized by some
+ * user action.
+ *
+ * @param b a boolean, where <code>true</code> means this internal frame can be resized
+ * @beaninfo
+ * preferred: true
+ * bound: true
+ * description: Determines whether this internal frame can be resized
+ * by the user.
+ */
+ public void setResizable(boolean b) {
+ Boolean oldValue = resizable ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
+ resizable = b;
+ firePropertyChange("resizable", oldValue, newValue);
+ }
+
+ /**
+ * Returns whether the <code>JInternalFrame</code> can be resized
+ * by some user action.
+ *
+ * @return <code>true</code> if this internal frame can be resized, <code>false</code> otherwise
+ */
+ public boolean isResizable() {
+ // don't allow resizing when maximized.
+ return isMaximum ? false : resizable;
+ }
+
+ /**
+ * Sets the <code>iconable</code> property,
+ * which must be <code>true</code>
+ * for the user to be able to
+ * make the <code>JInternalFrame</code> an icon.
+ * Some look and feels might not implement iconification;
+ * they will ignore this property.
+ *
+ * @param b a boolean, where <code>true</code> means this internal frame can be iconified
+ * @beaninfo
+ * preferred: true
+ bound: true
+ * description: Determines whether this internal frame can be iconified.
+ */
+ public void setIconifiable(boolean b) {
+ Boolean oldValue = iconable ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
+ iconable = b;
+ firePropertyChange("iconable", oldValue, newValue);
+ }
+
+ /**
+ * Gets the <code>iconable</code> property,
+ * which by default is <code>false</code>.
+ *
+ * @return the value of the <code>iconable</code> property.
+ *
+ * @see #setIconifiable
+ */
+ public boolean isIconifiable() {
+ return iconable;
+ }
+
+ /**
+ * Returns whether the <code>JInternalFrame</code> is currently iconified.
+ *
+ * @return <code>true</code> if this internal frame is iconified
+ */
+ public boolean isIcon() {
+ return isIcon;
+ }
+
+ /**
+ * Iconifies or de-iconifies this internal frame,
+ * if the look and feel supports iconification.
+ * If the internal frame's state changes to iconified,
+ * this method fires an <code>INTERNAL_FRAME_ICONIFIED</code> event.
+ * If the state changes to de-iconified,
+ * an <code>INTERNAL_FRAME_DEICONIFIED</code> event is fired.
+ *
+ * @param b a boolean, where <code>true</code> means to iconify this internal frame and
+ * <code>false</code> means to de-iconify it
+ * @exception PropertyVetoException when the attempt to set the
+ * property is vetoed by the <code>JInternalFrame</code>
+ *
+ * @see InternalFrameEvent#INTERNAL_FRAME_ICONIFIED
+ * @see InternalFrameEvent#INTERNAL_FRAME_DEICONIFIED
+ *
+ * @beaninfo
+ * bound: true
+ * constrained: true
+ * description: The image displayed when this internal frame is minimized.
+ */
+ public void setIcon(boolean b) throws PropertyVetoException {
+ if (isIcon == b) {
+ return;
+ }
+
+ /* If an internal frame is being iconified before it has a
+ parent, (e.g., client wants it to start iconic), create the
+ parent if possible so that we can place the icon in its
+ proper place on the desktop. I am not sure the call to
+ validate() is necessary, since we are not going to display
+ this frame yet */
+ firePropertyChange("ancestor", null, getParent());
+
+ Boolean oldValue = isIcon ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
+ fireVetoableChange(IS_ICON_PROPERTY, oldValue, newValue);
+ isIcon = b;
+ firePropertyChange(IS_ICON_PROPERTY, oldValue, newValue);
+ if (b)
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED);
+ else
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED);
+ }
+
+ /**
+ * Sets the <code>maximizable</code> property,
+ * which determines whether the <code>JInternalFrame</code>
+ * can be maximized by
+ * some user action.
+ * Some look and feels might not support maximizing internal frames;
+ * they will ignore this property.
+ *
+ * @param b <code>true</code> to specify that this internal frame should be maximizable; <code>false</code> to specify that it should not be
+ * @beaninfo
+ * bound: true
+ * preferred: true
+ * description: Determines whether this internal frame can be maximized.
+ */
+ public void setMaximizable(boolean b) {
+ Boolean oldValue = maximizable ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
+ maximizable = b;
+ firePropertyChange("maximizable", oldValue, newValue);
+ }
+
+ /**
+ * Gets the value of the <code>maximizable</code> property.
+ *
+ * @return the value of the <code>maximizable</code> property
+ * @see #setMaximizable
+ */
+ public boolean isMaximizable() {
+ return maximizable;
+ }
+
+ /**
+ * Returns whether the <code>JInternalFrame</code> is currently maximized.
+ *
+ * @return <code>true</code> if this internal frame is maximized, <code>false</code> otherwise
+ */
+ public boolean isMaximum() {
+ return isMaximum;
+ }
+
+ /**
+ * Maximizes and restores this internal frame. A maximized frame is resized to
+ * fully fit the <code>JDesktopPane</code> area associated with the
+ * <code>JInternalFrame</code>.
+ * A restored frame's size is set to the <code>JInternalFrame</code>'s
+ * actual size.
+ *
+ * @param b a boolean, where <code>true</code> maximizes this internal frame and <code>false</code>
+ * restores it
+ * @exception PropertyVetoException when the attempt to set the
+ * property is vetoed by the <code>JInternalFrame</code>
+ * @beaninfo
+ * bound: true
+ * constrained: true
+ * description: Indicates whether this internal frame is maximized.
+ */
+ public void setMaximum(boolean b) throws PropertyVetoException {
+ if (isMaximum == b) {
+ return;
+ }
+
+ Boolean oldValue = isMaximum ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = b ? Boolean.TRUE : Boolean.FALSE;
+ fireVetoableChange(IS_MAXIMUM_PROPERTY, oldValue, newValue);
+ /* setting isMaximum above the event firing means that
+ property listeners that, for some reason, test it will
+ get it wrong... See, for example, getNormalBounds() */
+ isMaximum = b;
+ firePropertyChange(IS_MAXIMUM_PROPERTY, oldValue, newValue);
+ }
+
+ /**
+ * Returns the title of the <code>JInternalFrame</code>.
+ *
+ * @return a <code>String</code> containing this internal frame's title
+ * @see #setTitle
+ */
+ public String getTitle() {
+ return title;
+ }
+
+ /**
+ * Sets the <code>JInternalFrame</code> title. <code>title</code>
+ * may have a <code>null</code> value.
+ * @see #getTitle
+ *
+ * @param title the <code>String</code> to display in the title bar
+ * @beaninfo
+ * preferred: true
+ * bound: true
+ * description: The text displayed in the title bar.
+ */
+ public void setTitle(String title) {
+ String oldValue = this.title;
+ this.title = title;
+ firePropertyChange(TITLE_PROPERTY, oldValue, title);
+ }
+
+ /**
+ * Selects or deselects the internal frame
+ * if it's showing.
+ * A <code>JInternalFrame</code> normally draws its title bar
+ * differently if it is
+ * the selected frame, which indicates to the user that this
+ * internal frame has the focus.
+ * When this method changes the state of the internal frame
+ * from deselected to selected, it fires an
+ * <code>InternalFrameEvent.INTERNAL_FRAME_ACTIVATED</code> event.
+ * If the change is from selected to deselected,
+ * an <code>InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED</code> event
+ * is fired.
+ *
+ * @param selected a boolean, where <code>true</code> means this internal frame
+ * should become selected (currently active)
+ * and <code>false</code> means it should become deselected
+ * @exception PropertyVetoException when the attempt to set the
+ * property is vetoed by the <code>JInternalFrame</code>
+ *
+ * @see #isShowing
+ * @see InternalFrameEvent#INTERNAL_FRAME_ACTIVATED
+ * @see InternalFrameEvent#INTERNAL_FRAME_DEACTIVATED
+ *
+ * @beaninfo
+ * constrained: true
+ * bound: true
+ * description: Indicates whether this internal frame is currently
+ * the active frame.
+ */
+ public void setSelected(boolean selected) throws PropertyVetoException {
+ // The InternalFrame may already be selected, but the focus
+ // may be outside it, so restore the focus to the subcomponent
+ // which previously had it. See Bug 4302764.
+ if (selected && isSelected) {
+ restoreSubcomponentFocus();
+ return;
+ }
+ // The internal frame or the desktop icon must be showing to allow
+ // selection. We may deselect even if neither is showing.
+ if ((isSelected == selected) || (selected &&
+ (isIcon ? !desktopIcon.isShowing() : !isShowing()))) {
+ return;
+ }
+
+ Boolean oldValue = isSelected ? Boolean.TRUE : Boolean.FALSE;
+ Boolean newValue = selected ? Boolean.TRUE : Boolean.FALSE;
+ fireVetoableChange(IS_SELECTED_PROPERTY, oldValue, newValue);
+
+ /* We don't want to leave focus in the previously selected
+ frame, so we have to set it to *something* in case it
+ doesn't get set in some other way (as if a user clicked on
+ a component that doesn't request focus). If this call is
+ happening because the user clicked on a component that will
+ want focus, then it will get transfered there later.
+
+ We test for parent.isShowing() above, because AWT throws a
+ NPE if you try to request focus on a lightweight before its
+ parent has been made visible */
+
+ if (selected) {
+ restoreSubcomponentFocus();
+ }
+
+ isSelected = selected;
+ firePropertyChange(IS_SELECTED_PROPERTY, oldValue, newValue);
+ if (isSelected)
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED);
+ else
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED);
+ repaint();
+ }
+
+ /**
+ * Returns whether the <code>JInternalFrame</code> is the
+ * currently "selected" or active frame.
+ *
+ * @return <code>true</code> if this internal frame is currently selected (active)
+ * @see #setSelected
+ */
+ public boolean isSelected() {
+ return isSelected;
+ }
+
+ /**
+ * Sets an image to be displayed in the titlebar of this internal frame (usually
+ * in the top-left corner).
+ * This image is not the <code>desktopIcon</code> object, which
+ * is the image displayed in the <code>JDesktop</code> when
+ * this internal frame is iconified.
+ *
+ * Passing <code>null</code> to this function is valid,
+ * but the look and feel
+ * can choose the
+ * appropriate behavior for that situation, such as displaying no icon
+ * or a default icon for the look and feel.
+ *
+ * @param icon the <code>Icon</code> to display in the title bar
+ * @see #getFrameIcon
+ * @beaninfo
+ * bound: true
+ * description: The icon shown in the top-left corner of this internal frame.
+ */
+ public void setFrameIcon(Icon icon) {
+ Icon oldIcon = frameIcon;
+ frameIcon = icon;
+ firePropertyChange(FRAME_ICON_PROPERTY, oldIcon, icon);
+ }
+
+ /**
+ * Returns the image displayed in the title bar of this internal frame (usually
+ * in the top-left corner).
+ *
+ * @return the <code>Icon</code> displayed in the title bar
+ * @see #setFrameIcon
+ */
+ public Icon getFrameIcon() {
+ return frameIcon;
+ }
+
+ /**
+ * Convenience method that moves this component to position 0 if its
+ * parent is a <code>JLayeredPane</code>.
+ */
+ public void moveToFront() {
+ if (isIcon()) {
+ if (getDesktopIcon().getParent() instanceof JLayeredPane) {
+ ((JLayeredPane)getDesktopIcon().getParent()).
+ moveToFront(getDesktopIcon());
+ }
+ }
+ else if (getParent() instanceof JLayeredPane) {
+ ((JLayeredPane)getParent()).moveToFront(this);
+ }
+ }
+
+ /**
+ * Convenience method that moves this component to position -1 if its
+ * parent is a <code>JLayeredPane</code>.
+ */
+ public void moveToBack() {
+ if (isIcon()) {
+ if (getDesktopIcon().getParent() instanceof JLayeredPane) {
+ ((JLayeredPane)getDesktopIcon().getParent()).
+ moveToBack(getDesktopIcon());
+ }
+ }
+ else if (getParent() instanceof JLayeredPane) {
+ ((JLayeredPane)getParent()).moveToBack(this);
+ }
+ }
+
+ /**
+ * Returns the last <code>Cursor</code> that was set by the
+ * <code>setCursor</code> method that is not a resizable
+ * <code>Cursor</code>.
+ *
+ * @return the last non-resizable <code>Cursor</code>
+ * @since 1.6
+ */
+ public Cursor getLastCursor() {
+ return lastCursor;
+ }
+
+ /**
+ * {@inheritDoc}
+ * @since 1.6
+ */
+ public void setCursor(Cursor cursor) {
+ if (cursor == null) {
+ lastCursor = null;
+ super.setCursor(cursor);
+ return;
+ }
+ int type = cursor.getType();
+ if (!(type == Cursor.SW_RESIZE_CURSOR ||
+ type == Cursor.SE_RESIZE_CURSOR ||
+ type == Cursor.NW_RESIZE_CURSOR ||
+ type == Cursor.NE_RESIZE_CURSOR ||
+ type == Cursor.N_RESIZE_CURSOR ||
+ type == Cursor.S_RESIZE_CURSOR ||
+ type == Cursor.W_RESIZE_CURSOR ||
+ type == Cursor.E_RESIZE_CURSOR)) {
+ lastCursor = cursor;
+ }
+ super.setCursor(cursor);
+ }
+
+ /**
+ * Convenience method for setting the layer attribute of this component.
+ *
+ * @param layer an <code>Integer</code> object specifying this
+ * frame's desktop layer
+ * @see JLayeredPane
+ * @beaninfo
+ * expert: true
+ * description: Specifies what desktop layer is used.
+ */
+ public void setLayer(Integer layer) {
+ if(getParent() != null && getParent() instanceof JLayeredPane) {
+ // Normally we want to do this, as it causes the LayeredPane
+ // to draw properly.
+ JLayeredPane p = (JLayeredPane)getParent();
+ p.setLayer(this, layer.intValue(), p.getPosition(this));
+ } else {
+ // Try to do the right thing
+ JLayeredPane.putLayer(this, layer.intValue());
+ if(getParent() != null)
+ getParent().repaint(getX(), getY(), getWidth(), getHeight());
+ }
+ }
+
+ /**
+ * Convenience method for setting the layer attribute of this component.
+ * The method <code>setLayer(Integer)</code> should be used for
+ * layer values predefined in <code>JLayeredPane</code>.
+ * When using <code>setLayer(int)</code>, care must be taken not to
+ * accidentally clash with those values.
+ *
+ * @param layer an integer specifying this internal frame's desktop layer
+ *
+ * @since 1.3
+ *
+ * @see #setLayer(Integer)
+ * @see JLayeredPane
+ * @beaninfo
+ * expert: true
+ * description: Specifies what desktop layer is used.
+ */
+ public void setLayer(int layer) {
+ this.setLayer(Integer.valueOf(layer));
+ }
+
+ /**
+ * Convenience method for getting the layer attribute of this component.
+ *
+ * @return an <code>Integer</code> object specifying this
+ * frame's desktop layer
+ * @see JLayeredPane
+ */
+ public int getLayer() {
+ return JLayeredPane.getLayer(this);
+ }
+
+ /**
+ * Convenience method that searches the ancestor hierarchy for a
+ * <code>JDesktop</code> instance. If <code>JInternalFrame</code>
+ * finds none, the <code>desktopIcon</code> tree is searched.
+ *
+ * @return the <code>JDesktopPane</code> this internal frame belongs to,
+ * or <code>null</code> if none is found
+ */
+ public JDesktopPane getDesktopPane() {
+ Container p;
+
+ // Search upward for desktop
+ p = getParent();
+ while(p != null && !(p instanceof JDesktopPane))
+ p = p.getParent();
+
+ if(p == null) {
+ // search its icon parent for desktop
+ p = getDesktopIcon().getParent();
+ while(p != null && !(p instanceof JDesktopPane))
+ p = p.getParent();
+ }
+
+ return (JDesktopPane)p;
+ }
+
+ /**
+ * Sets the <code>JDesktopIcon</code> associated with this
+ * <code>JInternalFrame</code>.
+ *
+ * @param d the <code>JDesktopIcon</code> to display on the desktop
+ * @see #getDesktopIcon
+ * @beaninfo
+ * bound: true
+ * description: The icon shown when this internal frame is minimized.
+ */
+ public void setDesktopIcon(JDesktopIcon d) {
+ JDesktopIcon oldValue = getDesktopIcon();
+ desktopIcon = d;
+ firePropertyChange("desktopIcon", oldValue, d);
+ }
+
+ /**
+ * Returns the <code>JDesktopIcon</code> used when this
+ * <code>JInternalFrame</code> is iconified.
+ *
+ * @return the <code>JDesktopIcon</code> displayed on the desktop
+ * @see #setDesktopIcon
+ */
+ public JDesktopIcon getDesktopIcon() {
+ return desktopIcon;
+ }
+
+ /**
+ * If the <code>JInternalFrame</code> is not in maximized state, returns
+ * <code>getBounds()</code>; otherwise, returns the bounds that the
+ * <code>JInternalFrame</code> would be restored to.
+ *
+ * @return a <code>Rectangle</code> containing the bounds of this
+ * frame when in the normal state
+ * @since 1.3
+ */
+ public Rectangle getNormalBounds() {
+
+ /* we used to test (!isMaximum) here, but since this
+ method is used by the property listener for the
+ IS_MAXIMUM_PROPERTY, it ended up getting the wrong
+ answer... Since normalBounds get set to null when the
+ frame is restored, this should work better */
+
+ if (normalBounds != null) {
+ return normalBounds;
+ } else {
+ return getBounds();
+ }
+ }
+
+ /**
+ * Sets the normal bounds for this internal frame, the bounds that
+ * this internal frame would be restored to from its maximized state.
+ * This method is intended for use only by desktop managers.
+ *
+ * @param r the bounds that this internal frame should be restored to
+ * @since 1.3
+ */
+ public void setNormalBounds(Rectangle r) {
+ normalBounds = r;
+ }
+
+ /**
+ * If this <code>JInternalFrame</code> is active,
+ * returns the child that has focus.
+ * Otherwise, returns <code>null</code>.
+ *
+ * @return the component with focus, or <code>null</code> if no children have focus
+ * @since 1.3
+ */
+ public Component getFocusOwner() {
+ if (isSelected()) {
+ return lastFocusOwner;
+ }
+ return null;
+ }
+
+ /**
+ * Returns the child component of this <code>JInternalFrame</code>
+ * that will receive the
+ * focus when this <code>JInternalFrame</code> is selected.
+ * If this <code>JInternalFrame</code> is
+ * currently selected, this method returns the same component as
+ * the <code>getFocusOwner</code> method.
+ * If this <code>JInternalFrame</code> is not selected,
+ * then the child component that most recently requested focus will be
+ * returned. If no child component has ever requested focus, then this
+ * <code>JInternalFrame</code>'s initial focusable component is returned.
+ * If no such
+ * child exists, then this <code>JInternalFrame</code>'s default component
+ * to focus is returned.
+ *
+ * @return the child component that will receive focus when this
+ * <code>JInternalFrame</code> is selected
+ * @see #getFocusOwner
+ * @see #isSelected
+ * @since 1.4
+ */
+ public Component getMostRecentFocusOwner() {
+ if (isSelected()) {
+ return getFocusOwner();
+ }
+
+ if (lastFocusOwner != null) {
+ return lastFocusOwner;
+ }
+
+ FocusTraversalPolicy policy = getFocusTraversalPolicy();
+ if (policy instanceof InternalFrameFocusTraversalPolicy) {
+ return ((InternalFrameFocusTraversalPolicy)policy).
+ getInitialComponent(this);
+ }
+
+ Component toFocus = policy.getDefaultComponent(this);
+ if (toFocus != null) {
+ return toFocus;
+ }
+ return getContentPane();
+ }
+
+ /**
+ * Requests the internal frame to restore focus to the
+ * last subcomponent that had focus. This is used by the UI when
+ * the user selected this internal frame --
+ * for example, by clicking on the title bar.
+ *
+ * @since 1.3
+ */
+ public void restoreSubcomponentFocus() {
+ if (isIcon()) {
+ SwingUtilities2.compositeRequestFocus(getDesktopIcon());
+ }
+ else {
+ Component component = KeyboardFocusManager.getCurrentKeyboardFocusManager().getPermanentFocusOwner();
+ if ((component == null) || !SwingUtilities.isDescendingFrom(component, this)) {
+ // FocusPropertyChangeListener will eventually update
+ // lastFocusOwner. As focus requests are asynchronous
+ // lastFocusOwner may be accessed before it has been correctly
+ // updated. To avoid any problems, lastFocusOwner is immediately
+ // set, assuming the request will succeed.
+ setLastFocusOwner(getMostRecentFocusOwner());
+ if (lastFocusOwner == null) {
+ // Make sure focus is restored somewhere, so that
+ // we don't leave a focused component in another frame while
+ // this frame is selected.
+ setLastFocusOwner(getContentPane());
+ }
+ lastFocusOwner.requestFocus();
+ }
+ }
+ }
+
+ private void setLastFocusOwner(Component component) {
+ lastFocusOwner = component;
+ }
+
+ /**
+ * Moves and resizes this component. Unlike other components,
+ * this implementation also forces re-layout, so that frame
+ * decorations such as the title bar are always redisplayed.
+ *
+ * @param x an integer giving the component's new horizontal position
+ * measured in pixels from the left of its container
+ * @param y an integer giving the component's new vertical position,
+ * measured in pixels from the bottom of its container
+ * @param width an integer giving the component's new width in pixels
+ * @param height an integer giving the component's new height in pixels
+ */
+ public void reshape(int x, int y, int width, int height) {
+ super.reshape(x, y, width, height);
+ validate();
+ repaint();
+ }
+
+///////////////////////////
+// Frame/Window equivalents
+///////////////////////////
+
+ /**
+ * Adds the specified listener to receive internal
+ * frame events from this internal frame.
+ *
+ * @param l the internal frame listener
+ */
+ public void addInternalFrameListener(InternalFrameListener l) { // remind: sync ??
+ listenerList.add(InternalFrameListener.class, l);
+ // remind: needed?
+ enableEvents(0); // turn on the newEventsOnly flag in Component.
+ }
+
+ /**
+ * Removes the specified internal frame listener so that it no longer
+ * receives internal frame events from this internal frame.
+ *
+ * @param l the internal frame listener
+ */
+ public void removeInternalFrameListener(InternalFrameListener l) { // remind: sync??
+ listenerList.remove(InternalFrameListener.class, l);
+ }
+
+ /**
+ * Returns an array of all the <code>InternalFrameListener</code>s added
+ * to this <code>JInternalFrame</code> with
+ * <code>addInternalFrameListener</code>.
+ *
+ * @return all of the <code>InternalFrameListener</code>s added or an empty
+ * array if no listeners have been added
+ * @since 1.4
+ *
+ * @see #addInternalFrameListener
+ */
+ public InternalFrameListener[] getInternalFrameListeners() {
+ return listenerList.getListeners(InternalFrameListener.class);
+ }
+
+ // remind: name ok? all one method ok? need to be synchronized?
+ /**
+ * Fires an internal frame event.
+ *
+ * @param id the type of the event being fired; one of the following:
+ * <ul>
+ * <li><code>InternalFrameEvent.INTERNAL_FRAME_OPENED</code>
+ * <li><code>InternalFrameEvent.INTERNAL_FRAME_CLOSING</code>
+ * <li><code>InternalFrameEvent.INTERNAL_FRAME_CLOSED</code>
+ * <li><code>InternalFrameEvent.INTERNAL_FRAME_ICONIFIED</code>
+ * <li><code>InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED</code>
+ * <li><code>InternalFrameEvent.INTERNAL_FRAME_ACTIVATED</code>
+ * <li><code>InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED</code>
+ * </ul>
+ * If the event type is not one of the above, nothing happens.
+ */
+ protected void fireInternalFrameEvent(int id){
+ Object[] listeners = listenerList.getListenerList();
+ InternalFrameEvent e = null;
+ for (int i = listeners.length -2; i >=0; i -= 2){
+ if (listeners[i] == InternalFrameListener.class){
+ if (e == null){
+ e = new InternalFrameEvent(this, id);
+ // System.out.println("InternalFrameEvent: " + e.paramString());
+ }
+ switch(e.getID()) {
+ case InternalFrameEvent.INTERNAL_FRAME_OPENED:
+ ((InternalFrameListener)listeners[i+1]).internalFrameOpened(e);
+ break;
+ case InternalFrameEvent.INTERNAL_FRAME_CLOSING:
+ ((InternalFrameListener)listeners[i+1]).internalFrameClosing(e);
+ break;
+ case InternalFrameEvent.INTERNAL_FRAME_CLOSED:
+ ((InternalFrameListener)listeners[i+1]).internalFrameClosed(e);
+ break;
+ case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED:
+ ((InternalFrameListener)listeners[i+1]).internalFrameIconified(e);
+ break;
+ case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED:
+ ((InternalFrameListener)listeners[i+1]).internalFrameDeiconified(e);
+ break;
+ case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED:
+ ((InternalFrameListener)listeners[i+1]).internalFrameActivated(e);
+ break;
+ case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED:
+ ((InternalFrameListener)listeners[i+1]).internalFrameDeactivated(e);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ /* we could do it off the event, but at the moment, that's not how
+ I'm implementing it */
+ // if (id == InternalFrameEvent.INTERNAL_FRAME_CLOSING) {
+ // doDefaultCloseAction();
+ // }
+ }
+
+ /**
+ * Fires an
+ * <code>INTERNAL_FRAME_CLOSING</code> event
+ * and then performs the action specified by
+ * the internal frame's default close operation.
+ * This method is typically invoked by the
+ * look-and-feel-implemented action handler
+ * for the internal frame's close button.
+ *
+ * @since 1.3
+ * @see #setDefaultCloseOperation
+ * @see javax.swing.event.InternalFrameEvent#INTERNAL_FRAME_CLOSING
+ */
+ public void doDefaultCloseAction() {
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING);
+ switch(defaultCloseOperation) {
+ case DO_NOTHING_ON_CLOSE:
+ break;
+ case HIDE_ON_CLOSE:
+ setVisible(false);
+ if (isSelected())
+ try {
+ setSelected(false);
+ } catch (PropertyVetoException pve) {}
+
+ /* should this activate the next frame? that's really
+ desktopmanager's policy... */
+ break;
+ case DISPOSE_ON_CLOSE:
+ try {
+ fireVetoableChange(IS_CLOSED_PROPERTY, Boolean.FALSE,
+ Boolean.TRUE);
+ isClosed = true;
+ setVisible(false);
+ firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE,
+ Boolean.TRUE);
+ dispose();
+ } catch (PropertyVetoException pve) {}
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ * Sets the operation that will happen by default when
+ * the user initiates a "close" on this internal frame.
+ * The possible choices are:
+ * <br><br>
+ * <dl>
+ * <dt><code>DO_NOTHING_ON_CLOSE</code>
+ * <dd> Do nothing.
+ * This requires the program to handle the operation
+ * in the <code>windowClosing</code> method
+ * of a registered <code>InternalFrameListener</code> object.
+ * <dt><code>HIDE_ON_CLOSE</code>
+ * <dd> Automatically make the internal frame invisible.
+ * <dt><code>DISPOSE_ON_CLOSE</code>
+ * <dd> Automatically dispose of the internal frame.
+ * </dl>
+ * <p>
+ * The default value is <code>DISPOSE_ON_CLOSE</code>.
+ * Before performing the specified close operation,
+ * the internal frame fires
+ * an <code>INTERNAL_FRAME_CLOSING</code> event.
+ *
+ * @param operation one of the following constants defined in
+ * <code>javax.swing.WindowConstants</code>
+ * (an interface implemented by
+ * <code>JInternalFrame</code>):
+ * <code>DO_NOTHING_ON_CLOSE</code>,
+ * <code>HIDE_ON_CLOSE</code>, or
+ * <code>DISPOSE_ON_CLOSE</code>
+ *
+ * @see #addInternalFrameListener
+ * @see #getDefaultCloseOperation
+ * @see #setVisible
+ * @see #dispose
+ * @see InternalFrameEvent#INTERNAL_FRAME_CLOSING
+ */
+ public void setDefaultCloseOperation(int operation) {
+ this.defaultCloseOperation = operation;
+ }
+
+ /**
+ * Returns the default operation that occurs when the user
+ * initiates a "close" on this internal frame.
+ * @return the operation that will occur when the user closes the internal
+ * frame
+ * @see #setDefaultCloseOperation
+ */
+ public int getDefaultCloseOperation() {
+ return defaultCloseOperation;
+ }
+
+ /**
+ * Causes subcomponents of this <code>JInternalFrame</code>
+ * to be laid out at their preferred size. Internal frames that are
+ * iconized or maximized are first restored and then packed. If the
+ * internal frame is unable to be restored its state is not changed
+ * and will not be packed.
+ *
+ * @see java.awt.Window#pack
+ */
+ public void pack() {
+ try {
+ if (isIcon()) {
+ setIcon(false);
+ } else if (isMaximum()) {
+ setMaximum(false);
+ }
+ } catch(PropertyVetoException e) {
+ return;
+ }
+ setSize(getPreferredSize());
+ validate();
+ }
+
+ /**
+ * If the internal frame is not visible,
+ * brings the internal frame to the front,
+ * makes it visible,
+ * and attempts to select it.
+ * The first time the internal frame is made visible,
+ * this method also fires an <code>INTERNAL_FRAME_OPENED</code> event.
+ * This method does nothing if the internal frame is already visible.
+ * Invoking this method
+ * has the same result as invoking
+ * <code>setVisible(true)</code>.
+ *
+ * @see #moveToFront
+ * @see #setSelected
+ * @see InternalFrameEvent#INTERNAL_FRAME_OPENED
+ * @see #setVisible
+ */
+ public void show() {
+ // bug 4312922
+ if (isVisible()) {
+ //match the behavior of setVisible(true): do nothing
+ return;
+ }
+
+ // bug 4149505
+ if (!opened) {
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED);
+ opened = true;
+ }
+
+ /* icon default visibility is false; set it to true so that it shows
+ up when user iconifies frame */
+ getDesktopIcon().setVisible(true);
+
+ toFront();
+ super.show();
+
+ if (isIcon) {
+ return;
+ }
+
+ if (!isSelected()) {
+ try {
+ setSelected(true);
+ } catch (PropertyVetoException pve) {}
+ }
+ }
+
+ public void hide() {
+ if (isIcon()) {
+ getDesktopIcon().setVisible(false);
+ }
+ super.hide();
+ }
+
+ /**
+ * Makes this internal frame
+ * invisible, unselected, and closed.
+ * If the frame is not already closed,
+ * this method fires an
+ * <code>INTERNAL_FRAME_CLOSED</code> event.
+ * The results of invoking this method are similar to
+ * <code>setClosed(true)</code>,
+ * but <code>dispose</code> always succeeds in closing
+ * the internal frame and does not fire
+ * an <code>INTERNAL_FRAME_CLOSING</code> event.
+ *
+ * @see javax.swing.event.InternalFrameEvent#INTERNAL_FRAME_CLOSED
+ * @see #setVisible
+ * @see #setSelected
+ * @see #setClosed
+ */
+ public void dispose() {
+ if (isVisible()) {
+ setVisible(false);
+ }
+ if (isSelected()) {
+ try {
+ setSelected(false);
+ } catch (PropertyVetoException pve) {}
+ }
+ if (!isClosed) {
+ firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE, Boolean.TRUE);
+ isClosed = true;
+ }
+ fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED);
+ }
+
+ /**
+ * Brings this internal frame to the front.
+ * Places this internal frame at the top of the stacking order
+ * and makes the corresponding adjustment to other visible internal
+ * frames.
+ *
+ * @see java.awt.Window#toFront
+ * @see #moveToFront
+ */
+ public void toFront() {
+ moveToFront();
+ }
+
+ /**
+ * Sends this internal frame to the back.
+ * Places this internal frame at the bottom of the stacking order
+ * and makes the corresponding adjustment to other visible
+ * internal frames.
+ *
+ * @see java.awt.Window#toBack
+ * @see #moveToBack
+ */
+ public void toBack() {
+ moveToBack();
+ }
+
+ /**
+ * Does nothing because <code>JInternalFrame</code>s must always be roots of a focus
+ * traversal cycle.
+ *
+ * @param focusCycleRoot this value is ignored
+ * @see #isFocusCycleRoot
+ * @see java.awt.Container#setFocusTraversalPolicy
+ * @see java.awt.Container#getFocusTraversalPolicy
+ * @since 1.4
+ */
+ public final void setFocusCycleRoot(boolean focusCycleRoot) {
+ }
+
+ /**
+ * Always returns <code>true</code> because all <code>JInternalFrame</code>s must be
+ * roots of a focus traversal cycle.
+ *
+ * @return <code>true</code>
+ * @see #setFocusCycleRoot
+ * @see java.awt.Container#setFocusTraversalPolicy
+ * @see java.awt.Container#getFocusTraversalPolicy
+ * @since 1.4
+ */
+ public final boolean isFocusCycleRoot() {
+ return true;
+ }
+
+ /**
+ * Always returns <code>null</code> because <code>JInternalFrame</code>s
+ * must always be roots of a focus
+ * traversal cycle.
+ *
+ * @return <code>null</code>
+ * @see java.awt.Container#isFocusCycleRoot()
+ * @since 1.4
+ */
+ public final Container getFocusCycleRootAncestor() {
+ return null;
+ }
+
+ /**
+ * Gets the warning string that is displayed with this internal frame.
+ * Since an internal frame is always secure (since it's fully
+ * contained within a window that might need a warning string)
+ * this method always returns <code>null</code>.
+ * @return <code>null</code>
+ * @see java.awt.Window#getWarningString
+ */
+ public final String getWarningString() {
+ return null;
+ }
+
+ /**
+ * See <code>readObject</code> and <code>writeObject</code>
+ * in <code>JComponent</code> for more
+ * information about serialization in Swing.
+ */
+ private void writeObject(ObjectOutputStream s) throws IOException {
+ s.defaultWriteObject();
+ if (getUIClassID().equals(uiClassID)) {
+ byte count = JComponent.getWriteObjCounter(this);
+ JComponent.setWriteObjCounter(this, --count);
+ if (count == 0 && ui != null) {
+ boolean old = isRootPaneCheckingEnabled();
+ try {
+ setRootPaneCheckingEnabled(false);
+ ui.installUI(this);
+ } finally {
+ setRootPaneCheckingEnabled(old);
+ }
+ }
+ }
+ }
+
+ /* Called from the JComponent's EnableSerializationFocusListener to
+ * do any Swing-specific pre-serialization configuration.
+ */
+ void compWriteObjectNotify() {
+ // need to disable rootpane checking for InternalFrame: 4172083
+ boolean old = isRootPaneCheckingEnabled();
+ try {
+ setRootPaneCheckingEnabled(false);
+ super.compWriteObjectNotify();
+ }
+ finally {
+ setRootPaneCheckingEnabled(old);
+ }
+ }
+
+ /**
+ * Returns a string representation of this <code>JInternalFrame</code>.
+ * This method
+ * is intended to be used only for debugging purposes, and the
+ * content and format of the returned string may vary between
+ * implementations. The returned string may be empty but may not
+ * be <code>null</code>.
+ *
+ * @return a string representation of this <code>JInternalFrame</code>
+ */
+ protected String paramString() {
+ String rootPaneString = (rootPane != null ?
+ rootPane.toString() : "");
+ String rootPaneCheckingEnabledString = (rootPaneCheckingEnabled ?
+ "true" : "false");
+ String closableString = (closable ? "true" : "false");
+ String isClosedString = (isClosed ? "true" : "false");
+ String maximizableString = (maximizable ? "true" : "false");
+ String isMaximumString = (isMaximum ? "true" : "false");
+ String iconableString = (iconable ? "true" : "false");
+ String isIconString = (isIcon ? "true" : "false");
+ String resizableString = (resizable ? "true" : "false");
+ String isSelectedString = (isSelected ? "true" : "false");
+ String frameIconString = (frameIcon != null ?
+ frameIcon.toString() : "");
+ String titleString = (title != null ?
+ title : "");
+ String desktopIconString = (desktopIcon != null ?
+ desktopIcon.toString() : "");
+ String openedString = (opened ? "true" : "false");
+ String defaultCloseOperationString;
+ if (defaultCloseOperation == HIDE_ON_CLOSE) {
+ defaultCloseOperationString = "HIDE_ON_CLOSE";
+ } else if (defaultCloseOperation == DISPOSE_ON_CLOSE) {
+ defaultCloseOperationString = "DISPOSE_ON_CLOSE";
+ } else if (defaultCloseOperation == DO_NOTHING_ON_CLOSE) {
+ defaultCloseOperationString = "DO_NOTHING_ON_CLOSE";
+ } else defaultCloseOperationString = "";
+
+ return super.paramString() +
+ ",closable=" + closableString +
+ ",defaultCloseOperation=" + defaultCloseOperationString +
+ ",desktopIcon=" + desktopIconString +
+ ",frameIcon=" + frameIconString +
+ ",iconable=" + iconableString +
+ ",isClosed=" + isClosedString +
+ ",isIcon=" + isIconString +
+ ",isMaximum=" + isMaximumString +
+ ",isSelected=" + isSelectedString +
+ ",maximizable=" + maximizableString +
+ ",opened=" + openedString +
+ ",resizable=" + resizableString +
+ ",rootPane=" + rootPaneString +
+ ",rootPaneCheckingEnabled=" + rootPaneCheckingEnabledString +
+ ",title=" + titleString;
+ }
+
+ // ======= begin optimized frame dragging defence code ==============
+
+ boolean isDragging = false;
+ boolean danger = false;
+
+ /**
+ * Overridden to allow optimized painting when the
+ * internal frame is being dragged.
+ */
+ protected void paintComponent(Graphics g) {
+ if (isDragging) {
+ // System.out.println("ouch");
+ danger = true;
+ }
+
+ super.paintComponent(g);
+ }
+
+ // ======= end optimized frame dragging defence code ==============
+
+/////////////////
+// Accessibility support
+////////////////
+
+ /**
+ * Gets the <code>AccessibleContext</code> associated with this
+ * <code>JInternalFrame</code>.
+ * For internal frames, the <code>AccessibleContext</code>
+ * takes the form of an
+ * <code>AccessibleJInternalFrame</code> object.
+ * A new <code>AccessibleJInternalFrame</code> instance is created if necessary.
+ *
+ * @return an <code>AccessibleJInternalFrame</code> that serves as the
+ * <code>AccessibleContext</code> of this
+ * <code>JInternalFrame</code>
+ * @see AccessibleJInternalFrame
+ */
+ public AccessibleContext getAccessibleContext() {
+ if (accessibleContext == null) {
+ accessibleContext = new AccessibleJInternalFrame();
+ }
+ return accessibleContext;
+ }
+
+ /**
+ * This class implements accessibility support for the
+ * <code>JInternalFrame</code> class. It provides an implementation of the
+ * Java Accessibility API appropriate to internal frame user-interface
+ * elements.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing. As of 1.4, support for long term storage
+ * of all JavaBeans™
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ */
+ @SuppressWarnings("serial") // Same-version serialization only
+ protected class AccessibleJInternalFrame extends AccessibleJComponent
+ implements AccessibleValue {
+
+ /**
+ * Get the accessible name of this object.
+ *
+ * @return the localized name of the object -- can be <code>null</code> if this
+ * object does not have a name
+ * @see #setAccessibleName
+ */
+ public String getAccessibleName() {
+ String name = accessibleName;
+
+ if (name == null) {
+ name = (String)getClientProperty(AccessibleContext.ACCESSIBLE_NAME_PROPERTY);
+ }
+ if (name == null) {
+ name = getTitle();
+ }
+ return name;
+ }
+
+ /**
+ * Get the role of this object.
+ *
+ * @return an instance of AccessibleRole describing the role of the
+ * object
+ * @see AccessibleRole
+ */
+ public AccessibleRole getAccessibleRole() {
+ return AccessibleRole.INTERNAL_FRAME;
+ }
+
+ /**
+ * Gets the AccessibleValue associated with this object. In the
+ * implementation of the Java Accessibility API for this class,
+ * returns this object, which is responsible for implementing the
+ * <code>AccessibleValue</code> interface on behalf of itself.
+ *
+ * @return this object
+ */
+ public AccessibleValue getAccessibleValue() {
+ return this;
+ }
+
+
+ //
+ // AccessibleValue methods
+ //
+
+ /**
+ * Get the value of this object as a Number.
+ *
+ * @return value of the object -- can be <code>null</code> if this object does not
+ * have a value
+ */
+ public Number getCurrentAccessibleValue() {
+ return Integer.valueOf(getLayer());
+ }
+
+ /**
+ * Set the value of this object as a Number.
+ *
+ * @return <code>true</code> if the value was set
+ */
+ public boolean setCurrentAccessibleValue(Number n) {
+ // TIGER - 4422535
+ if (n == null) {
+ return false;
+ }
+ setLayer(Integer.valueOf(n.intValue()));
+ return true;
+ }
+
+ /**
+ * Get the minimum value of this object as a Number.
+ *
+ * @return Minimum value of the object; <code>null</code> if this object does not
+ * have a minimum value
+ */
+ public Number getMinimumAccessibleValue() {
+ return Integer.MIN_VALUE;
+ }
+
+ /**
+ * Get the maximum value of this object as a Number.
+ *
+ * @return Maximum value of the object; <code>null</code> if this object does not
+ * have a maximum value
+ */
+ public Number getMaximumAccessibleValue() {
+ return Integer.MAX_VALUE;
+ }
+
+ } // AccessibleJInternalFrame
+
+ /**
+ * This component represents an iconified version of a
+ * <code>JInternalFrame</code>.
+ * This API should NOT BE USED by Swing applications, as it will go
+ * away in future versions of Swing as its functionality is moved into
+ * <code>JInternalFrame</code>. This class is public only so that
+ * UI objects can display a desktop icon. If an application
+ * wants to display a desktop icon, it should create a
+ * <code>JInternalFrame</code> instance and iconify it.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing. As of 1.4, support for long term storage
+ * of all JavaBeans™
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ *
+ * @author David Kloba
+ */
+ @SuppressWarnings("serial") // Same-version serialization only
+ static public class JDesktopIcon extends JComponent implements Accessible
+ {
+ JInternalFrame internalFrame;
+
+ /**
+ * Creates an icon for an internal frame.
+ *
+ * @param f the <code>JInternalFrame</code>
+ * for which the icon is created
+ */
+ public JDesktopIcon(JInternalFrame f) {
+ setVisible(false);
+ setInternalFrame(f);
+ updateUI();
+ }
+
+ /**
+ * Returns the look-and-feel object that renders this component.
+ *
+ * @return the <code>DesktopIconUI</code> object that renders
+ * this component
+ */
+ public DesktopIconUI getUI() {
+ return (DesktopIconUI)ui;
+ }
+
+ /**
+ * Sets the look-and-feel object that renders this component.
+ *
+ * @param ui the <code>DesktopIconUI</code> look-and-feel object
+ * @see UIDefaults#getUI
+ */
+ public void setUI(DesktopIconUI ui) {
+ super.setUI(ui);
+ }
+
+ /**
+ * Returns the <code>JInternalFrame</code> that this
+ * <code>DesktopIcon</code> is associated with.
+ *
+ * @return the <code>JInternalFrame</code> with which this icon
+ * is associated
+ */
+ public JInternalFrame getInternalFrame() {
+ return internalFrame;
+ }
+
+ /**
+ * Sets the <code>JInternalFrame</code> with which this
+ * <code>DesktopIcon</code> is associated.
+ *
+ * @param f the <code>JInternalFrame</code> with which this icon
+ * is associated
+ */
+ public void setInternalFrame(JInternalFrame f) {
+ internalFrame = f;
+ }
+
+ /**
+ * Convenience method to ask the icon for the <code>Desktop</code>
+ * object it belongs to.
+ *
+ * @return the <code>JDesktopPane</code> that contains this
+ * icon's internal frame, or <code>null</code> if none found
+ */
+ public JDesktopPane getDesktopPane() {
+ if(getInternalFrame() != null)
+ return getInternalFrame().getDesktopPane();
+ return null;
+ }
+
+ /**
+ * Notification from the <code>UIManager</code> that the look and feel
+ * has changed.
+ * Replaces the current UI object with the latest version from the
+ * <code>UIManager</code>.
+ *
+ * @see JComponent#updateUI
+ */
+ public void updateUI() {
+ boolean hadUI = (ui != null);
+ setUI((DesktopIconUI)UIManager.getUI(this));
+ invalidate();
+
+ Dimension r = getPreferredSize();
+ setSize(r.width, r.height);
+
+
+ if (internalFrame != null && internalFrame.getUI() != null) { // don't do this if UI not created yet
+ SwingUtilities.updateComponentTreeUI(internalFrame);
+ }
+ }
+
+ /* This method is called if updateUI was called on the associated
+ * JInternalFrame. It's necessary to avoid infinite recursion.
+ */
+ void updateUIWhenHidden() {
+ /* Update this UI and any associated internal frame */
+ setUI((DesktopIconUI)UIManager.getUI(this));
+
+ Dimension r = getPreferredSize();
+ setSize(r.width, r.height);
+
+ invalidate();
+ Component[] children = getComponents();
+ if (children != null) {
+ for (Component child : children) {
+ SwingUtilities.updateComponentTreeUI(child);
+ }
+ }
+ }
+
+ /**
+ * Returns the name of the look-and-feel
+ * class that renders this component.
+ *
+ * @return the string "DesktopIconUI"
+ * @see JComponent#getUIClassID
+ * @see UIDefaults#getUI
+ */
+ public String getUIClassID() {
+ return "DesktopIconUI";
+ }
+ ////////////////
+ // Serialization support
+ ////////////////
+ private void writeObject(ObjectOutputStream s) throws IOException {
+ s.defaultWriteObject();
+ if (getUIClassID().equals("DesktopIconUI")) {
+ byte count = JComponent.getWriteObjCounter(this);
+ JComponent.setWriteObjCounter(this, --count);
+ if (count == 0 && ui != null) {
+ ui.installUI(this);
+ }
+ }
+ }
+
+ /////////////////
+ // Accessibility support
+ ////////////////
+
+ /**
+ * Gets the AccessibleContext associated with this JDesktopIcon.
+ * For desktop icons, the AccessibleContext takes the form of an
+ * AccessibleJDesktopIcon.
+ * A new AccessibleJDesktopIcon instance is created if necessary.
+ *
+ * @return an AccessibleJDesktopIcon that serves as the
+ * AccessibleContext of this JDesktopIcon
+ */
+ public AccessibleContext getAccessibleContext() {
+ if (accessibleContext == null) {
+ accessibleContext = new AccessibleJDesktopIcon();
+ }
+ return accessibleContext;
+ }
+
+ /**
+ * This class implements accessibility support for the
+ * <code>JInternalFrame.JDesktopIcon</code> class. It provides an
+ * implementation of the Java Accessibility API appropriate to
+ * desktop icon user-interface elements.
+ * <p>
+ * <strong>Warning:</strong>
+ * Serialized objects of this class will not be compatible with
+ * future Swing releases. The current serialization support is
+ * appropriate for short term storage or RMI between applications running
+ * the same version of Swing. As of 1.4, support for long term storage
+ * of all JavaBeans™
+ * has been added to the <code>java.beans</code> package.
+ * Please see {@link java.beans.XMLEncoder}.
+ */
+ @SuppressWarnings("serial") // Same-version serialization only
+ protected class AccessibleJDesktopIcon extends AccessibleJComponent
+ implements AccessibleValue {
+
+ /**
+ * Gets the role of this object.
+ *
+ * @return an instance of AccessibleRole describing the role of the
+ * object
+ * @see AccessibleRole
+ */
+ public AccessibleRole getAccessibleRole() {
+ return AccessibleRole.DESKTOP_ICON;
+ }
+
+ /**
+ * Gets the AccessibleValue associated with this object. In the
+ * implementation of the Java Accessibility API for this class,
+ * returns this object, which is responsible for implementing the
+ * <code>AccessibleValue</code> interface on behalf of itself.
+ *
+ * @return this object
+ */
+ public AccessibleValue getAccessibleValue() {
+ return this;
+ }
+
+ //
+ // AccessibleValue methods
+ //
+
+ /**
+ * Gets the value of this object as a <code>Number</code>.
+ *
+ * @return value of the object -- can be <code>null</code> if this object does not
+ * have a value
+ */
+ public Number getCurrentAccessibleValue() {
+ AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
+ AccessibleValue v = a.getAccessibleValue();
+ if (v != null) {
+ return v.getCurrentAccessibleValue();
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Sets the value of this object as a <code>Number</code>.
+ *
+ * @return <code>true</code> if the value was set
+ */
+ public boolean setCurrentAccessibleValue(Number n) {
+ // TIGER - 4422535
+ if (n == null) {
+ return false;
+ }
+ AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
+ AccessibleValue v = a.getAccessibleValue();
+ if (v != null) {
+ return v.setCurrentAccessibleValue(n);
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Gets the minimum value of this object as a <code>Number</code>.
+ *
+ * @return minimum value of the object; <code>null</code> if this object does not
+ * have a minimum value
+ */
+ public Number getMinimumAccessibleValue() {
+ AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
+ if (a instanceof AccessibleValue) {
+ return ((AccessibleValue)a).getMinimumAccessibleValue();
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Gets the maximum value of this object as a <code>Number</code>.
+ *
+ * @return maximum value of the object; <code>null</code> if this object does not
+ * have a maximum value
+ */
+ public Number getMaximumAccessibleValue() {
+ AccessibleContext a = JDesktopIcon.this.getInternalFrame().getAccessibleContext();
+ if (a instanceof AccessibleValue) {
+ return ((AccessibleValue)a).getMaximumAccessibleValue();
+ } else {
+ return null;
+ }
+ }
+
+ } // AccessibleJDesktopIcon
+ }
+}