--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/javax/swing/plaf/basic/BasicInternalFrameUI.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,1473 @@
+/*
+ * Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package javax.swing.plaf.basic;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.peer.LightweightPeer;
+
+import javax.swing.*;
+import javax.swing.border.*;
+import javax.swing.plaf.*;
+import javax.swing.event.*;
+
+import java.beans.*;
+import java.io.Serializable;
+
+import sun.swing.DefaultLookup;
+import sun.swing.UIAction;
+
+/**
+ * A basic L&F implementation of JInternalFrame.
+ *
+ * @author David Kloba
+ * @author Rich Schiavi
+ */
+public class BasicInternalFrameUI extends InternalFrameUI
+{
+
+ protected JInternalFrame frame;
+
+ private Handler handler;
+ protected MouseInputAdapter borderListener;
+ protected PropertyChangeListener propertyChangeListener;
+ protected LayoutManager internalFrameLayout;
+ protected ComponentListener componentListener;
+ protected MouseInputListener glassPaneDispatcher;
+ private InternalFrameListener internalFrameListener;
+
+ protected JComponent northPane;
+ protected JComponent southPane;
+ protected JComponent westPane;
+ protected JComponent eastPane;
+
+ protected BasicInternalFrameTitlePane titlePane; // access needs this
+
+ private static DesktopManager sharedDesktopManager;
+ private boolean componentListenerAdded = false;
+
+ private Rectangle parentBounds;
+
+ private boolean dragging = false;
+ private boolean resizing = false;
+
+ /**
+ * As of Java 2 platform v1.3 this previously undocumented field is no
+ * longer used.
+ * Key bindings are now defined by the LookAndFeel, please refer to
+ * the key bindings specification for further details.
+ *
+ * @deprecated As of Java 2 platform v1.3.
+ */
+ @Deprecated
+ protected KeyStroke openMenuKey;
+
+ private boolean keyBindingRegistered = false;
+ private boolean keyBindingActive = false;
+
+/////////////////////////////////////////////////////////////////////////////
+// ComponentUI Interface Implementation methods
+/////////////////////////////////////////////////////////////////////////////
+ public static ComponentUI createUI(JComponent b) {
+ return new BasicInternalFrameUI((JInternalFrame)b);
+ }
+
+ public BasicInternalFrameUI(JInternalFrame b) {
+ LookAndFeel laf = UIManager.getLookAndFeel();
+ if (laf instanceof BasicLookAndFeel) {
+ ((BasicLookAndFeel)laf).installAWTEventListener();
+ }
+ }
+
+ public void installUI(JComponent c) {
+
+ frame = (JInternalFrame)c;
+
+ installDefaults();
+ installListeners();
+ installComponents();
+ installKeyboardActions();
+
+ LookAndFeel.installProperty(frame, "opaque", Boolean.TRUE);
+ }
+
+ public void uninstallUI(JComponent c) {
+ if(c != frame)
+ throw new IllegalComponentStateException(
+ this + " was asked to deinstall() "
+ + c + " when it only knows about "
+ + frame + ".");
+
+ uninstallKeyboardActions();
+ uninstallComponents();
+ uninstallListeners();
+ uninstallDefaults();
+ updateFrameCursor();
+ handler = null;
+ frame = null;
+ }
+
+ protected void installDefaults(){
+ Icon frameIcon = frame.getFrameIcon();
+ if (frameIcon == null || frameIcon instanceof UIResource) {
+ frame.setFrameIcon(UIManager.getIcon("InternalFrame.icon"));
+ }
+
+ // Enable the content pane to inherit background color from its
+ // parent by setting its background color to null.
+ Container contentPane = frame.getContentPane();
+ if (contentPane != null) {
+ Color bg = contentPane.getBackground();
+ if (bg instanceof UIResource)
+ contentPane.setBackground(null);
+ }
+ frame.setLayout(internalFrameLayout = createLayoutManager());
+ frame.setBackground(UIManager.getLookAndFeelDefaults().getColor("control"));
+
+ LookAndFeel.installBorder(frame, "InternalFrame.border");
+
+ }
+ protected void installKeyboardActions(){
+ createInternalFrameListener();
+ if (internalFrameListener != null) {
+ frame.addInternalFrameListener(internalFrameListener);
+ }
+
+ LazyActionMap.installLazyActionMap(frame, BasicInternalFrameUI.class,
+ "InternalFrame.actionMap");
+ }
+
+ static void loadActionMap(LazyActionMap map) {
+ map.put(new UIAction("showSystemMenu") {
+ public void actionPerformed(ActionEvent evt) {
+ JInternalFrame iFrame = (JInternalFrame)evt.getSource();
+ if (iFrame.getUI() instanceof BasicInternalFrameUI) {
+ JComponent comp = ((BasicInternalFrameUI)
+ iFrame.getUI()).getNorthPane();
+ if (comp instanceof BasicInternalFrameTitlePane) {
+ ((BasicInternalFrameTitlePane)comp).
+ showSystemMenu();
+ }
+ }
+ }
+
+ public boolean isEnabled(Object sender){
+ if (sender instanceof JInternalFrame) {
+ JInternalFrame iFrame = (JInternalFrame)sender;
+ if (iFrame.getUI() instanceof BasicInternalFrameUI) {
+ return ((BasicInternalFrameUI)iFrame.getUI()).
+ isKeyBindingActive();
+ }
+ }
+ return false;
+ }
+ });
+
+ // Set the ActionMap's parent to the Auditory Feedback Action Map
+ BasicLookAndFeel.installAudioActionMap(map);
+ }
+
+ protected void installComponents(){
+ setNorthPane(createNorthPane(frame));
+ setSouthPane(createSouthPane(frame));
+ setEastPane(createEastPane(frame));
+ setWestPane(createWestPane(frame));
+ }
+
+ /**
+ * @since 1.3
+ */
+ protected void installListeners() {
+ borderListener = createBorderListener(frame);
+ propertyChangeListener = createPropertyChangeListener();
+ frame.addPropertyChangeListener(propertyChangeListener);
+ installMouseHandlers(frame);
+ glassPaneDispatcher = createGlassPaneDispatcher();
+ if (glassPaneDispatcher != null) {
+ frame.getGlassPane().addMouseListener(glassPaneDispatcher);
+ frame.getGlassPane().addMouseMotionListener(glassPaneDispatcher);
+ }
+ componentListener = createComponentListener();
+ if (frame.getParent() != null) {
+ parentBounds = frame.getParent().getBounds();
+ }
+ if ((frame.getParent() != null) && !componentListenerAdded) {
+ frame.getParent().addComponentListener(componentListener);
+ componentListenerAdded = true;
+ }
+ }
+
+ // Provide a FocusListener to listen for a WINDOW_LOST_FOCUS event,
+ // so that a resize can be cancelled if the focus is lost while resizing
+ // when an Alt-Tab, modal dialog popup, iconify, dispose, or remove
+ // of the internal frame occurs.
+ private WindowFocusListener getWindowFocusListener(){
+ return getHandler();
+ }
+
+ // Cancel a resize in progress by calling finishMouseReleased().
+ private void cancelResize() {
+ if (resizing) {
+ if (borderListener instanceof BorderListener) {
+ ((BorderListener)borderListener).finishMouseReleased();
+ }
+ }
+ }
+
+ private Handler getHandler() {
+ if (handler == null) {
+ handler = new Handler();
+ }
+ return handler;
+ }
+
+ InputMap getInputMap(int condition) {
+ if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {
+ return createInputMap(condition);
+ }
+ return null;
+ }
+
+ InputMap createInputMap(int condition) {
+ if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {
+ Object[] bindings = (Object[])DefaultLookup.get(
+ frame, this, "InternalFrame.windowBindings");
+
+ if (bindings != null) {
+ return LookAndFeel.makeComponentInputMap(frame, bindings);
+ }
+ }
+ return null;
+ }
+
+ protected void uninstallDefaults() {
+ Icon frameIcon = frame.getFrameIcon();
+ if (frameIcon instanceof UIResource) {
+ frame.setFrameIcon(null);
+ }
+ internalFrameLayout = null;
+ frame.setLayout(null);
+ LookAndFeel.uninstallBorder(frame);
+ }
+
+ protected void uninstallComponents(){
+ setNorthPane(null);
+ setSouthPane(null);
+ setEastPane(null);
+ setWestPane(null);
+ if(titlePane != null) {
+ titlePane.uninstallDefaults();
+ }
+ titlePane = null;
+ }
+
+ /**
+ * @since 1.3
+ */
+ protected void uninstallListeners() {
+ if ((frame.getParent() != null) && componentListenerAdded) {
+ frame.getParent().removeComponentListener(componentListener);
+ componentListenerAdded = false;
+ }
+ componentListener = null;
+ if (glassPaneDispatcher != null) {
+ frame.getGlassPane().removeMouseListener(glassPaneDispatcher);
+ frame.getGlassPane().removeMouseMotionListener(glassPaneDispatcher);
+ glassPaneDispatcher = null;
+ }
+ deinstallMouseHandlers(frame);
+ frame.removePropertyChangeListener(propertyChangeListener);
+ propertyChangeListener = null;
+ borderListener = null;
+ }
+
+ protected void uninstallKeyboardActions(){
+ if (internalFrameListener != null) {
+ frame.removeInternalFrameListener(internalFrameListener);
+ }
+ internalFrameListener = null;
+
+ SwingUtilities.replaceUIInputMap(frame, JComponent.
+ WHEN_IN_FOCUSED_WINDOW, null);
+ SwingUtilities.replaceUIActionMap(frame, null);
+
+ }
+
+ void updateFrameCursor() {
+ if (resizing) {
+ return;
+ }
+ Cursor s = (Cursor)frame.getLastCursor();
+ if (s == null) {
+ s = Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
+ }
+ frame.setCursor(s);
+ }
+
+ protected LayoutManager createLayoutManager(){
+ return getHandler();
+ }
+
+ protected PropertyChangeListener createPropertyChangeListener(){
+ return getHandler();
+ }
+
+
+
+ public Dimension getPreferredSize(JComponent x) {
+ if((JComponent)frame == x)
+ return frame.getLayout().preferredLayoutSize(x);
+ return new Dimension(100, 100);
+ }
+
+ public Dimension getMinimumSize(JComponent x) {
+ if((JComponent)frame == x) {
+ return frame.getLayout().minimumLayoutSize(x);
+ }
+ return new Dimension(0, 0);
+ }
+
+ public Dimension getMaximumSize(JComponent x) {
+ return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
+ }
+
+
+
+ /**
+ * Installs necessary mouse handlers on <code>newPane</code>
+ * and adds it to the frame.
+ * Reverse process for the <code>currentPane</code>.
+ */
+ protected void replacePane(JComponent currentPane, JComponent newPane) {
+ if(currentPane != null) {
+ deinstallMouseHandlers(currentPane);
+ frame.remove(currentPane);
+ }
+ if(newPane != null) {
+ frame.add(newPane);
+ installMouseHandlers(newPane);
+ }
+ }
+
+ protected void deinstallMouseHandlers(JComponent c) {
+ c.removeMouseListener(borderListener);
+ c.removeMouseMotionListener(borderListener);
+ }
+
+ protected void installMouseHandlers(JComponent c) {
+ c.addMouseListener(borderListener);
+ c.addMouseMotionListener(borderListener);
+ }
+
+ protected JComponent createNorthPane(JInternalFrame w) {
+ titlePane = new BasicInternalFrameTitlePane(w);
+ return titlePane;
+ }
+
+
+ protected JComponent createSouthPane(JInternalFrame w) {
+ return null;
+ }
+
+ protected JComponent createWestPane(JInternalFrame w) {
+ return null;
+ }
+
+ protected JComponent createEastPane(JInternalFrame w) {
+ return null;
+ }
+
+
+ protected MouseInputAdapter createBorderListener(JInternalFrame w) {
+ return new BorderListener();
+ }
+
+ protected void createInternalFrameListener(){
+ internalFrameListener = getHandler();
+ }
+
+ protected final boolean isKeyBindingRegistered(){
+ return keyBindingRegistered;
+ }
+
+ protected final void setKeyBindingRegistered(boolean b){
+ keyBindingRegistered = b;
+ }
+
+ public final boolean isKeyBindingActive(){
+ return keyBindingActive;
+ }
+
+ protected final void setKeyBindingActive(boolean b){
+ keyBindingActive = b;
+ }
+
+
+ protected void setupMenuOpenKey(){
+ // PENDING(hania): Why are these WHEN_IN_FOCUSED_WINDOWs? Shouldn't
+ // they be WHEN_ANCESTOR_OF_FOCUSED_COMPONENT?
+ // Also, no longer registering on the desktopicon, the previous
+ // action did nothing.
+ InputMap map = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
+ SwingUtilities.replaceUIInputMap(frame,
+ JComponent.WHEN_IN_FOCUSED_WINDOW, map);
+ //ActionMap actionMap = getActionMap();
+ //SwingUtilities.replaceUIActionMap(frame, actionMap);
+ }
+
+ protected void setupMenuCloseKey(){
+ }
+
+ public JComponent getNorthPane() {
+ return northPane;
+ }
+
+ public void setNorthPane(JComponent c) {
+ if (northPane != null &&
+ northPane instanceof BasicInternalFrameTitlePane) {
+ ((BasicInternalFrameTitlePane)northPane).uninstallListeners();
+ }
+ replacePane(northPane, c);
+ northPane = c;
+ if (c instanceof BasicInternalFrameTitlePane) {
+ titlePane = (BasicInternalFrameTitlePane)c;
+ }
+ }
+
+ public JComponent getSouthPane() {
+ return southPane;
+ }
+
+ public void setSouthPane(JComponent c) {
+ southPane = c;
+ }
+
+ public JComponent getWestPane() {
+ return westPane;
+ }
+
+ public void setWestPane(JComponent c) {
+ westPane = c;
+ }
+
+ public JComponent getEastPane() {
+ return eastPane;
+ }
+
+ public void setEastPane(JComponent c) {
+ eastPane = c;
+ }
+
+ public class InternalFramePropertyChangeListener implements
+ PropertyChangeListener {
+ // NOTE: This class exists only for backward compatability. All
+ // its functionality has been moved into Handler. If you need to add
+ // new functionality add it to the Handler, but make sure this
+ // class calls into the Handler.
+ /**
+ * Detects changes in state from the JInternalFrame and handles
+ * actions.
+ */
+ public void propertyChange(PropertyChangeEvent evt) {
+ getHandler().propertyChange(evt);
+ }
+ }
+
+ public class InternalFrameLayout implements LayoutManager {
+ // NOTE: This class exists only for backward compatability. All
+ // its functionality has been moved into Handler. If you need to add
+ // new functionality add it to the Handler, but make sure this
+ // class calls into the Handler.
+ public void addLayoutComponent(String name, Component c) {
+ getHandler().addLayoutComponent(name, c);
+ }
+
+ public void removeLayoutComponent(Component c) {
+ getHandler().removeLayoutComponent(c);
+ }
+
+ public Dimension preferredLayoutSize(Container c) {
+ return getHandler().preferredLayoutSize(c);
+ }
+
+ public Dimension minimumLayoutSize(Container c) {
+ return getHandler().minimumLayoutSize(c);
+ }
+
+ public void layoutContainer(Container c) {
+ getHandler().layoutContainer(c);
+ }
+ }
+
+/// DesktopManager methods
+ /** Returns the proper DesktopManager. Calls getDesktopPane() to
+ * find the JDesktop component and returns the desktopManager from
+ * it. If this fails, it will return a default DesktopManager that
+ * should work in arbitrary parents.
+ */
+ protected DesktopManager getDesktopManager() {
+ if(frame.getDesktopPane() != null
+ && frame.getDesktopPane().getDesktopManager() != null)
+ return frame.getDesktopPane().getDesktopManager();
+ if(sharedDesktopManager == null)
+ sharedDesktopManager = createDesktopManager();
+ return sharedDesktopManager;
+ }
+
+ protected DesktopManager createDesktopManager(){
+ return new DefaultDesktopManager();
+ }
+
+ /**
+ * This method is called when the user wants to close the frame.
+ * The <code>playCloseSound</code> Action is fired.
+ * This action is delegated to the desktopManager.
+ */
+ protected void closeFrame(JInternalFrame f) {
+ // Internal Frame Auditory Cue Activation
+ BasicLookAndFeel.playSound(frame,"InternalFrame.closeSound");
+ // delegate to desktop manager
+ getDesktopManager().closeFrame(f);
+ }
+
+ /**
+ * This method is called when the user wants to maximize the frame.
+ * The <code>playMaximizeSound</code> Action is fired.
+ * This action is delegated to the desktopManager.
+ */
+ protected void maximizeFrame(JInternalFrame f) {
+ // Internal Frame Auditory Cue Activation
+ BasicLookAndFeel.playSound(frame,"InternalFrame.maximizeSound");
+ // delegate to desktop manager
+ getDesktopManager().maximizeFrame(f);
+ }
+
+ /**
+ * This method is called when the user wants to minimize the frame.
+ * The <code>playRestoreDownSound</code> Action is fired.
+ * This action is delegated to the desktopManager.
+ */
+ protected void minimizeFrame(JInternalFrame f) {
+ // Internal Frame Auditory Cue Activation
+ if ( ! f.isIcon() ) {
+ // This method seems to regularly get called after an
+ // internal frame is iconified. Don't play this sound then.
+ BasicLookAndFeel.playSound(frame,"InternalFrame.restoreDownSound");
+ }
+ // delegate to desktop manager
+ getDesktopManager().minimizeFrame(f);
+ }
+
+ /**
+ * This method is called when the user wants to iconify the frame.
+ * The <code>playMinimizeSound</code> Action is fired.
+ * This action is delegated to the desktopManager.
+ */
+ protected void iconifyFrame(JInternalFrame f) {
+ // Internal Frame Auditory Cue Activation
+ BasicLookAndFeel.playSound(frame, "InternalFrame.minimizeSound");
+ // delegate to desktop manager
+ getDesktopManager().iconifyFrame(f);
+ }
+
+ /**
+ * This method is called when the user wants to deiconify the frame.
+ * The <code>playRestoreUpSound</code> Action is fired.
+ * This action is delegated to the desktopManager.
+ */
+ protected void deiconifyFrame(JInternalFrame f) {
+ // Internal Frame Auditory Cue Activation
+ if ( ! f.isMaximum() ) {
+ // This method seems to regularly get called after an
+ // internal frame is maximized. Don't play this sound then.
+ BasicLookAndFeel.playSound(frame, "InternalFrame.restoreUpSound");
+ }
+ // delegate to desktop manager
+ getDesktopManager().deiconifyFrame(f);
+ }
+
+ /** This method is called when the frame becomes selected.
+ * This action is delegated to the desktopManager.
+ */
+ protected void activateFrame(JInternalFrame f) {
+ getDesktopManager().activateFrame(f);
+ }
+ /** This method is called when the frame is no longer selected.
+ * This action is delegated to the desktopManager.
+ */
+ protected void deactivateFrame(JInternalFrame f) {
+ getDesktopManager().deactivateFrame(f);
+ }
+
+ /////////////////////////////////////////////////////////////////////////
+ /// Border Listener Class
+ /////////////////////////////////////////////////////////////////////////
+ /**
+ * Listens for border adjustments.
+ */
+ protected class BorderListener extends MouseInputAdapter implements SwingConstants
+ {
+ // _x & _y are the mousePressed location in absolute coordinate system
+ int _x, _y;
+ // __x & __y are the mousePressed location in source view's coordinate system
+ int __x, __y;
+ Rectangle startingBounds;
+ int resizeDir;
+
+
+ protected final int RESIZE_NONE = 0;
+ private boolean discardRelease = false;
+
+ int resizeCornerSize = 16;
+
+ public void mouseClicked(MouseEvent e) {
+ if(e.getClickCount() > 1 && e.getSource() == getNorthPane()) {
+ if(frame.isIconifiable() && frame.isIcon()) {
+ try { frame.setIcon(false); } catch (PropertyVetoException e2) { }
+ } else if(frame.isMaximizable()) {
+ if(!frame.isMaximum())
+ try { frame.setMaximum(true); } catch (PropertyVetoException e2) { }
+ else
+ try { frame.setMaximum(false); } catch (PropertyVetoException e3) { }
+ }
+ }
+ }
+
+ // Factor out finishMouseReleased() from mouseReleased(), so that
+ // it can be called by cancelResize() without passing it a null
+ // MouseEvent.
+ void finishMouseReleased() {
+ if (discardRelease) {
+ discardRelease = false;
+ return;
+ }
+ if (resizeDir == RESIZE_NONE) {
+ getDesktopManager().endDraggingFrame(frame);
+ dragging = false;
+ } else {
+ // Remove the WindowFocusListener for handling a
+ // WINDOW_LOST_FOCUS event with a cancelResize().
+ Window windowAncestor =
+ SwingUtilities.getWindowAncestor(frame);
+ if (windowAncestor != null) {
+ windowAncestor.removeWindowFocusListener(
+ getWindowFocusListener());
+ }
+ Container c = frame.getTopLevelAncestor();
+ if (c instanceof RootPaneContainer) {
+ Component glassPane = ((RootPaneContainer)c).getGlassPane();
+ glassPane.setCursor(Cursor.getPredefinedCursor(
+ Cursor.DEFAULT_CURSOR));
+ glassPane.setVisible(false);
+ }
+ getDesktopManager().endResizingFrame(frame);
+ resizing = false;
+ }
+ _x = 0;
+ _y = 0;
+ __x = 0;
+ __y = 0;
+ startingBounds = null;
+ resizeDir = RESIZE_NONE;
+ // Set discardRelease to true, so that only a mousePressed()
+ // which sets it to false, will allow entry to the above code
+ // for finishing a resize.
+ discardRelease = true;
+ }
+
+ public void mouseReleased(MouseEvent e) {
+ finishMouseReleased();
+ }
+
+ public void mousePressed(MouseEvent e) {
+ Point p = SwingUtilities.convertPoint((Component)e.getSource(),
+ e.getX(), e.getY(), null);
+ __x = e.getX();
+ __y = e.getY();
+ _x = p.x;
+ _y = p.y;
+ startingBounds = frame.getBounds();
+ resizeDir = RESIZE_NONE;
+ discardRelease = false;
+
+ try { frame.setSelected(true); }
+ catch (PropertyVetoException e1) { }
+
+ Insets i = frame.getInsets();
+
+ Point ep = new Point(__x, __y);
+ if (e.getSource() == getNorthPane()) {
+ Point np = getNorthPane().getLocation();
+ ep.x += np.x;
+ ep.y += np.y;
+ }
+
+ if (e.getSource() == getNorthPane()) {
+ if (ep.x > i.left && ep.y > i.top && ep.x < frame.getWidth() - i.right) {
+ getDesktopManager().beginDraggingFrame(frame);
+ dragging = true;
+ return;
+ }
+ }
+ if (!frame.isResizable()) {
+ return;
+ }
+
+ if (e.getSource() == frame || e.getSource() == getNorthPane()) {
+ if (ep.x <= i.left) {
+ if (ep.y < resizeCornerSize + i.top) {
+ resizeDir = NORTH_WEST;
+ } else if (ep.y > frame.getHeight()
+ - resizeCornerSize - i.bottom) {
+ resizeDir = SOUTH_WEST;
+ } else {
+ resizeDir = WEST;
+}
+ } else if (ep.x >= frame.getWidth() - i.right) {
+ if (ep.y < resizeCornerSize + i.top) {
+ resizeDir = NORTH_EAST;
+ } else if (ep.y > frame.getHeight()
+ - resizeCornerSize - i.bottom) {
+ resizeDir = SOUTH_EAST;
+ } else {
+ resizeDir = EAST;
+ }
+ } else if (ep.y <= i.top) {
+ if (ep.x < resizeCornerSize + i.left) {
+ resizeDir = NORTH_WEST;
+ } else if (ep.x > frame.getWidth()
+ - resizeCornerSize - i.right) {
+ resizeDir = NORTH_EAST;
+ } else {
+ resizeDir = NORTH;
+ }
+ } else if (ep.y >= frame.getHeight() - i.bottom) {
+ if (ep.x < resizeCornerSize + i.left) {
+ resizeDir = SOUTH_WEST;
+ } else if (ep.x > frame.getWidth()
+ - resizeCornerSize - i.right) {
+ resizeDir = SOUTH_EAST;
+ } else {
+ resizeDir = SOUTH;
+ }
+ } else {
+ /* the mouse press happened inside the frame, not in the
+ border */
+ discardRelease = true;
+ return;
+ }
+ Cursor s = Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
+ switch (resizeDir) {
+ case SOUTH:
+ s = Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR);
+ break;
+ case NORTH:
+ s = Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR);
+ break;
+ case WEST:
+ s = Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR);
+ break;
+ case EAST:
+ s = Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
+ break;
+ case SOUTH_EAST:
+ s = Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR);
+ break;
+ case SOUTH_WEST:
+ s = Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR);
+ break;
+ case NORTH_WEST:
+ s = Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR);
+ break;
+ case NORTH_EAST:
+ s = Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR);
+ break;
+ }
+ Container c = frame.getTopLevelAncestor();
+ if (c instanceof RootPaneContainer) {
+ Component glassPane = ((RootPaneContainer)c).getGlassPane();
+ glassPane.setVisible(true);
+ glassPane.setCursor(s);
+ }
+ getDesktopManager().beginResizingFrame(frame, resizeDir);
+ resizing = true;
+ // Add the WindowFocusListener for handling a
+ // WINDOW_LOST_FOCUS event with a cancelResize().
+ Window windowAncestor = SwingUtilities.getWindowAncestor(frame);
+ if (windowAncestor != null) {
+ windowAncestor.addWindowFocusListener(
+ getWindowFocusListener());
+ }
+ return;
+ }
+ }
+
+ public void mouseDragged(MouseEvent e) {
+
+ if ( startingBounds == null ) {
+ // (STEVE) Yucky work around for bug ID 4106552
+ return;
+ }
+
+ Point p = SwingUtilities.convertPoint((Component)e.getSource(),
+ e.getX(), e.getY(), null);
+ int deltaX = _x - p.x;
+ int deltaY = _y - p.y;
+ Dimension min = frame.getMinimumSize();
+ Dimension max = frame.getMaximumSize();
+ int newX, newY, newW, newH;
+ Insets i = frame.getInsets();
+
+ // Handle a MOVE
+ if (dragging) {
+ if (frame.isMaximum() || ((e.getModifiers() &
+ InputEvent.BUTTON1_MASK) !=
+ InputEvent.BUTTON1_MASK)) {
+ // don't allow moving of frames if maximixed or left mouse
+ // button was not used.
+ return;
+ }
+ int pWidth, pHeight;
+ Dimension s = frame.getParent().getSize();
+ pWidth = s.width;
+ pHeight = s.height;
+
+
+ newX = startingBounds.x - deltaX;
+ newY = startingBounds.y - deltaY;
+
+ // Make sure we stay in-bounds
+ if(newX + i.left <= -__x)
+ newX = -__x - i.left + 1;
+ if(newY + i.top <= -__y)
+ newY = -__y - i.top + 1;
+ if(newX + __x + i.right >= pWidth)
+ newX = pWidth - __x - i.right - 1;
+ if(newY + __y + i.bottom >= pHeight)
+ newY = pHeight - __y - i.bottom - 1;
+
+ getDesktopManager().dragFrame(frame, newX, newY);
+ return;
+ }
+
+ if(!frame.isResizable()) {
+ return;
+ }
+
+ newX = frame.getX();
+ newY = frame.getY();
+ newW = frame.getWidth();
+ newH = frame.getHeight();
+
+ parentBounds = frame.getParent().getBounds();
+
+ switch(resizeDir) {
+ case RESIZE_NONE:
+ return;
+ case NORTH:
+ if(startingBounds.height + deltaY < min.height)
+ deltaY = -(startingBounds.height - min.height);
+ else if(startingBounds.height + deltaY > max.height)
+ deltaY = max.height - startingBounds.height;
+ if (startingBounds.y - deltaY < 0) {deltaY = startingBounds.y;}
+
+ newX = startingBounds.x;
+ newY = startingBounds.y - deltaY;
+ newW = startingBounds.width;
+ newH = startingBounds.height + deltaY;
+ break;
+ case NORTH_EAST:
+ if(startingBounds.height + deltaY < min.height)
+ deltaY = -(startingBounds.height - min.height);
+ else if(startingBounds.height + deltaY > max.height)
+ deltaY = max.height - startingBounds.height;
+ if (startingBounds.y - deltaY < 0) {deltaY = startingBounds.y;}
+
+ if(startingBounds.width - deltaX < min.width)
+ deltaX = startingBounds.width - min.width;
+ else if(startingBounds.width - deltaX > max.width)
+ deltaX = -(max.width - startingBounds.width);
+ if (startingBounds.x + startingBounds.width - deltaX >
+ parentBounds.width) {
+ deltaX = startingBounds.x + startingBounds.width -
+ parentBounds.width;
+ }
+
+ newX = startingBounds.x;
+ newY = startingBounds.y - deltaY;
+ newW = startingBounds.width - deltaX;
+ newH = startingBounds.height + deltaY;
+ break;
+ case EAST:
+ if(startingBounds.width - deltaX < min.width)
+ deltaX = startingBounds.width - min.width;
+ else if(startingBounds.width - deltaX > max.width)
+ deltaX = -(max.width - startingBounds.width);
+ if (startingBounds.x + startingBounds.width - deltaX >
+ parentBounds.width) {
+ deltaX = startingBounds.x + startingBounds.width -
+ parentBounds.width;
+ }
+
+ newW = startingBounds.width - deltaX;
+ newH = startingBounds.height;
+ break;
+ case SOUTH_EAST:
+ if(startingBounds.width - deltaX < min.width)
+ deltaX = startingBounds.width - min.width;
+ else if(startingBounds.width - deltaX > max.width)
+ deltaX = -(max.width - startingBounds.width);
+ if (startingBounds.x + startingBounds.width - deltaX >
+ parentBounds.width) {
+ deltaX = startingBounds.x + startingBounds.width -
+ parentBounds.width;
+ }
+
+ if(startingBounds.height - deltaY < min.height)
+ deltaY = startingBounds.height - min.height;
+ else if(startingBounds.height - deltaY > max.height)
+ deltaY = -(max.height - startingBounds.height);
+ if (startingBounds.y + startingBounds.height - deltaY >
+ parentBounds.height) {
+ deltaY = startingBounds.y + startingBounds.height -
+ parentBounds.height ;
+ }
+
+ newW = startingBounds.width - deltaX;
+ newH = startingBounds.height - deltaY;
+ break;
+ case SOUTH:
+ if(startingBounds.height - deltaY < min.height)
+ deltaY = startingBounds.height - min.height;
+ else if(startingBounds.height - deltaY > max.height)
+ deltaY = -(max.height - startingBounds.height);
+ if (startingBounds.y + startingBounds.height - deltaY >
+ parentBounds.height) {
+ deltaY = startingBounds.y + startingBounds.height -
+ parentBounds.height ;
+ }
+
+ newW = startingBounds.width;
+ newH = startingBounds.height - deltaY;
+ break;
+ case SOUTH_WEST:
+ if(startingBounds.height - deltaY < min.height)
+ deltaY = startingBounds.height - min.height;
+ else if(startingBounds.height - deltaY > max.height)
+ deltaY = -(max.height - startingBounds.height);
+ if (startingBounds.y + startingBounds.height - deltaY >
+ parentBounds.height) {
+ deltaY = startingBounds.y + startingBounds.height -
+ parentBounds.height ;
+ }
+
+ if(startingBounds.width + deltaX < min.width)
+ deltaX = -(startingBounds.width - min.width);
+ else if(startingBounds.width + deltaX > max.width)
+ deltaX = max.width - startingBounds.width;
+ if (startingBounds.x - deltaX < 0) {
+ deltaX = startingBounds.x;
+ }
+
+ newX = startingBounds.x - deltaX;
+ newY = startingBounds.y;
+ newW = startingBounds.width + deltaX;
+ newH = startingBounds.height - deltaY;
+ break;
+ case WEST:
+ if(startingBounds.width + deltaX < min.width)
+ deltaX = -(startingBounds.width - min.width);
+ else if(startingBounds.width + deltaX > max.width)
+ deltaX = max.width - startingBounds.width;
+ if (startingBounds.x - deltaX < 0) {
+ deltaX = startingBounds.x;
+ }
+
+ newX = startingBounds.x - deltaX;
+ newY = startingBounds.y;
+ newW = startingBounds.width + deltaX;
+ newH = startingBounds.height;
+ break;
+ case NORTH_WEST:
+ if(startingBounds.width + deltaX < min.width)
+ deltaX = -(startingBounds.width - min.width);
+ else if(startingBounds.width + deltaX > max.width)
+ deltaX = max.width - startingBounds.width;
+ if (startingBounds.x - deltaX < 0) {
+ deltaX = startingBounds.x;
+ }
+
+ if(startingBounds.height + deltaY < min.height)
+ deltaY = -(startingBounds.height - min.height);
+ else if(startingBounds.height + deltaY > max.height)
+ deltaY = max.height - startingBounds.height;
+ if (startingBounds.y - deltaY < 0) {deltaY = startingBounds.y;}
+
+ newX = startingBounds.x - deltaX;
+ newY = startingBounds.y - deltaY;
+ newW = startingBounds.width + deltaX;
+ newH = startingBounds.height + deltaY;
+ break;
+ default:
+ return;
+ }
+ getDesktopManager().resizeFrame(frame, newX, newY, newW, newH);
+ }
+
+ public void mouseMoved(MouseEvent e) {
+
+ if(!frame.isResizable())
+ return;
+
+ if (e.getSource() == frame || e.getSource() == getNorthPane()) {
+ Insets i = frame.getInsets();
+ Point ep = new Point(e.getX(), e.getY());
+ if (e.getSource() == getNorthPane()) {
+ Point np = getNorthPane().getLocation();
+ ep.x += np.x;
+ ep.y += np.y;
+ }
+ if(ep.x <= i.left) {
+ if(ep.y < resizeCornerSize + i.top)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR));
+ else if(ep.y > frame.getHeight() - resizeCornerSize - i.bottom)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR));
+ else
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));
+ } else if(ep.x >= frame.getWidth() - i.right) {
+ if(e.getY() < resizeCornerSize + i.top)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR));
+ else if(ep.y > frame.getHeight() - resizeCornerSize - i.bottom)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
+ else
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));
+ } else if(ep.y <= i.top) {
+ if(ep.x < resizeCornerSize + i.left)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR));
+ else if(ep.x > frame.getWidth() - resizeCornerSize - i.right)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR));
+ else
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));
+ } else if(ep.y >= frame.getHeight() - i.bottom) {
+ if(ep.x < resizeCornerSize + i.left)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR));
+ else if(ep.x > frame.getWidth() - resizeCornerSize - i.right)
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
+ else
+ frame.setCursor(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));
+ }
+ else
+ updateFrameCursor();
+ return;
+ }
+
+ updateFrameCursor();
+ }
+
+ public void mouseEntered(MouseEvent e) {
+ updateFrameCursor();
+ }
+
+ public void mouseExited(MouseEvent e) {
+ updateFrameCursor();
+ }
+
+ }; /// End BorderListener Class
+
+ protected class ComponentHandler implements ComponentListener {
+ // NOTE: This class exists only for backward compatability. All
+ // its functionality has been moved into Handler. If you need to add
+ // new functionality add it to the Handler, but make sure this
+ // class calls into the Handler.
+ /** Invoked when a JInternalFrame's parent's size changes. */
+ public void componentResized(ComponentEvent e) {
+ getHandler().componentResized(e);
+ }
+
+ public void componentMoved(ComponentEvent e) {
+ getHandler().componentMoved(e);
+ }
+ public void componentShown(ComponentEvent e) {
+ getHandler().componentShown(e);
+ }
+ public void componentHidden(ComponentEvent e) {
+ getHandler().componentHidden(e);
+ }
+ }
+
+ protected ComponentListener createComponentListener() {
+ return getHandler();
+ }
+
+
+ protected class GlassPaneDispatcher implements MouseInputListener {
+ // NOTE: This class exists only for backward compatability. All
+ // its functionality has been moved into Handler. If you need to add
+ // new functionality add it to the Handler, but make sure this
+ // class calls into the Handler.
+ public void mousePressed(MouseEvent e) {
+ getHandler().mousePressed(e);
+ }
+
+ public void mouseEntered(MouseEvent e) {
+ getHandler().mouseEntered(e);
+ }
+
+ public void mouseMoved(MouseEvent e) {
+ getHandler().mouseMoved(e);
+ }
+
+ public void mouseExited(MouseEvent e) {
+ getHandler().mouseExited(e);
+ }
+
+ public void mouseClicked(MouseEvent e) {
+ getHandler().mouseClicked(e);
+ }
+
+ public void mouseReleased(MouseEvent e) {
+ getHandler().mouseReleased(e);
+ }
+
+ public void mouseDragged(MouseEvent e) {
+ getHandler().mouseDragged(e);
+ }
+ }
+
+ protected MouseInputListener createGlassPaneDispatcher() {
+ return null;
+ }
+
+
+ protected class BasicInternalFrameListener implements InternalFrameListener
+ {
+ // NOTE: This class exists only for backward compatability. All
+ // its functionality has been moved into Handler. If you need to add
+ // new functionality add it to the Handler, but make sure this
+ // class calls into the Handler.
+ public void internalFrameClosing(InternalFrameEvent e) {
+ getHandler().internalFrameClosing(e);
+ }
+
+ public void internalFrameClosed(InternalFrameEvent e) {
+ getHandler().internalFrameClosed(e);
+ }
+
+ public void internalFrameOpened(InternalFrameEvent e) {
+ getHandler().internalFrameOpened(e);
+ }
+
+ public void internalFrameIconified(InternalFrameEvent e) {
+ getHandler().internalFrameIconified(e);
+ }
+
+ public void internalFrameDeiconified(InternalFrameEvent e) {
+ getHandler().internalFrameDeiconified(e);
+ }
+
+ public void internalFrameActivated(InternalFrameEvent e) {
+ getHandler().internalFrameActivated(e);
+ }
+
+
+ public void internalFrameDeactivated(InternalFrameEvent e) {
+ getHandler().internalFrameDeactivated(e);
+ }
+ }
+
+ private static boolean isDragging = false;
+ private class Handler implements ComponentListener, InternalFrameListener,
+ LayoutManager, MouseInputListener, PropertyChangeListener,
+ WindowFocusListener, SwingConstants {
+
+ public void windowGainedFocus(WindowEvent e) {
+ }
+
+ public void windowLostFocus(WindowEvent e) {
+ // Cancel a resize which may be in progress, when a
+ // WINDOW_LOST_FOCUS event occurs, which may be
+ // caused by an Alt-Tab or a modal dialog popup.
+ cancelResize();
+ }
+
+ // ComponentHandler methods
+ /** Invoked when a JInternalFrame's parent's size changes. */
+ public void componentResized(ComponentEvent e) {
+ // Get the JInternalFrame's parent container size
+ Rectangle parentNewBounds = ((Component) e.getSource()).getBounds();
+ JInternalFrame.JDesktopIcon icon = null;
+
+ if (frame != null) {
+ icon = frame.getDesktopIcon();
+ // Resize the internal frame if it is maximized and relocate
+ // the associated icon as well.
+ if (frame.isMaximum()) {
+ frame.setBounds(0, 0, parentNewBounds.width,
+ parentNewBounds.height);
+ }
+ }
+
+ // Relocate the icon base on the new parent bounds.
+ if (icon != null) {
+ Rectangle iconBounds = icon.getBounds();
+ int y = iconBounds.y +
+ (parentNewBounds.height - parentBounds.height);
+ icon.setBounds(iconBounds.x, y,
+ iconBounds.width, iconBounds.height);
+ }
+
+ // Update the new parent bounds for next resize.
+ if (!parentBounds.equals(parentNewBounds)) {
+ parentBounds = parentNewBounds;
+ }
+
+ // Validate the component tree for this container.
+ if (frame != null) frame.validate();
+ }
+
+ public void componentMoved(ComponentEvent e) {}
+ public void componentShown(ComponentEvent e) {}
+ public void componentHidden(ComponentEvent e) {}
+
+
+ // InternalFrameListener
+ public void internalFrameClosed(InternalFrameEvent e) {
+ frame.removeInternalFrameListener(getHandler());
+ }
+
+ public void internalFrameActivated(InternalFrameEvent e) {
+ if (!isKeyBindingRegistered()){
+ setKeyBindingRegistered(true);
+ setupMenuOpenKey();
+ setupMenuCloseKey();
+ }
+ if (isKeyBindingRegistered())
+ setKeyBindingActive(true);
+ }
+
+ public void internalFrameDeactivated(InternalFrameEvent e) {
+ setKeyBindingActive(false);
+ }
+
+ public void internalFrameClosing(InternalFrameEvent e) { }
+ public void internalFrameOpened(InternalFrameEvent e) { }
+ public void internalFrameIconified(InternalFrameEvent e) { }
+ public void internalFrameDeiconified(InternalFrameEvent e) { }
+
+
+ // LayoutManager
+ public void addLayoutComponent(String name, Component c) {}
+ public void removeLayoutComponent(Component c) {}
+ public Dimension preferredLayoutSize(Container c) {
+ Dimension result;
+ Insets i = frame.getInsets();
+
+ result = new Dimension(frame.getRootPane().getPreferredSize());
+ result.width += i.left + i.right;
+ result.height += i.top + i.bottom;
+
+ if(getNorthPane() != null) {
+ Dimension d = getNorthPane().getPreferredSize();
+ result.width = Math.max(d.width, result.width);
+ result.height += d.height;
+ }
+
+ if(getSouthPane() != null) {
+ Dimension d = getSouthPane().getPreferredSize();
+ result.width = Math.max(d.width, result.width);
+ result.height += d.height;
+ }
+
+ if(getEastPane() != null) {
+ Dimension d = getEastPane().getPreferredSize();
+ result.width += d.width;
+ result.height = Math.max(d.height, result.height);
+ }
+
+ if(getWestPane() != null) {
+ Dimension d = getWestPane().getPreferredSize();
+ result.width += d.width;
+ result.height = Math.max(d.height, result.height);
+ }
+ return result;
+ }
+
+ public Dimension minimumLayoutSize(Container c) {
+ // The minimum size of the internal frame only takes into
+ // account the title pane since you are allowed to resize
+ // the frames to the point where just the title pane is visible.
+ Dimension result = new Dimension();
+ if (getNorthPane() != null &&
+ getNorthPane() instanceof BasicInternalFrameTitlePane) {
+ result = new Dimension(getNorthPane().getMinimumSize());
+ }
+ Insets i = frame.getInsets();
+ result.width += i.left + i.right;
+ result.height += i.top + i.bottom;
+
+ return result;
+ }
+
+ public void layoutContainer(Container c) {
+ Insets i = frame.getInsets();
+ int cx, cy, cw, ch;
+
+ cx = i.left;
+ cy = i.top;
+ cw = frame.getWidth() - i.left - i.right;
+ ch = frame.getHeight() - i.top - i.bottom;
+
+ if(getNorthPane() != null) {
+ Dimension size = getNorthPane().getPreferredSize();
+ if (DefaultLookup.getBoolean(frame, BasicInternalFrameUI.this,
+ "InternalFrame.layoutTitlePaneAtOrigin", false)) {
+ cy = 0;
+ ch += i.top;
+ getNorthPane().setBounds(0, 0, frame.getWidth(),
+ size.height);
+ }
+ else {
+ getNorthPane().setBounds(cx, cy, cw, size.height);
+ }
+ cy += size.height;
+ ch -= size.height;
+ }
+
+ if(getSouthPane() != null) {
+ Dimension size = getSouthPane().getPreferredSize();
+ getSouthPane().setBounds(cx, frame.getHeight()
+ - i.bottom - size.height,
+ cw, size.height);
+ ch -= size.height;
+ }
+
+ if(getWestPane() != null) {
+ Dimension size = getWestPane().getPreferredSize();
+ getWestPane().setBounds(cx, cy, size.width, ch);
+ cw -= size.width;
+ cx += size.width;
+ }
+
+ if(getEastPane() != null) {
+ Dimension size = getEastPane().getPreferredSize();
+ getEastPane().setBounds(cw - size.width, cy, size.width, ch);
+ cw -= size.width;
+ }
+
+ if(frame.getRootPane() != null) {
+ frame.getRootPane().setBounds(cx, cy, cw, ch);
+ }
+ }
+
+
+ // MouseInputListener
+ private Component mouseEventTarget = null;
+ private Component dragSource = null;
+
+ public void mousePressed(MouseEvent e) { }
+
+ public void mouseEntered(MouseEvent e) { }
+
+ public void mouseMoved(MouseEvent e) { }
+
+ public void mouseExited(MouseEvent e) { }
+
+ public void mouseClicked(MouseEvent e) { }
+
+ public void mouseReleased(MouseEvent e) { }
+
+ public void mouseDragged(MouseEvent e) { }
+
+ // PropertyChangeListener
+ public void propertyChange(PropertyChangeEvent evt) {
+ String prop = (String)evt.getPropertyName();
+ JInternalFrame f = (JInternalFrame)evt.getSource();
+ Object newValue = evt.getNewValue();
+ Object oldValue = evt.getOldValue();
+
+ if (JInternalFrame.IS_CLOSED_PROPERTY == prop) {
+ if (newValue == Boolean.TRUE) {
+ // Cancel a resize in progress if the internal frame
+ // gets a setClosed(true) or dispose().
+ cancelResize();
+ if ((frame.getParent() != null) && componentListenerAdded) {
+ frame.getParent().removeComponentListener(
+ componentListener);
+ }
+ closeFrame(f);
+ }
+ } else if (JInternalFrame.IS_MAXIMUM_PROPERTY == prop) {
+ if(newValue == Boolean.TRUE) {
+ maximizeFrame(f);
+ } else {
+ minimizeFrame(f);
+ }
+ } else if(JInternalFrame.IS_ICON_PROPERTY == prop) {
+ if (newValue == Boolean.TRUE) {
+ iconifyFrame(f);
+ } else {
+ deiconifyFrame(f);
+ }
+ } else if (JInternalFrame.IS_SELECTED_PROPERTY == prop) {
+ if (newValue == Boolean.TRUE && oldValue == Boolean.FALSE) {
+ activateFrame(f);
+ } else if (newValue == Boolean.FALSE &&
+ oldValue == Boolean.TRUE) {
+ deactivateFrame(f);
+ }
+ } else if (prop == "ancestor") {
+ if (newValue == null) {
+ // Cancel a resize in progress, if the internal frame
+ // gets a remove(), removeNotify() or setIcon(true).
+ cancelResize();
+ }
+ if (frame.getParent() != null) {
+ parentBounds = f.getParent().getBounds();
+ } else {
+ parentBounds = null;
+ }
+ if ((frame.getParent() != null) && !componentListenerAdded) {
+ f.getParent().addComponentListener(componentListener);
+ componentListenerAdded = true;
+ } else if ((newValue == null) && componentListenerAdded) {
+ if (f.getParent() != null) {
+ f.getParent().removeComponentListener(
+ componentListener);
+ }
+ componentListenerAdded = false;
+ }
+ } else if (JInternalFrame.TITLE_PROPERTY == prop ||
+ prop == "closable" || prop == "iconable" ||
+ prop == "maximizable") {
+ Dimension dim = frame.getMinimumSize();
+ Dimension frame_dim = frame.getSize();
+ if (dim.width > frame_dim.width) {
+ frame.setSize(dim.width, frame_dim.height);
+ }
+ }
+ }
+ }
+}