/*
* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
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.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="https://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
* @beaninfo
* attribute: isContainer true
* attribute: containerDelegate getContentPane
* description: A frame container which is contained within
* another window.
*/
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>internalFrameClosing</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}.
*/
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(new
Integer(
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
*/
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}.
*/
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
}
}