| /* |
| * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.swing.plaf.basic; |
| |
| import java.awt.*; |
| import java.awt.event.*; |
| import javax.swing.*; |
| import javax.swing.plaf.*; |
| import javax.swing.event.*; |
| import java.beans.*; |
| 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 = 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(frame == x) |
| return frame.getLayout().preferredLayoutSize(x); |
| return new Dimension(100, 100); |
| } |
| |
| public Dimension getMinimumSize(JComponent x) { |
| if(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; |
| updateFrameCursor(); |
| } |
| _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 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 |
| 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 = 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 (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); |
| } |
| } |
| } |
| } |
| } |
