| /* JInternalFrame.java -- |
| Copyright (C) 2002, 2004, 2005, 2006, Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package javax.swing; |
| |
| import java.awt.BorderLayout; |
| import java.awt.Component; |
| import java.awt.Container; |
| import java.awt.Graphics; |
| import java.awt.IllegalComponentStateException; |
| import java.awt.KeyboardFocusManager; |
| import java.awt.LayoutManager; |
| import java.awt.Rectangle; |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyVetoException; |
| |
| import javax.accessibility.Accessible; |
| import javax.accessibility.AccessibleContext; |
| import javax.accessibility.AccessibleRole; |
| import javax.accessibility.AccessibleValue; |
| import javax.swing.event.InternalFrameEvent; |
| import javax.swing.event.InternalFrameListener; |
| import javax.swing.plaf.DesktopIconUI; |
| import javax.swing.plaf.InternalFrameUI; |
| |
| /** |
| * This class implements a Swing widget that looks and acts like a native |
| * frame. The frame can be dragged, resized, closed, etc. Typically, |
| * JInternalFrames are placed in JDesktopPanes. The actions that the |
| * JInternalFrame performs (maximizing, minimizing, etc.) are performed by a |
| * DesktopManager. As with regular frames, components are added by calling |
| * frame.getContentPane().add. |
| */ |
| public class JInternalFrame extends JComponent implements Accessible, |
| WindowConstants, |
| RootPaneContainer |
| { |
| |
| private static final long serialVersionUID = -5425177187760785402L; |
| |
| /** |
| * Provides the accessibility features for the <code>JInternalFrame</code> |
| * component. |
| */ |
| protected class AccessibleJInternalFrame extends AccessibleJComponent |
| implements AccessibleValue |
| { |
| private static final long serialVersionUID = 5931936924175476797L; |
| |
| /** |
| * Creates a new <code>AccessibleJInternalFrame</code> instance. |
| */ |
| protected AccessibleJInternalFrame() |
| { |
| super(); |
| } |
| |
| /** |
| * Returns the frame title. |
| * |
| * @return The frame title. |
| */ |
| public String getAccessibleName() |
| { |
| return getTitle(); |
| } |
| |
| /** |
| * Returns the accessible role for the <code>JInternalFrame</code> |
| * component. |
| * |
| * @return {@link AccessibleRole#INTERNAL_FRAME}. |
| */ |
| public AccessibleRole getAccessibleRole() |
| { |
| return AccessibleRole.INTERNAL_FRAME; |
| } |
| |
| /** |
| * Returns an object that provides access to the current, minimum and |
| * maximum values for the {@link JInternalFrame}. Since this class |
| * implements {@link AccessibleValue}, it returns itself. |
| * |
| * @return The accessible value. |
| */ |
| public AccessibleValue getAccessibleValue() |
| { |
| return this; |
| } |
| |
| /** |
| * Returns the current layer for the {@link JInternalFrame} component, |
| * as an {@link Integer}. |
| * |
| * @return The layer for the {@link JInternalFrame} component. |
| */ |
| public Number getCurrentAccessibleValue() |
| { |
| return new Integer(getLayer()); |
| } |
| |
| /** |
| * Returns the maximum permitted accessible value. |
| * |
| * @return <code>Integer(Integer.MAX_VALUE)</code>. |
| */ |
| public Number getMaximumAccessibleValue() |
| { |
| return new Integer(Integer.MAX_VALUE); |
| } |
| |
| /** |
| * Returns the minimum permitted accessible value. |
| * |
| * @return <code>Integer(Integer.MIN_VALUE)</code>. |
| */ |
| public Number getMinimumAccessibleValue() |
| { |
| return new Integer(Integer.MIN_VALUE); |
| } |
| |
| /** |
| * Sets the layer for the internal frame. |
| * |
| * @param n the layer (see the constants defined in {@link JLayeredPane}). |
| * |
| * @return <code>true</code> if the value is set, and <code>false</code> |
| * if it was not set. |
| */ |
| public boolean setCurrentAccessibleValue(Number n) |
| { |
| if (n == null) |
| return false; |
| setLayer(n.intValue()); |
| return true; |
| } |
| } |
| |
| /** |
| * This class represents the JInternalFrame while it is iconified. |
| */ |
| public static class JDesktopIcon extends JComponent implements Accessible |
| { |
| /** |
| * Provides the accessibility features for the <code>JDesktopIcon</code> |
| * component. |
| */ |
| protected class AccessibleJDesktopIcon extends AccessibleJComponent |
| implements AccessibleValue |
| { |
| private static final long serialVersionUID = 5035560458941637802L; |
| |
| /** |
| * Creates a new <code>AccessibleJDesktopIcon</code> instance. |
| */ |
| protected AccessibleJDesktopIcon() |
| { |
| super(); |
| } |
| |
| /** |
| * Returns the accessible role for the <code>JDesktopIcon</code> |
| * component. |
| * |
| * @return {@link AccessibleRole#DESKTOP_ICON}. |
| */ |
| public AccessibleRole getAccessibleRole() |
| { |
| return AccessibleRole.DESKTOP_ICON; |
| } |
| |
| /** |
| * Returns an object that provides access to the current, minimum and |
| * maximum values for the {@link JDesktopIcon}. Since this class |
| * implements {@link AccessibleValue}, it returns itself. |
| * |
| * @return The accessible value. |
| */ |
| public AccessibleValue getAccessibleValue() |
| { |
| return this; |
| } |
| |
| /** |
| * Returns the current layer for the {@link JInternalFrame} component |
| * represented by this <code>JDesktopIcon</code>, as an {@link Integer}. |
| * |
| * @return The layer. |
| */ |
| public Number getCurrentAccessibleValue() |
| { |
| return new Integer(frame.getLayer()); |
| } |
| |
| /** |
| * Returns the maximum permitted accessible value. |
| * |
| * @return <code>Integer(Integer.MAX_VALUE)</code>. |
| */ |
| public Number getMaximumAccessibleValue() |
| { |
| return new Integer(Integer.MAX_VALUE); |
| } |
| |
| /** |
| * Returns the minimum permitted accessible value. |
| * |
| * @return <code>Integer(Integer.MIN_VALUE)</code>. |
| */ |
| public Number getMinimumAccessibleValue() |
| { |
| return new Integer(Integer.MIN_VALUE); |
| } |
| |
| /** |
| * Sets the layer for the internal frame represented by this |
| * <code>JDesktopIcon</code> component. |
| * |
| * @param n the layer (see the constants defined in |
| * {@link JLayeredPane}). |
| * |
| * @return <code>true</code> if the value is set, and <code>false</code> |
| * if it was not set. |
| */ |
| public boolean setCurrentAccessibleValue(Number n) |
| { |
| if (n == null) |
| return false; |
| frame.setLayer(n.intValue()); |
| return true; |
| } |
| } |
| |
| private static final long serialVersionUID = 4672973344731387687L; |
| |
| /** The JInternalFrame this DesktopIcon represents. */ |
| JInternalFrame frame; |
| |
| /** |
| * Creates a new JDesktopIcon object for representing the given frame. |
| * |
| * @param f The JInternalFrame to represent. |
| */ |
| public JDesktopIcon(JInternalFrame f) |
| { |
| frame = f; |
| updateUI(); |
| } |
| |
| /** |
| * Returns the object that provides accessibility features for this |
| * <code>JDesktopIcon</code> component. |
| * |
| * @return The accessible context (an instance of |
| * {@link AccessibleJDesktopIcon}). |
| */ |
| public AccessibleContext getAccessibleContext() |
| { |
| if (accessibleContext == null) |
| accessibleContext = new AccessibleJDesktopIcon(); |
| return accessibleContext; |
| } |
| |
| /** |
| * This method returns the JDesktopPane this JDesktopIcon is in. |
| * |
| * @return The JDesktopPane this JDesktopIcon is in. |
| */ |
| public JDesktopPane getDesktopPane() |
| { |
| JDesktopPane p = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class, |
| this); |
| return p; |
| } |
| |
| /** |
| * This method returns the JInternalFrame this JDesktopIcon represents. |
| * |
| * @return The JInternalFrame this JDesktopIcon represents. |
| */ |
| public JInternalFrame getInternalFrame() |
| { |
| return frame; |
| } |
| |
| /** |
| * This method returns the UI that is responsible for the JDesktopIcon. |
| * |
| * @return The UI that is responsible for the JDesktopIcon. |
| */ |
| public DesktopIconUI getUI() |
| { |
| return (DesktopIconUI) ui; |
| } |
| |
| /** |
| * This method returns the String identifier that is used to determine |
| * which class is used for JDesktopIcon's UI. |
| * |
| * @return A String identifier for the UI class. |
| */ |
| public String getUIClassID() |
| { |
| return "DesktopIconUI"; |
| } |
| |
| /** |
| * This method sets the JInternalFrame that this JDesktopIcon represents. |
| * |
| * @param f The JInternalFrame that this JDesktopIcon represents. |
| */ |
| public void setInternalFrame(JInternalFrame f) |
| { |
| frame = f; |
| } |
| |
| /** |
| * This method sets the UI used for this JDesktopIcon. |
| * |
| * @param ui The UI to use. |
| */ |
| public void setUI(DesktopIconUI ui) |
| { |
| super.setUI(ui); |
| } |
| |
| /** |
| * This method restores the UI property to the defaults. |
| */ |
| public void updateUI() |
| { |
| setUI((DesktopIconUI) UIManager.getUI(this)); |
| } |
| } |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the contentPane property |
| * changes. |
| */ |
| public static final String CONTENT_PANE_PROPERTY = "contentPane"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the frameIcon property |
| * changes. |
| */ |
| public static final String FRAME_ICON_PROPERTY = "frameIcon"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the glassPane property |
| * changes. |
| */ |
| public static final String GLASS_PANE_PROPERTY = "glassPane"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the closed property |
| * changes. |
| */ |
| public static final String IS_CLOSED_PROPERTY = "closed"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the icon property |
| * changes. |
| */ |
| public static final String IS_ICON_PROPERTY = "icon"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the maximum property |
| * changes. |
| */ |
| public static final String IS_MAXIMUM_PROPERTY = "maximum"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the selected property |
| * changes. |
| */ |
| public static final String IS_SELECTED_PROPERTY = "selected"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the layeredPane property |
| * changes. |
| */ |
| public static final String LAYERED_PANE_PROPERTY = "layeredPane"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the jMenuBar property |
| * changes. |
| */ |
| public static final String MENU_BAR_PROPERTY = "JMenuBar"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the rootPane property |
| * changes. |
| */ |
| public static final String ROOT_PANE_PROPERTY = "rootPane"; |
| |
| /** |
| * The property fired in a PropertyChangeEvent when the title property |
| * changes. |
| */ |
| public static final String TITLE_PROPERTY = "title"; |
| |
| /** Whether the JInternalFrame is closable. */ |
| protected boolean closable; |
| |
| /** Whether the JInternalFrame can be iconified. */ |
| protected boolean iconable; |
| |
| /** Whether the JInternalFrame is closed. */ |
| protected boolean isClosed; |
| |
| /** Whether the JInternalFrame has been iconified. */ |
| protected boolean isIcon; |
| |
| /** Whether the JInternalFrame has been maximized. */ |
| protected boolean isMaximum; |
| |
| /** Whether the JInternalFrame is the active frame. */ |
| protected boolean isSelected; |
| |
| /** Whether the JInternalFrame can be maximized. */ |
| protected boolean maximizable; |
| |
| /** |
| * Whether the JInternalFrame has rootPaneChecking enabled. |
| * |
| * @specnote Should be false to comply with J2SE 5.0 |
| */ |
| protected boolean rootPaneCheckingEnabled = false; |
| |
| /** Whether the JInternalFrame is resizable. */ |
| protected boolean resizable; |
| |
| /** |
| * The JDesktopIcon that represents the JInternalFrame while it is |
| * iconified. |
| */ |
| protected JDesktopIcon desktopIcon; |
| |
| /** The icon used in the JMenuBar in the TitlePane. */ |
| protected Icon frameIcon; |
| |
| /** The rootPane of the JInternalFrame. */ |
| protected JRootPane rootPane; |
| |
| /** The title on the TitlePane of the JInternalFrame. */ |
| protected String title; |
| |
| /** The bounds of the JInternalFrame before it was maximized. */ |
| private transient Rectangle storedBounds; |
| |
| /** The Component that receives focus by default. */ |
| private transient Component defaultFocus; |
| |
| /** The default close action taken, */ |
| private transient int defaultCloseOperation = DISPOSE_ON_CLOSE; |
| |
| /** Whether the JInternalFrame has become visible for the very first time. */ |
| private transient boolean isFirstTimeVisible = true; |
| |
| /** DOCUMENT ME! */ |
| private transient boolean wasIcon = false; |
| |
| /** |
| * Creates a new JInternalFrame object that has an empty string for its |
| * title, and is non-resizable, non-maximizable, non-iconifiable, and |
| * non-closable. |
| */ |
| public JInternalFrame() |
| { |
| this("", false, false, false, false); |
| } |
| |
| /** |
| * Creates a new JInternalFrame object with the given title and is |
| * non-resizable, non-maximizable, non-iconifiable, and non-closable. |
| * |
| * @param title The title displayed in the JInternalFrame. |
| */ |
| public JInternalFrame(String title) |
| { |
| this(title, false, false, false, false); |
| } |
| |
| /** |
| * Creates a new JInternalFrame object with the given title and resizable |
| * properties. The JInternalFrame is non-maximizable, non-iconifiable, and |
| * non-closable. |
| * |
| * @param title The title displayed in the JInternalFrame. |
| * @param resizable Whether the JInternalFrame is resizable. |
| */ |
| public JInternalFrame(String title, boolean resizable) |
| { |
| this(title, resizable, false, false, false); |
| } |
| |
| /** |
| * Creates a new JInternalFrame object with the given title, resizable, and |
| * closable properties. The JInternalFrame is non-maximizable and |
| * non-iconifiable. |
| * |
| * @param title The title displayed in the JInternalFrame. |
| * @param resizable Whether the JInternalFrame is resizable. |
| * @param closable Whether the JInternalFrame is closable. |
| */ |
| public JInternalFrame(String title, boolean resizable, boolean closable) |
| { |
| this(title, resizable, closable, false, false); |
| } |
| |
| /** |
| * Creates a new JInternalFrame object with the given title, resizable, |
| * closable and maximizable properties. The JInternalFrame is |
| * non-iconifiable. |
| * |
| * @param title The title displayed in the JInternalFrame. |
| * @param resizable Whether the JInternalFrame is resizable. |
| * @param closable Whether the JInternalFrame is closable. |
| * @param maximizable Whether the JInternalFrame is maximizable. |
| */ |
| public JInternalFrame(String title, boolean resizable, boolean closable, |
| boolean maximizable) |
| { |
| this(title, resizable, closable, maximizable, false); |
| } |
| |
| /** |
| * Creates a new JInternalFrame object with the given title, resizable, |
| * closable, maximizable and iconifiable properties. |
| * |
| * @param title The title displayed in the JInternalFrame. |
| * @param resizable Whether the JInternalFrame is resizable. |
| * @param closable Whether the JInternalFrame is closable. |
| * @param maximizable Whether the JInternalFrame is maximizable. |
| * @param iconifiable Whether the JInternalFrame is iconifiable. |
| */ |
| public JInternalFrame(String title, boolean resizable, boolean closable, |
| boolean maximizable, boolean iconifiable) |
| { |
| this.title = title; |
| this.resizable = resizable; |
| this.closable = closable; |
| this.maximizable = maximizable; |
| this.iconable = iconifiable; |
| isMaximum = false; |
| setRootPane(createRootPane()); |
| // JInternalFrames are invisible and opaque by default. |
| setVisible(false); |
| setOpaque(true); |
| desktopIcon = new JDesktopIcon(this); |
| updateUI(); |
| setRootPaneCheckingEnabled(true); // Done the init stage, now adds go to content pane. |
| } |
| |
| /** |
| * This method adds Components to this Container. For JInternalFrames, |
| * instead of calling add directly on the JInternalFrame, it should be |
| * called with JInternalFrame.getContentPane().add. If root pane checking |
| * is enabled, calling this method will cause an exception to be thrown. |
| * |
| * @param comp The Component to add. |
| * @param constraints The constraints on the Component added. |
| * @param index The position to place the Component. |
| * |
| * @throws Error DOCUMENT ME! |
| */ |
| protected void addImpl(Component comp, Object constraints, int index) |
| { |
| // If we're in the initialization stage use super.add. Here we add the |
| // rootPane as well as the title bar and other stuff. |
| // Otherwise pass the add onto the content pane. |
| if (isRootPaneCheckingEnabled()) |
| getContentPane().add(comp, constraints, index); |
| else |
| super.addImpl(comp,constraints, index); |
| } |
| |
| /** |
| * This method adds an InternalFrameListener to this JInternalFrame. |
| * |
| * @param l The listener to add. |
| */ |
| public void addInternalFrameListener(InternalFrameListener l) |
| { |
| listenerList.add(InternalFrameListener.class, l); |
| } |
| |
| /** |
| * This method is used to create a root pane for the JInternalFrame. This |
| * method is called by the constructors. |
| * |
| * @return A root pane for the JInternalFrame to use. |
| */ |
| protected JRootPane createRootPane() |
| { |
| return new JRootPane(); |
| } |
| |
| /** |
| * This method makes this JInternalFrame invisible, unselected and closed. |
| * If this JInternalFrame is not closed already, it will fire an |
| * INTERNAL_FRAME_CLoSED event. This method is similar to setClosed but it |
| * doesn't give vetoable listeners a chance to veto and it will not fire an |
| * INTERNAL_FRAME_CLOSING event. |
| */ |
| public void dispose() |
| { |
| if (isVisible()) |
| setVisible(false); |
| if (isSelected()) |
| { |
| try |
| { |
| setSelected(false); |
| } |
| catch (PropertyVetoException e) |
| { |
| // Do nothing if they don't want to be unselected. |
| } |
| } |
| if (! isClosed) |
| { |
| firePropertyChange(IS_CLOSED_PROPERTY, Boolean.FALSE, Boolean.TRUE); |
| isClosed = true; |
| } |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSED); |
| } |
| |
| /** |
| * This method is used for closing this JInternalFrame. It fires an |
| * INTERNAL_FRAME_CLOSING event and then performs the action specified by |
| * the default close operation. |
| */ |
| public void doDefaultCloseAction() |
| { |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING); |
| switch (getDefaultCloseOperation()) |
| { |
| case HIDE_ON_CLOSE: |
| setVisible(false); |
| break; |
| case DISPOSE_ON_CLOSE: |
| dispose(); |
| break; |
| } |
| } |
| |
| /** |
| * This method fires an InternalFrameEvent to the listeners. |
| * |
| * @param id The type of event being fired. See InternalFrameEvent. |
| */ |
| protected void fireInternalFrameEvent(int id) |
| { |
| Object[] ifListeners = listenerList.getListenerList(); |
| InternalFrameEvent evt = new InternalFrameEvent(this, id); |
| switch (id) |
| { |
| case InternalFrameEvent.INTERNAL_FRAME_CLOSING: |
| for (int i = ifListeners.length - 2; i >= 0; i -= 2) |
| { |
| if (ifListeners[i] == InternalFrameListener.class) |
| ((InternalFrameListener) ifListeners[i + 1]) |
| .internalFrameClosing(evt); |
| } |
| break; |
| case InternalFrameEvent.INTERNAL_FRAME_ACTIVATED: |
| for (int i = ifListeners.length - 2; i >= 0; i -= 2) |
| { |
| if (ifListeners[i] == InternalFrameListener.class) |
| ((InternalFrameListener) ifListeners[i + 1]) |
| .internalFrameActivated(evt); |
| } |
| break; |
| case InternalFrameEvent.INTERNAL_FRAME_CLOSED: |
| for (int i = ifListeners.length - 2; i >= 0; i -= 2) |
| { |
| if (ifListeners[i] == InternalFrameListener.class) |
| ((InternalFrameListener) ifListeners[i + 1]).internalFrameClosed(evt); |
| } |
| break; |
| case InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED: |
| for (int i = ifListeners.length - 2; i >= 0; i -= 2) |
| { |
| if (ifListeners[i] == InternalFrameListener.class) |
| ((InternalFrameListener) ifListeners[i + 1]) |
| .internalFrameDeactivated(evt); |
| } |
| break; |
| case InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED: |
| for (int i = ifListeners.length - 2; i >= 0; i -= 2) |
| { |
| if (ifListeners[i] == InternalFrameListener.class) |
| ((InternalFrameListener) ifListeners[i + 1]) |
| .internalFrameDeiconified(evt); |
| } |
| break; |
| case InternalFrameEvent.INTERNAL_FRAME_ICONIFIED: |
| for (int i = ifListeners.length - 2; i >= 0; i -= 2) |
| { |
| if (ifListeners[i] == InternalFrameListener.class) |
| ((InternalFrameListener) ifListeners[i + 1]) |
| .internalFrameIconified(evt); |
| } |
| break; |
| case InternalFrameEvent.INTERNAL_FRAME_OPENED: |
| for (int i = ifListeners.length - 2; i >= 0; i -= 2) |
| { |
| if (ifListeners[i] == InternalFrameListener.class) |
| ((InternalFrameListener) ifListeners[i + 1]).internalFrameOpened(evt); |
| } |
| break; |
| } |
| } |
| |
| /** |
| * Returns the object that provides accessibility features for this |
| * <code>JInternalFrame</code> component. |
| * |
| * @return The accessible context (an instance of |
| * {@link AccessibleJInternalFrame}). |
| */ |
| public AccessibleContext getAccessibleContext() |
| { |
| if (accessibleContext == null) |
| accessibleContext = new AccessibleJInternalFrame(); |
| return accessibleContext; |
| } |
| |
| /** |
| * This method returns the Content Pane for this JInternalFrame. |
| * |
| * @return The Content Pane for this JInternalFrame. |
| */ |
| public Container getContentPane() |
| { |
| return getRootPane().getContentPane(); |
| } |
| |
| /** |
| * Returns a code for the default action taken when this |
| * <code>JInternalFrame</code> is closed. |
| * |
| * @return The action code (usually one of |
| * {@link WindowConstants#DO_NOTHING_ON_CLOSE}, |
| * {@link WindowConstants#HIDE_ON_CLOSE}, or |
| * {@link WindowConstants#DISPOSE_ON_CLOSE}). |
| * |
| * @see #setDefaultCloseOperation(int) |
| * @see #doDefaultCloseAction() |
| */ |
| public int getDefaultCloseOperation() |
| { |
| return defaultCloseOperation; |
| } |
| |
| /** |
| * Returns the <code>JDesktopIcon</code> that represents this |
| * <code>JInternalFrame</code> while it is iconified. |
| * |
| * @return The desktop icon component. |
| */ |
| public JDesktopIcon getDesktopIcon() |
| { |
| return desktopIcon; |
| } |
| |
| /** |
| * This method searches this JInternalFrame ancestors for an instance of |
| * JDesktopPane. If one is found, it is returned. If none is found, then it |
| * will search the JDesktopIcon for a JDesktopPane. |
| * |
| * @return The JDesktopPane that this JInternalFrame belongs to. |
| */ |
| public JDesktopPane getDesktopPane() |
| { |
| JDesktopPane value = (JDesktopPane) SwingUtilities.getAncestorOfClass(JDesktopPane.class, |
| this); |
| if (value == null && desktopIcon != null) |
| value = desktopIcon.getDesktopPane(); |
| return value; |
| } |
| |
| /** |
| * This method returns null because this must always be the root of a focus |
| * traversal. |
| * |
| * @return always null |
| * |
| * @since 1.4 |
| */ |
| public final Container getFocusCycleRootAncestor() |
| { |
| // as defined. |
| return null; |
| } |
| |
| /** |
| * This method returns the child Component that will receive focus if this |
| * JInternalFrame is selected. |
| * |
| * @return The child Component that will receive focus. |
| */ |
| public Component getFocusOwner() |
| { |
| if (isSelected()) |
| { |
| Component focus = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); |
| if (SwingUtilities.isDescendingFrom(focus, this)) |
| { |
| defaultFocus = focus; |
| return focus; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * This method returns the Frame Icon (the icon used in the JInternalFrame |
| * TitlePane and iconified frame). |
| * |
| * @return The Frame Icon. |
| */ |
| public Icon getFrameIcon() |
| { |
| return frameIcon; |
| } |
| |
| /** |
| * This method returns the Glass Pane used with this JInternalFrame. |
| * |
| * @return The Glass Pane used with this JInternalFrame. |
| */ |
| public Component getGlassPane() |
| { |
| return getRootPane().getGlassPane(); |
| } |
| |
| /** |
| * This method returns an array of InternalFrameListeners that are listening |
| * to this JInternalFrame. |
| * |
| * @return An array of InternalFrameListeners that are listening to this |
| * JInternalFrame. |
| */ |
| public InternalFrameListener[] getInternalFrameListeners() |
| { |
| return (InternalFrameListener[]) listenerList.getListeners(InternalFrameListener.class); |
| } |
| |
| /** |
| * This method returns the JMenuBar for this JInternalFrame. |
| * |
| * @return The JMenuBar for this JInternalFrame. |
| */ |
| public JMenuBar getJMenuBar() |
| { |
| return getRootPane().getJMenuBar(); |
| } |
| |
| /** |
| * This method returns the layer that this JInternalFrame resides in. |
| * |
| * @return The layer that this JInternalFrame resides in. |
| */ |
| public int getLayer() |
| { |
| return JLayeredPane.getLayer(this); |
| } |
| |
| /** |
| * This method returns the LayeredPane for this JInternalFrame. |
| * |
| * @return The LayeredPane for this JInternalFrame. |
| */ |
| public JLayeredPane getLayeredPane() |
| { |
| return getRootPane().getLayeredPane(); |
| } |
| |
| /** |
| * This method is deprecated. This method returns the JMenuBar for this |
| * JInternalFrame. |
| * |
| * @return The JMenuBar for this JInternalFrame. |
| * |
| * @deprecated 1.0.3 |
| */ |
| public JMenuBar getMenuBar() |
| { |
| return getJMenuBar(); |
| } |
| |
| /** |
| * This method returns the child Component that will receive focus when the |
| * JInternalFrame is selected. If the JInternalFrame is selected, this |
| * method returns getFocusOwner(). Otherwise, it will return the child |
| * Component that most recently requested focus. If that is null, then the |
| * initial focus Component is returned. If that is null, then the default |
| * focus component is returned. |
| * |
| * @return The most recent focus owner. |
| */ |
| public Component getMostRecentFocusOwner() |
| { |
| if (isSelected()) |
| return getFocusOwner(); |
| else |
| return defaultFocus; |
| } |
| |
| /** |
| * This method returns the bounds of the JInternalFrame if it is not |
| * maximized. If it is maximized, it returns the bounds of the |
| * JInternalFrame before it was maximized (the bounds that it will be |
| * restored to). |
| * |
| * @return A Rectangle that contains this JInternalFrame's normal bounds (or |
| * just its bounds if it is not maximized). |
| */ |
| public Rectangle getNormalBounds() |
| { |
| if (storedBounds == null) |
| return getBounds(); |
| else |
| return storedBounds; |
| } |
| |
| /** |
| * This method returns the Root Pane for this JInternalFrame. |
| * |
| * @return The Root Pane for this JInternalFrame. |
| */ |
| public JRootPane getRootPane() |
| { |
| return rootPane; |
| } |
| |
| /** |
| * Returns the frame's title. |
| * |
| * @return The frame's title (can be <code>null</code>). |
| * |
| * @see #setTitle(String) |
| */ |
| public String getTitle() |
| { |
| return title; |
| } |
| |
| /** |
| * This method returns the UI used to represent the JInternalFrame. |
| * |
| * @return The UI used to represent the JInternalFrame. |
| */ |
| public InternalFrameUI getUI() |
| { |
| return (InternalFrameUI) ui; |
| } |
| |
| /** |
| * This method returns a String identifier that is used to determine which |
| * class acts as the JInternalFrame's UI. |
| * |
| * @return A String identifier to determine a UI class. |
| */ |
| public String getUIClassID() |
| { |
| return "InternalFrameUI"; |
| } |
| |
| /** |
| * This method returns null. |
| * |
| * @return null. |
| */ |
| public final String getWarningString() |
| { |
| // as defined. |
| return null; |
| } |
| |
| /** |
| * This method deselects this JInternalFrame and hides it. |
| */ |
| public void hide() |
| { |
| if (isIcon()) |
| getDesktopIcon().hide(); |
| super.hide(); |
| } |
| |
| /** |
| * This method returns whether this JInternalFrame is closable. |
| * |
| * @return Whether this JInternalFrame is closable. |
| */ |
| public boolean isClosable() |
| { |
| return closable; |
| } |
| |
| /** |
| * This method returns whether this JInternalFrame has been closed. |
| * |
| * @return Whether this JInternalFrame is closed. |
| */ |
| public boolean isClosed() |
| { |
| return isClosed; |
| } |
| |
| /** |
| * This must always return true. |
| * |
| * @return always true |
| * |
| * @since 1.4 |
| */ |
| public final boolean isFocusCycleRoot() |
| { |
| return true; |
| } |
| |
| /** |
| * This method returns whether this JInternalFrame is currently iconified. |
| * |
| * @return Whether this JInternalFrame is currently iconified. |
| */ |
| public boolean isIcon() |
| { |
| return isIcon; |
| } |
| |
| /** |
| * This method returns whether the JInternalFrame can be iconified. |
| * |
| * @return Whether the JInternalFrame can be iconified. |
| */ |
| public boolean isIconifiable() |
| { |
| return iconable; |
| } |
| |
| /** |
| * This method returns whether this JInternalFrame can be maximized. |
| * |
| * @return Whether this JInternalFrame can be maximized. |
| */ |
| public boolean isMaximizable() |
| { |
| return maximizable; |
| } |
| |
| /** |
| * This method returns whether this JInternalFrame is currently maximized. |
| * |
| * @return Whether this JInternalFrame is maximized. |
| */ |
| public boolean isMaximum() |
| { |
| return isMaximum; |
| } |
| |
| /** |
| * This method returns whether this JInternalFrame is resizable. |
| * |
| * @return Whether this JInternalFrame is resizable. |
| */ |
| public boolean isResizable() |
| { |
| return resizable; |
| } |
| |
| /** |
| * This method returns whether root pane checking is enabled. If root pane |
| * checking is enabled, then calls to addImpl and setLayout will throw |
| * exceptions. |
| * |
| * @return Whether root pane checking is enabled. |
| */ |
| protected boolean isRootPaneCheckingEnabled() |
| { |
| return rootPaneCheckingEnabled; |
| } |
| |
| /** |
| * This method returns whether this JInternalFrame is selected. |
| * |
| * @return Whether this JInternalFrame is selected. |
| */ |
| public boolean isSelected() |
| { |
| return isSelected; |
| } |
| |
| /** |
| * A helper method that moves this JInternalFrame to the back if the parent |
| * is a JLayeredPane. |
| */ |
| public void moveToBack() |
| { |
| Container p = getParent(); |
| if (p instanceof JLayeredPane) |
| ((JLayeredPane) p).moveToBack(this); |
| } |
| |
| /** |
| * A helper method that moves this JInternalFrame to the front if the parent |
| * is a JLayeredPane. |
| */ |
| public void moveToFront() |
| { |
| Container p = getParent(); |
| if (p != null && p instanceof JLayeredPane) |
| ((JLayeredPane) p).moveToFront(this); |
| } |
| |
| /** |
| * This method causes the children of this JInternalFrame to be laid out. |
| * Before it begins, if this JInternalFrame is an icon, then it will be |
| * deiconified. If it is maximized, then it will be restored. If either |
| * operation fails, then this method will return. |
| */ |
| public void pack() |
| { |
| try |
| { |
| if (isIcon()) |
| setIcon(false); |
| else if (isMaximum()) |
| setMaximum(false); |
| } |
| catch (PropertyVetoException e) |
| { |
| // Do nothing if they don't want to be restored first. |
| } |
| setSize(getPreferredSize()); |
| validate(); |
| } |
| |
| /** |
| * This method is overridden to allow for speedier painting while this |
| * JInternalFramme is being dragged. |
| * |
| * @param g The Graphics object to paint with. |
| */ |
| protected void paintComponent(Graphics g) |
| { |
| super.paintComponent(g); |
| } |
| |
| /** |
| * An implementation dependent string describing the current state of this |
| * <code>JInternalFrame</code> instance. |
| * |
| * @return A string describing the current state of this |
| * <code>JInternalFrame</code> instance. |
| */ |
| protected String paramString() |
| { |
| return super.paramString() + ",title=" + getTitle(); |
| } |
| |
| /** |
| * This method removes the given Component from the Container. |
| * |
| * @param comp The Component to remove. |
| */ |
| public void remove(Component comp) |
| { |
| // If we're removing the root pane, use super.remove. Otherwise |
| // pass it on to the content pane instead. |
| if (comp==rootPane || ! isRootPaneCheckingEnabled()) |
| super.remove(comp); |
| else |
| getContentPane().remove(comp); |
| } |
| |
| /** |
| * This method removes an InternalFrameListener from this JInternalFrame. |
| * |
| * @param l The listener to remove. |
| */ |
| public void removeInternalFrameListener(InternalFrameListener l) |
| { |
| listenerList.remove(InternalFrameListener.class, l); |
| } |
| |
| /** |
| * This method resizes and positions this JInternalFrame. It also forces a |
| * relayout of the Container. |
| * |
| * @param x The x position of this JInternalFrame. |
| * @param y The y position of this JInternalFrame. |
| * @param width The width of this JInternalFrame. |
| * @param height The height of this JInternalFrame. |
| */ |
| public void reshape(int x, int y, int width, int height) |
| { |
| super.reshape(x, y, width, height); |
| revalidate(); |
| } |
| |
| /** |
| * This method gives focus to the last child Component that had focus. This |
| * is used by the UI when this JInternalFrame is activated. |
| */ |
| public void restoreSubcomponentFocus() |
| { |
| Component c = getMostRecentFocusOwner(); |
| if (c != null) |
| c.requestFocus(); |
| } |
| |
| /** |
| * This method sets whether this JInternalFrame can be closed. |
| * |
| * @param b Whether this JInternalFrame can be closed. |
| */ |
| public void setClosable(boolean b) |
| { |
| if (closable != b) |
| { |
| closable = b; |
| firePropertyChange("closable", ! closable, closable); |
| } |
| } |
| |
| /** |
| * This method closes the JInternalFrame if the given boolean is true. If it |
| * is false, then the result of this method is unspecified. If the |
| * JInternalFrame is closed, this method does nothing. This method will |
| * first fire an INTERNAL_FRAME_CLOSING event and give a chance for veto |
| * listeners to cancel the close. If no listener vetoes the change, the |
| * closed property is set to true and the JInternalFrame is hidden and |
| * unselected. The method will finish by firing an INTERNAL_FRAME_CLOSED |
| * event. |
| * |
| * @param b Whether the JInternalFrame will be closed. |
| * |
| * @throws PropertyVetoException If a VetoableChangeListener vetoes the change. |
| */ |
| public void setClosed(boolean b) throws PropertyVetoException |
| { |
| if (b && ! isClosed()) |
| { |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_CLOSING); |
| fireVetoableChange(IS_CLOSED_PROPERTY, false, true); |
| |
| isClosed = b; |
| dispose(); |
| |
| firePropertyChange(IS_CLOSED_PROPERTY, false, true); |
| } |
| } |
| |
| /** |
| * This method sets the Container to be used as a Content Pane for this |
| * JInternalFrame. |
| * |
| * @param c The Container to use as a Content Pane. |
| */ |
| public void setContentPane(Container c) |
| { |
| if (c != getContentPane()) |
| { |
| Container old = getContentPane(); |
| getRootPane().setContentPane(c); |
| firePropertyChange(CONTENT_PANE_PROPERTY, old, c); |
| } |
| } |
| |
| /** |
| * Sets a code for the action to be taken when this |
| * <code>JInternalFrame</code> is closed. Note that no validation is |
| * performed on the <code>operation</code> code, any integer will be |
| * accepted (nevertheless, you should pass in one of the listed values). |
| * |
| * @param operation one of {@link WindowConstants#DO_NOTHING_ON_CLOSE}, |
| * {@link WindowConstants#HIDE_ON_CLOSE} or |
| * {@link WindowConstants#DISPOSE_ON_CLOSE}. |
| * |
| * @see #getDefaultCloseOperation() |
| * @see #doDefaultCloseAction() |
| */ |
| public void setDefaultCloseOperation(int operation) |
| { |
| /* Reference implementation allows invalid operations to be specified. |
| In that case, behaviour defaults to DO_NOTHING_ON_CLOSE. |
| processWindowEvent handles the behaviour. getDefaultCloseOperation |
| must return the invalid operator code. */ |
| defaultCloseOperation = operation; |
| } |
| |
| /** |
| * Sets the <code>JDesktopIcon</code> instance that represents this |
| * <code>JInternalFrame</code> while it is iconified and, if the new icon is |
| * not the same instance as the existing icon, sends a |
| * {@link PropertyChangeEvent} (with the property name |
| * <code>"desktopIcon"</code>) to all registered listeners.. |
| * |
| * @param d the icon. |
| * |
| * @see #getDesktopIcon() |
| */ |
| public void setDesktopIcon(JDesktopIcon d) |
| { |
| if (desktopIcon != d) |
| { |
| JDesktopIcon oldIcon = desktopIcon; |
| desktopIcon = d; |
| firePropertyChange("desktopIcon", oldIcon, d); |
| } |
| } |
| |
| /** |
| * This method does nothing because this must be the root of a focus |
| * traversal cycle. |
| * |
| * @param focusCycleRoot Not used. |
| */ |
| public final void setFocusCycleRoot(boolean focusCycleRoot) |
| { |
| // Do nothing |
| } |
| |
| /** |
| * This method sets the Icon to be used in two places. The first is icon |
| * that is painted at the top left corner of the JInternalFrame when it is |
| * not iconified (clicking on that icon will activate the TitlePane |
| * JMenuBar). When the JInternalFrame is iconified, it will be the icon |
| * displayed in the JDesktopIcon. If no icon is set, the JInternalFrame |
| * will use a Look and Feel default. |
| * |
| * @param icon The Icon used in the TitlePane JMenuBar and iconified frames. |
| */ |
| public void setFrameIcon(Icon icon) |
| { |
| if (icon != frameIcon) |
| { |
| Icon old = frameIcon; |
| frameIcon = icon; |
| firePropertyChange(FRAME_ICON_PROPERTY, old, frameIcon); |
| } |
| } |
| |
| /** |
| * This method sets the Glass Pane used with this JInternalFrame. |
| * |
| * @param glass The Glass Pane to use with this JInternalFrame. |
| */ |
| public void setGlassPane(Component glass) |
| { |
| if (glass != getGlassPane()) |
| { |
| Component old = getGlassPane(); |
| getRootPane().setGlassPane(glass); |
| firePropertyChange(GLASS_PANE_PROPERTY, old, glass); |
| } |
| } |
| |
| /** |
| * This method iconifies or deiconifies this JInternalFrame given the |
| * boolean argument. If the JInternalFrame becomes iconified, it will fire |
| * an INTERNAL_FRAME_ICONIFIED event. If the JInternalFrame becomes |
| * deiconified, it will fire anINTERNAL_FRAME_DEICONIFIED event. |
| * |
| * @param b Whether this JInternalFrame is to be iconified or deiconified. |
| * |
| * @throws PropertyVetoException DOCUMENT ME! |
| */ |
| public void setIcon(boolean b) throws PropertyVetoException |
| { |
| if (b != isIcon()) |
| { |
| fireVetoableChange(IS_ICON_PROPERTY, b, isIcon); |
| |
| isIcon = b; |
| |
| firePropertyChange(IS_ICON_PROPERTY, ! isIcon, isIcon); |
| if (b) |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ICONIFIED); |
| else |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED); |
| } |
| } |
| |
| /** |
| * This method sets whether the JInternalFrame can be iconified. (This means |
| * that the JInternalFrame can be turned into an icon if minimized). |
| * |
| * @param b Whether the JInternalFrame can be iconified. |
| */ |
| public void setIconifiable(boolean b) |
| { |
| if (iconable != b) |
| { |
| iconable = b; |
| firePropertyChange("iconable", ! iconable, iconable); |
| } |
| } |
| |
| /** |
| * This method sets the JMenuBar to be used with this JInternalFrame. |
| * |
| * @param b The JMenuBar to be used with this JInternalFrame. |
| */ |
| public void setJMenuBar(JMenuBar b) |
| { |
| JMenuBar old = getJMenuBar(); |
| getRootPane().setJMenuBar(b); |
| firePropertyChange(MENU_BAR_PROPERTY, old, b); |
| } |
| |
| /** |
| * A helper method that set the layer that this JInternalFrame resides in. |
| * Using this version of the method means that the user should not set it |
| * to values that are already defined in JLayeredPane. If predefined values |
| * are to be used, the user should use the setLayer(Integer) version. |
| * |
| * @param layer The layer to place this JInternalFrame in. |
| */ |
| public void setLayer(int layer) |
| { |
| setLayer(new Integer(layer)); |
| } |
| |
| /** |
| * A helper method that sets the layer that this JInternalFrame resides in. |
| * Calling this version of the method should use layer values that are |
| * already defined in JLayeredPane. |
| * |
| * @param layer The layer to place this JInternalFrame in. |
| */ |
| public void setLayer(Integer layer) |
| { |
| Container p = getParent(); |
| if (p instanceof JLayeredPane) |
| { |
| JLayeredPane lp = (JLayeredPane) p; |
| lp.setLayer(this, layer.intValue(), lp.getPosition(this)); |
| } |
| else |
| { |
| JLayeredPane.putLayer(this, layer.intValue()); |
| if (p != null) |
| p.repaint(getX(), getY(), getWidth(), getHeight()); |
| } |
| } |
| |
| /** |
| * This method sets the JLayeredPane to use with this JInternalFrame. |
| * |
| * @param layered The JLayeredPane to use as a layeredPane. |
| */ |
| public void setLayeredPane(JLayeredPane layered) |
| { |
| if (layered == null) |
| throw new IllegalComponentStateException("LayeredPane must not be null"); |
| |
| if (layered != getLayeredPane()) |
| { |
| JLayeredPane old = getLayeredPane(); |
| getRootPane().setLayeredPane(layered); |
| firePropertyChange(LAYERED_PANE_PROPERTY, old, layered); |
| } |
| } |
| |
| /** |
| * This method sets whether the JInternalFrame can be maximized. |
| * |
| * @param b Whether this JInternalFrame can be maximized. |
| */ |
| public void setMaximizable(boolean b) |
| { |
| if (maximizable != b) |
| { |
| maximizable = b; |
| firePropertyChange("maximizable", ! maximizable, maximizable); |
| } |
| } |
| |
| /** |
| * This method sets the Layout Manager used in the JInternalFrame. SetLayout |
| * should not be called on the JInternalFrame directly. Instead, it should |
| * be called with JInternalFrame.getContentPane().setLayout. Calls to this |
| * method with root pane checking enabled will cause exceptions to be |
| * thrown. |
| * |
| * @param manager The Layout Manager to be used with the JInternalFrame. |
| * |
| * @throws Error If rootPaneChecking is enabled. |
| */ |
| public void setLayout(LayoutManager manager) |
| { |
| // Check if we're in initialization stage. If so, call super.setLayout |
| // otherwise, valid calls go to the content pane. |
| if (isRootPaneCheckingEnabled()) |
| getContentPane().setLayout(manager); |
| else |
| super.setLayout(manager); |
| } |
| |
| /** |
| * This method sets the JInternalFrame to maximized (if the given argument |
| * is true) or restores the JInternalFrame to its normal bounds otherwise. |
| * |
| * @param b Whether this JInteralFrame will be maximized or restored. |
| * |
| * @throws PropertyVetoException If a VetoableChangeListener vetoes the change. |
| */ |
| public void setMaximum(boolean b) throws PropertyVetoException |
| { |
| if (b != isMaximum) |
| { |
| fireVetoableChange(IS_MAXIMUM_PROPERTY, isMaximum, b); |
| isMaximum = b; |
| firePropertyChange(IS_MAXIMUM_PROPERTY, ! isMaximum, isMaximum); |
| } |
| } |
| |
| /** |
| * This method is deprecated. This method sets the JMenuBar used with this |
| * JInternalFrame. |
| * |
| * @param m The JMenuBar to use with this JInternalFrame. |
| * |
| * @deprecated 1.0.3 |
| */ |
| public void setMenuBar(JMenuBar m) |
| { |
| setJMenuBar(m); |
| } |
| |
| /** |
| * This method sets the bounds that this JInternalFrame will be restored to. |
| * |
| * @param r The bounds that this JInternalFrame will be restored to. |
| */ |
| public void setNormalBounds(Rectangle r) |
| { |
| storedBounds = r; |
| } |
| |
| /** |
| * This method sets whether the JInternalFrame can be resized by a user |
| * action (like dragging at the frame borders). |
| * |
| * @param b Whether this JInternalFramer can be resized. |
| */ |
| public void setResizable(boolean b) |
| { |
| if (b != resizable) |
| { |
| resizable = b; |
| firePropertyChange("resizable", ! resizable, resizable); |
| } |
| } |
| |
| /** |
| * This method sets the Root Pane for this JInternalFrame. |
| * |
| * @param root The Root Pane for this JInternalFrame. |
| */ |
| protected void setRootPane(JRootPane root) |
| { |
| if (rootPane != null) |
| remove(rootPane); |
| |
| JRootPane old = rootPane; |
| rootPane = root; |
| |
| if (rootPane != null) |
| { |
| boolean checkingEnabled = isRootPaneCheckingEnabled(); |
| try |
| { |
| setRootPaneCheckingEnabled(false); |
| add(rootPane, BorderLayout.CENTER); |
| } |
| finally |
| { |
| setRootPaneCheckingEnabled(checkingEnabled); |
| } |
| } |
| firePropertyChange(ROOT_PANE_PROPERTY, old, rootPane); |
| } |
| |
| /** |
| * This method sets whether root pane checking is enabled. If root pane |
| * checking is enabled, then calls to addImpl and setLayout will throw |
| * exceptions. |
| * |
| * @param enabled Whether root pane checking is enabled. |
| */ |
| protected void setRootPaneCheckingEnabled(boolean enabled) |
| { |
| rootPaneCheckingEnabled = enabled; |
| } |
| |
| /** |
| * This method sets whether this JInternalFrame is the selected frame in the |
| * JDesktopPane (or other container). When selected, a JInternalFrame will |
| * have focus and paint its TitlePane differently (usually a different |
| * colour). If this method selects the frame, this JInternalFrame will fire |
| * an INTERNAL_FRAME_ACTIVATED event. If it deselects this frame, it will |
| * fire an INTERNAL_FRAME_DEACTIVATED event. |
| * |
| * @param selected Whether this JInternalFrame will become selected or |
| * deselected. |
| * |
| * @throws PropertyVetoException If a VetoableChangeListener vetoes the change. |
| */ |
| public void setSelected(boolean selected) throws PropertyVetoException |
| { |
| if (selected != isSelected |
| && (! selected || (isIcon ? desktopIcon.isShowing() : isShowing()))) |
| { |
| fireVetoableChange(IS_SELECTED_PROPERTY, isSelected, selected); |
| |
| if (! selected) |
| defaultFocus = getMostRecentFocusOwner(); |
| |
| isSelected = selected; |
| firePropertyChange(IS_SELECTED_PROPERTY, ! isSelected, isSelected); |
| |
| if (isSelected) |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_ACTIVATED); |
| else |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED); |
| |
| if (selected) |
| restoreSubcomponentFocus(); |
| |
| repaint(); |
| } |
| } |
| |
| /** |
| * Sets the title for the <code>JInternalFrame</code> and sends a |
| * {@link PropertyChangeEvent} (with the property name |
| * {@link #TITLE_PROPERTY}) to all registered listeners. |
| * |
| * @param title the new title (<code>null</code> permitted). |
| * |
| * @see #getTitle() |
| */ |
| public void setTitle(String title) |
| { |
| String old = this.title; |
| this.title = title; |
| firePropertyChange(TITLE_PROPERTY, old, this.title); |
| } |
| |
| /** |
| * This method displays the JInternalFrame. If it is not visible, this |
| * method will bring this JInternalFrame to the front, make it visible and |
| * select it. If this is the first time this JInternalFrame is made |
| * visible, an INTERNAL_FRAME_OPENED event will be fired. |
| */ |
| public void show() |
| { |
| if (! isVisible()) |
| { |
| if (isFirstTimeVisible) |
| { |
| isFirstTimeVisible = false; |
| fireInternalFrameEvent(InternalFrameEvent.INTERNAL_FRAME_OPENED); |
| } |
| |
| getDesktopIcon().setVisible(true); |
| |
| toFront(); |
| super.show(); |
| |
| if (isIcon()) |
| return; |
| |
| if (! isSelected()) |
| { |
| try |
| { |
| setSelected(true); |
| } |
| catch (PropertyVetoException e) |
| { |
| // Do nothing. if they don't want to be selected. |
| } |
| } |
| } |
| } |
| |
| /** |
| * This method is used to set the UI responsible for the JInternalFrame. |
| * |
| * @param ui The UI responsible for the JInternalFrame. |
| */ |
| public void setUI(InternalFrameUI ui) |
| { |
| // We must temporarily go into init mode so that the UI can directly |
| // manipulate the JInternalFrame. |
| boolean old = isRootPaneCheckingEnabled(); |
| setRootPaneCheckingEnabled(false); |
| super.setUI(ui); |
| setRootPaneCheckingEnabled(old); |
| } |
| |
| /** |
| * This method causes the JInternalFrame to be brough to back in the |
| * z-order. |
| */ |
| public void toBack() |
| { |
| moveToBack(); |
| } |
| |
| /** |
| * This method causes the JInternalFrame to be brought to front in the |
| * z-order. |
| */ |
| public void toFront() |
| { |
| moveToFront(); |
| } |
| |
| /** |
| * This method resets the UI to the Look and Feel defaults. |
| */ |
| public void updateUI() |
| { |
| // We must go into the init stage when updating the UI, so the UI can |
| // set layout and components directly on the internal frame, not its |
| // content pane. |
| boolean old = isRootPaneCheckingEnabled(); |
| setRootPaneCheckingEnabled(false); |
| setUI((InternalFrameUI) UIManager.getUI(this)); |
| setRootPaneCheckingEnabled(old); |
| } |
| |
| /** |
| * This helper method allows JInternalFrames to signal that they were |
| * iconned for the first time. |
| * |
| * @param b Whether the JInternalFrame was iconned. |
| * @param ID The identifier of the property change event to fire if the |
| * JInternalFrame is iconned for the first time. |
| */ |
| void setWasIcon(boolean b, String ID) |
| { |
| if (b && ! wasIcon) |
| { |
| wasIcon = b; |
| firePropertyChange(ID, ! b, b); |
| } |
| } |
| |
| /** |
| * This helper method returns whether the JInternalFrame has been iconned |
| * once already. |
| * |
| * @return Whether the JInternalFrame has been iconned once already. |
| */ |
| boolean getWasIcon() |
| { |
| return wasIcon; |
| } |
| |
| /** |
| * This method is a convenience method to fire vetoable property changes. |
| * |
| * @param name The identifier of the property change. |
| * @param oldValue The old value. |
| * @param newValue The new value. |
| * |
| * @throws PropertyVetoException Fired if a vetoable change listener vetoes |
| * the change. |
| */ |
| private void fireVetoableChange(String name, boolean oldValue, |
| boolean newValue) |
| throws PropertyVetoException |
| { |
| super.fireVetoableChange(name, Boolean.valueOf(oldValue), Boolean.valueOf(newValue)); |
| } |
| } |