1. /*

  2.  * @(#)BasicDesktopPaneUI.java	1.55 04/05/18

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package javax.swing.plaf.basic;

  9. 

  10. import javax.swing.*;

  11. import javax.swing.plaf.*;

  12. 

  13. import java.beans.*;

  14. 

  15. import java.awt.event.*;

  16. import java.awt.Dimension;

  17. import java.awt.Insets;

  18. import java.awt.Graphics;

  19. import java.awt.KeyboardFocusManager;

  20. import java.awt.*;

  21. import java.util.Vector;

  22. import sun.swing.DefaultLookup;

  23. import sun.swing.UIAction;

  24. 

  25. /**

  26.  * Basic L&F for a desktop.

  27.  *

  28.  * @version 1.55 05/18/04

  29.  * @author Steve Wilson

  30.  */

  31. public class BasicDesktopPaneUI extends DesktopPaneUI {

  32.     // Old actions forward to an instance of this.

  33.     private static final Actions SHARED_ACTION = new Actions();

  34. 

  35.     private static Dimension minSize = new Dimension(0,0);

  36.     private static Dimension maxSize = new Dimension(Integer.MAX_VALUE,

  37.             Integer.MAX_VALUE);

  38.     private Handler handler;

  39.     private PropertyChangeListener pcl;

  40. 

  41.     protected JDesktopPane desktop;

  42.     protected DesktopManager desktopManager;

  43. 

  44.     /**

  45.      * As of Java 2 platform v1.3 this previously undocumented field is no

  46.      * longer used.

  47.      * Key bindings are now defined by the LookAndFeel, please refer to

  48.      * the key bindings specification for further details.

  49.      *

  50.      * @deprecated As of 1.3.

  51.      */

  52.     @Deprecated

  53.     protected KeyStroke minimizeKey;

  54.     /**

  55.      * As of Java 2 platform v1.3 this previously undocumented field is no

  56.      * longer used.

  57.      * Key bindings are now defined by the LookAndFeel, please refer to

  58.      * the key bindings specification for further details.

  59.      *

  60.      * @deprecated As of 1.3.

  61.      */

  62.     @Deprecated

  63.     protected KeyStroke maximizeKey;

  64.     /**

  65.      * As of Java 2 platform v1.3 this previously undocumented field is no

  66.      * longer used.

  67.      * Key bindings are now defined by the LookAndFeel, please refer to

  68.      * the key bindings specification for further details.

  69.      *

  70.      * @deprecated As of 1.3.

  71.      */

  72.     @Deprecated

  73.     protected KeyStroke closeKey;

  74.     /**

  75.      * As of Java 2 platform v1.3 this previously undocumented field is no

  76.      * longer used.

  77.      * Key bindings are now defined by the LookAndFeel, please refer to

  78.      * the key bindings specification for further details.

  79.      *

  80.      * @deprecated As of 1.3.

  81.      */

  82.     @Deprecated

  83.     protected KeyStroke navigateKey;

  84.     /**

  85.      * As of Java 2 platform v1.3 this previously undocumented field is no

  86.      * longer used.

  87.      * Key bindings are now defined by the LookAndFeel, please refer to

  88.      * the key bindings specification for further details.

  89.      *

  90.      * @deprecated As of 1.3.

  91.      */

  92.     @Deprecated

  93.     protected KeyStroke navigateKey2;

  94. 

  95.     public static ComponentUI createUI(JComponent c) {

  96.         return new BasicDesktopPaneUI();

  97.     }

  98. 

  99.     public BasicDesktopPaneUI() {

  100.     }

  101. 

  102.     public void installUI(JComponent c)   {

  103. 	desktop = (JDesktopPane)c;

  104. 	installDefaults();

  105. 	installDesktopManager();

  106.         installListeners();

  107. 	installKeyboardActions();

  108.     }

  109. 

  110.     public void uninstallUI(JComponent c) {

  111. 	uninstallKeyboardActions();

  112.         uninstallListeners();

  113. 	uninstallDesktopManager();

  114.         uninstallDefaults();

  115. 	desktop = null;

  116.         handler = null;

  117.     }

  118. 

  119.     protected void installDefaults() {

  120. 	if (desktop.getBackground() == null || 

  121. 	    desktop.getBackground() instanceof UIResource) {

  122. 	    desktop.setBackground(UIManager.getColor("Desktop.background"));

  123. 	}

  124.         LookAndFeel.installProperty(desktop, "opaque", Boolean.TRUE);

  125.     }

  126. 

  127.     protected void uninstallDefaults() { }

  128. 

  129.     /**

  130.      * Installs the <code>PropertyChangeListener</code> returned from

  131.      * <code>createPropertyChangeListener</code> on the

  132.      * <code>JDesktopPane</code>.

  133.      *

  134.      * @since 1.5

  135.      * @see #createPropertyChangeListener

  136.      */

  137.     protected void installListeners() {

  138.         pcl = createPropertyChangeListener();

  139.         desktop.addPropertyChangeListener(pcl);

  140.     }

  141. 

  142.     /**

  143.      * Uninstalls the <code>PropertyChangeListener</code> returned from 

  144.      * <code>createPropertyChangeListener</code> from the

  145.      * <code>JDesktopPane</code>.

  146.      *

  147.      * @since 1.5

  148.      * @see #createPropertyChangeListener

  149.      */

  150.     protected void uninstallListeners() {

  151.         desktop.removePropertyChangeListener(pcl);

  152.         pcl = null;

  153.     }

  154. 

  155.     protected void installDesktopManager() {

  156.         desktopManager = desktop.getDesktopManager();

  157. 	if(desktopManager == null) {

  158. 	    desktopManager = new BasicDesktopManager();

  159. 	    desktop.setDesktopManager(desktopManager);

  160. 	}

  161.     }

  162. 

  163.     protected void uninstallDesktopManager() {

  164. 	if(desktop.getDesktopManager() instanceof UIResource) {

  165. 	    desktop.setDesktopManager(null);

  166. 	}

  167. 	desktopManager = null;

  168.     }

  169. 

  170.     protected void installKeyboardActions(){

  171. 	InputMap inputMap = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

  172. 	if (inputMap != null) {

  173. 	    SwingUtilities.replaceUIInputMap(desktop,

  174. 			JComponent.WHEN_IN_FOCUSED_WINDOW, inputMap);

  175. 	}

  176. 	inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  177. 	if (inputMap != null) {

  178. 	    SwingUtilities.replaceUIInputMap(desktop,

  179. 			JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

  180. 			inputMap);

  181. 	}

  182. 

  183.         LazyActionMap.installLazyActionMap(desktop, BasicDesktopPaneUI.class,

  184.                 "DesktopPane.actionMap");

  185. 	registerKeyboardActions();

  186.     }

  187. 

  188.     protected void registerKeyboardActions(){

  189.     }

  190.  

  191.     protected void unregisterKeyboardActions(){

  192.     }

  193. 

  194.     InputMap getInputMap(int condition) {

  195. 	if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {

  196. 	    return createInputMap(condition);

  197. 	}

  198. 	else if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {

  199. 	    return (InputMap)DefaultLookup.get(desktop, this,

  200.                     "Desktop.ancestorInputMap");

  201. 	}

  202. 	return null;

  203.     }

  204. 

  205.     InputMap createInputMap(int condition) {

  206. 	if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {

  207. 	    Object[] bindings = (Object[])DefaultLookup.get(desktop,

  208.                     this, "Desktop.windowBindings");

  209. 

  210. 	    if (bindings != null) {

  211. 		return LookAndFeel.makeComponentInputMap(desktop, bindings);

  212. 	    }

  213. 	}

  214. 	return null;

  215.     }

  216. 

  217.     static void loadActionMap(LazyActionMap map) {

  218.         map.put(new Actions(Actions.RESTORE));

  219.         map.put(new Actions(Actions.CLOSE));

  220.         map.put(new Actions(Actions.MOVE));

  221.         map.put(new Actions(Actions.RESIZE));

  222.         map.put(new Actions(Actions.LEFT));

  223.         map.put(new Actions(Actions.SHRINK_LEFT));

  224.         map.put(new Actions(Actions.RIGHT));

  225.         map.put(new Actions(Actions.SHRINK_RIGHT));

  226.         map.put(new Actions(Actions.UP));

  227.         map.put(new Actions(Actions.SHRINK_UP));

  228.         map.put(new Actions(Actions.DOWN));

  229.         map.put(new Actions(Actions.SHRINK_DOWN));

  230.         map.put(new Actions(Actions.ESCAPE));

  231.         map.put(new Actions(Actions.MINIMIZE));

  232.         map.put(new Actions(Actions.MAXIMIZE));

  233.         map.put(new Actions(Actions.NEXT_FRAME));

  234.         map.put(new Actions(Actions.PREVIOUS_FRAME));

  235.         map.put(new Actions(Actions.NAVIGATE_NEXT));

  236.         map.put(new Actions(Actions.NAVIGATE_PREVIOUS));

  237.     }

  238. 

  239.     protected void uninstallKeyboardActions(){ 

  240.       unregisterKeyboardActions();

  241.       SwingUtilities.replaceUIInputMap(desktop, JComponent.

  242. 				     WHEN_IN_FOCUSED_WINDOW, null);

  243.       SwingUtilities.replaceUIInputMap(desktop, JComponent.

  244. 				     WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);

  245.       SwingUtilities.replaceUIActionMap(desktop, null);

  246.     }

  247. 

  248.     public void paint(Graphics g, JComponent c) {}

  249. 

  250.     public Dimension getPreferredSize(JComponent c) {return null;}

  251. 

  252.     public Dimension getMinimumSize(JComponent c) {

  253. 	return minSize;

  254. 	}

  255.     public Dimension getMaximumSize(JComponent c){

  256. 	return maxSize;

  257.     }

  258. 

  259.     /**

  260.      * Returns the <code>PropertyChangeListener</code> to install on

  261.      * the <code>JDesktopPane</code>.

  262.      *

  263.      * @since 1.5

  264.      * @return The PropertyChangeListener that will be added to track

  265.      * changes in the desktop pane.

  266.      */

  267.     protected PropertyChangeListener createPropertyChangeListener() {

  268.         return getHandler();

  269.     }

  270. 

  271.     private Handler getHandler() {

  272.         if (handler == null) {

  273.             handler = new Handler();

  274.         }

  275.         return handler;

  276.     }

  277. 

  278.     private class Handler implements PropertyChangeListener {

  279.         public void propertyChange(PropertyChangeEvent evt) {

  280.             String propertyName = evt.getPropertyName();

  281. 

  282.             if ("desktopManager" == propertyName) {

  283.                 installDesktopManager();

  284.             }

  285.         }

  286.     }

  287. 

  288.     /**

  289.      * The default DesktopManager installed by the UI.

  290.      */

  291.     private class BasicDesktopManager extends DefaultDesktopManager

  292.             implements UIResource {

  293.     }

  294. 

  295.     private static class Actions extends UIAction {

  296.         private static String CLOSE = "close";

  297.         private static String ESCAPE = "escape";

  298.         private static String MAXIMIZE = "maximize";

  299.         private static String MINIMIZE = "minimize";

  300.         private static String MOVE = "move";

  301.         private static String RESIZE = "resize";

  302.         private static String RESTORE = "restore";

  303.         private static String LEFT = "left";

  304.         private static String RIGHT = "right";

  305.         private static String UP = "up";

  306.         private static String DOWN = "down";

  307.         private static String SHRINK_LEFT = "shrinkLeft";

  308.         private static String SHRINK_RIGHT = "shrinkRight";

  309.         private static String SHRINK_UP = "shrinkUp";

  310.         private static String SHRINK_DOWN = "shrinkDown";

  311.         private static String NEXT_FRAME = "selectNextFrame";

  312.         private static String PREVIOUS_FRAME = "selectPreviousFrame";

  313.         private static String NAVIGATE_NEXT = "navigateNext";

  314.         private static String NAVIGATE_PREVIOUS = "navigatePrevious";

  315.         private final int MOVE_RESIZE_INCREMENT = 10;

  316.         private static boolean moving = false;

  317.         private static boolean resizing = false;

  318.         private static JInternalFrame sourceFrame = null;

  319.         private static Component focusOwner = null;

  320. 

  321.         Actions() {

  322.             super(null);

  323.         }

  324. 

  325.         Actions(String name) {

  326.             super(name);

  327.         }

  328. 

  329.         public void actionPerformed(ActionEvent e) {

  330.             JDesktopPane dp = (JDesktopPane)e.getSource();

  331.             String key = getName();

  332. 

  333.             if (CLOSE == key || MAXIMIZE == key || MINIMIZE == key ||

  334.                     RESTORE == key) {

  335.                 setState(dp, key);

  336.             }

  337.             else if (ESCAPE == key) {

  338.                 if (sourceFrame == dp.getSelectedFrame() &&

  339.                         focusOwner != null) {

  340.                     focusOwner.requestFocus();

  341.                 }

  342.                 moving = false;

  343.                 resizing = false;

  344.                 sourceFrame = null;

  345.                 focusOwner = null;

  346.             }

  347.             else if (MOVE == key || RESIZE == key) {

  348.                 sourceFrame = dp.getSelectedFrame();

  349.                 if (sourceFrame == null) {

  350.                     return;

  351.                 }

  352.                 moving = (key == MOVE) ? true : false;

  353.                 resizing = (key == RESIZE) ? true : false;

  354. 

  355.                 focusOwner = KeyboardFocusManager.

  356.                     getCurrentKeyboardFocusManager().getFocusOwner();

  357.                 if (!SwingUtilities.isDescendingFrom(focusOwner, sourceFrame)) {

  358.                     focusOwner = null;

  359.                 }

  360.                 sourceFrame.requestFocus();

  361.             }

  362.             else if (LEFT == key ||

  363.                      RIGHT == key ||

  364.                      UP == key ||

  365.                      DOWN == key ||

  366.                      SHRINK_RIGHT == key ||

  367.                      SHRINK_LEFT == key ||

  368.                      SHRINK_UP == key ||

  369.                      SHRINK_DOWN == key) {

  370.                 JInternalFrame c = dp.getSelectedFrame();

  371.                 if (sourceFrame == null || c != sourceFrame ||

  372.                         KeyboardFocusManager.

  373.                             getCurrentKeyboardFocusManager().getFocusOwner() !=

  374.                                 sourceFrame) {

  375.                     return;

  376.                 }

  377.                 Dimension size = c.getSize();

  378.                 Dimension minSize = c.getMinimumSize();

  379.                 Point loc = c.getLocation();

  380.                 if (LEFT == key) {

  381.                     if (moving) {

  382.                         c.setLocation(loc.x - MOVE_RESIZE_INCREMENT, loc.y);

  383.                     } else if (resizing) {

  384.                         c.setLocation(loc.x - MOVE_RESIZE_INCREMENT, loc.y);

  385.                         c.setSize(size.width + MOVE_RESIZE_INCREMENT,

  386.                                 size.height);

  387.                     }

  388.                 } else if (RIGHT == key) {

  389.                     if (moving) {

  390.                         c.setLocation(loc.x + MOVE_RESIZE_INCREMENT, loc.y);

  391.                     } else if (resizing) {

  392.                         c.setLocation(loc.x, loc.y);

  393.                         c.setSize(size.width + MOVE_RESIZE_INCREMENT,

  394.                                 size.height);

  395.                     }

  396.                 } else if (UP == key) {

  397.                     if (moving) {

  398.                         c.setLocation(loc.x, loc.y - MOVE_RESIZE_INCREMENT);

  399.                     } else if (resizing) {

  400.                         c.setLocation(loc.x, loc.y - MOVE_RESIZE_INCREMENT);

  401.                         c.setSize(size.width,

  402.                                 size.height + MOVE_RESIZE_INCREMENT);

  403.                     }

  404.                 } else if (DOWN == key) {

  405.                     if (moving) {

  406.                         c.setLocation(loc.x, loc.y + MOVE_RESIZE_INCREMENT);

  407.                     } else if (resizing) {

  408.                         c.setLocation(loc.x, loc.y);

  409.                         c.setSize(size.width,

  410.                                 size.height + MOVE_RESIZE_INCREMENT);

  411.                     }

  412.                 } else if (SHRINK_LEFT == key && resizing) {

  413.                     if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {

  414.                         c.setLocation(loc.x, loc.y);

  415.                         c.setSize(size.width - MOVE_RESIZE_INCREMENT,

  416.                                 size.height);

  417.                     } else {

  418.                         c.setSize(minSize.width, size.height);

  419.                     }

  420.                 } else if (SHRINK_RIGHT == key && resizing) {

  421.                     if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {

  422.                         c.setLocation(loc.x + MOVE_RESIZE_INCREMENT, loc.y);

  423.                         c.setSize(size.width - MOVE_RESIZE_INCREMENT,

  424.                                 size.height);

  425.                     } else {

  426.                         c.setLocation(loc.x - minSize.width + size.width,

  427.                                 loc.y);

  428.                         c.setSize(minSize.width, size.height);

  429.                     }

  430.                 } else if (SHRINK_UP == key && resizing) {

  431.                     if (minSize.height <

  432.                             (size.height - MOVE_RESIZE_INCREMENT)) {

  433.                         c.setLocation(loc.x, loc.y);

  434.                         c.setSize(size.width,

  435.                                 size.height - MOVE_RESIZE_INCREMENT);

  436.                     } else {

  437.                         c.setSize(size.width, minSize.height);

  438.                     }

  439.                 } else if (SHRINK_DOWN == key  && resizing) {

  440.                     if (minSize.height <

  441.                             (size.height - MOVE_RESIZE_INCREMENT)) {

  442.                         c.setLocation(loc.x, loc.y + MOVE_RESIZE_INCREMENT);

  443.                         c.setSize(size.width,

  444.                                 size.height - MOVE_RESIZE_INCREMENT);

  445.                     } else {

  446.                         c.setLocation(loc.x,

  447.                                 loc.y - minSize.height + size.height);

  448.                         c.setSize(size.width, minSize.height);

  449.                     }

  450.                 }

  451.             }

  452.             else if (NEXT_FRAME == key || PREVIOUS_FRAME == key) {

  453.                 selectFrame(dp, (key == NEXT_FRAME) ? true : false);

  454.             }

  455.             else if (NAVIGATE_NEXT == key ||

  456.                      NAVIGATE_PREVIOUS == key) {

  457.                 boolean moveForward = true;

  458.                 if (NAVIGATE_PREVIOUS == key) {

  459.                     moveForward = false;

  460.                 }

  461.                 Container cycleRoot = dp.getFocusCycleRootAncestor();

  462. 

  463.                 if (cycleRoot != null) {

  464.                     FocusTraversalPolicy policy =

  465.                         cycleRoot.getFocusTraversalPolicy();

  466.                     if (policy != null && policy instanceof

  467.                             SortingFocusTraversalPolicy) {

  468.                         SortingFocusTraversalPolicy sPolicy =

  469.                             (SortingFocusTraversalPolicy)policy;

  470.                         boolean idc = sPolicy.getImplicitDownCycleTraversal();

  471.                         try {

  472.                             sPolicy.setImplicitDownCycleTraversal(false);

  473.                             if (moveForward) {

  474.                                 KeyboardFocusManager.

  475.                                     getCurrentKeyboardFocusManager().

  476.                                         focusNextComponent(dp);

  477.                             } else {

  478.                                 KeyboardFocusManager.

  479.                                     getCurrentKeyboardFocusManager().

  480.                                     focusPreviousComponent(dp);

  481.                             }

  482.                         } finally {

  483.                             sPolicy.setImplicitDownCycleTraversal(idc);

  484.                         }

  485.                     }

  486.                 }

  487.             }

  488.         }

  489. 

  490.         private void selectFrame(JDesktopPane dp, boolean forward) {

  491.             if (forward) {

  492.                 // navigate to the next frame

  493.                 int i = 0;

  494.                 verifyFramesCache(dp);

  495.                 if (framesCache.size() == 0) {

  496.                     return;

  497.                 }

  498. 

  499.                 JInternalFrame f = dp.getSelectedFrame();

  500. 

  501.                 if (f != null) {

  502.                     i = framesCache.indexOf(f);

  503.                 }

  504.                 if (i == -1) {

  505.                     /* if the frame is not there, its icon may be */

  506.                     i = framesCache.indexOf(f.getDesktopIcon());

  507.                     if (i == -1) {

  508.                         /* error */

  509.                         return;

  510.                     }

  511.                 }

  512.                 if (++i == framesCache.size()) {

  513.                     /* wrap */

  514.                     i = 0;

  515.                 }

  516.                 JComponent c = (JComponent) framesCache.elementAt(i);

  517.                 if (c instanceof JInternalFrame) {

  518.                     try {

  519.                         ((JInternalFrame)c).setSelected(true);

  520.                         dp.getDesktopManager().activateFrame((JInternalFrame)c);

  521.                     } catch (PropertyVetoException pve) {}

  522.                 } else {

  523.                     /* it had better be an icon! */

  524.                     if (!(c instanceof JInternalFrame.JDesktopIcon)){

  525.                         /* error */

  526.                         return;

  527.                     }

  528.                     try {

  529.                         ((JInternalFrame)((JInternalFrame.JDesktopIcon)c).

  530.                                 getInternalFrame()).setSelected(true);

  531.                         dp.getDesktopManager().activateFrame(

  532.                                 ((JInternalFrame.JDesktopIcon)c).

  533.                                         getInternalFrame());

  534.                     } catch (PropertyVetoException pve) {}

  535.                 }

  536.             } else {

  537.                 // navigate to the previous internal frame

  538.                 int i = 0;

  539.                 verifyFramesCache(dp);

  540.                 if (framesCache.size() == 0) {

  541.                     return;

  542.                 }

  543.                 JInternalFrame f = dp.getSelectedFrame();

  544.                 if (f != null) {

  545.                     i = framesCache.indexOf(f);

  546.                 }

  547.                 if (i == -1) {

  548.                     /* if the frame is not there, its icon may be */

  549.                     i = framesCache.indexOf(f.getDesktopIcon());

  550.                     if (i == -1) {

  551.                         /* error */

  552.                         return;

  553.                     }

  554.                 }

  555.                 if (--i == -1) {

  556.                     /* wrap */

  557.                     i = framesCache.size() - 1;

  558.                 }

  559.                 JComponent c = (JComponent) framesCache.elementAt(i);

  560.                 if (c instanceof JInternalFrame) {

  561.                     try {

  562.                         ((JInternalFrame)c).setSelected(true);

  563.                     } catch (PropertyVetoException pve) {}

  564.                 } else {

  565.                     /* it had better be an icon! */

  566.                     if (!(c instanceof JInternalFrame.JDesktopIcon)) {

  567.                         /* error */

  568.                         return;

  569.                     }

  570.                     try {

  571.                         ((JInternalFrame)((JInternalFrame.JDesktopIcon)c).

  572.                                 getInternalFrame()).setSelected(true);

  573.                     } catch (PropertyVetoException pve) {}

  574.                 }

  575.             }

  576.         }

  577. 

  578.         private void setState(JDesktopPane dp, String state) {

  579.             if (state == CLOSE) {

  580.                 JInternalFrame f = dp.getSelectedFrame();

  581.                 if (f == null) {

  582.                     return;

  583.                 }

  584.                 f.doDefaultCloseAction();

  585.             } else if (state == MAXIMIZE) {

  586.                 // maximize the selected frame

  587.                 JInternalFrame f = dp.getSelectedFrame();

  588.                 if (f == null) {

  589.                     return;

  590.                 }

  591.                 if (!f.isMaximum()) {

  592.                     if (f.isIcon()) {

  593.                         try {

  594.                             f.setIcon(false);

  595.                             f.setMaximum(true);

  596.                         } catch (PropertyVetoException pve) {}

  597.                     } else {

  598.                         try {

  599.                             f.setMaximum(true);

  600.                         } catch (PropertyVetoException pve) {

  601.                         }

  602.                     }

  603.                 }

  604.             } else if (state == MINIMIZE) {

  605.                 // minimize the selected frame

  606.                 JInternalFrame f = dp.getSelectedFrame();

  607.                 if (f == null) {

  608.                     return;

  609.                 }

  610.                 if (!f.isIcon()) {

  611.                     try {

  612.                         f.setIcon(true);

  613.                     } catch (PropertyVetoException pve) {

  614.                     }

  615.                 }

  616.             } else if (state == RESTORE) {

  617.                 // restore the selected minimized or maximized frame

  618.                 JInternalFrame f = dp.getSelectedFrame();

  619.                 if (f == null) {

  620.                     return;

  621.                 }

  622.                 try {

  623.                     if (f.isIcon()) {

  624.                         f.setIcon(false);

  625.                     } else if (f.isMaximum()) {

  626.                         f.setMaximum(false);

  627.                     }

  628.                     f.setSelected(true);

  629.                 } catch (PropertyVetoException pve) {

  630.                 }

  631.             }

  632.         }

  633. 

  634. 

  635.         public boolean isEnabled(Object sender) {

  636.             if (sender instanceof JDesktopPane) {

  637.                 JDesktopPane dp = (JDesktopPane)sender;

  638.                 JInternalFrame iFrame = dp.getSelectedFrame();

  639.                 if (iFrame == null) {

  640.                     return false;

  641.                 }

  642.                 String action = getName();

  643.                 if (action == Actions.CLOSE) {

  644.                     return iFrame.isClosable();

  645.                 } else if (action == Actions.MINIMIZE) {

  646.                     return iFrame.isIconifiable();

  647.                 } else if (action == Actions.MAXIMIZE) {

  648.                     return iFrame.isMaximizable();

  649.                 }

  650.                 return true;

  651.             }

  652.             return false;

  653.         }

  654.     }

  655. 

  656. 

  657.     private static Vector framesCache;

  658. 

  659.     /*

  660.      * Handles restoring a minimized or maximized internal frame.

  661.      */

  662.     protected class OpenAction extends AbstractAction {

  663. 	public void actionPerformed(ActionEvent evt) {

  664.             JDesktopPane dp = (JDesktopPane)evt.getSource();

  665.             SHARED_ACTION.setState(dp, Actions.RESTORE);

  666. 	}

  667. 

  668. 	public boolean isEnabled() { 

  669. 	    return true;

  670. 	}

  671.     }

  672. 

  673.     /*

  674.      * Handles closing an internal frame

  675.      */

  676.     protected class CloseAction extends AbstractAction {

  677. 	public void actionPerformed(ActionEvent evt) {

  678.             JDesktopPane dp = (JDesktopPane)evt.getSource();

  679.             SHARED_ACTION.setState(dp, Actions.CLOSE);

  680. 	}

  681. 

  682. 	public boolean isEnabled() { 

  683.             JInternalFrame iFrame = desktop.getSelectedFrame();

  684.             if (iFrame != null) {

  685.                 return iFrame.isClosable();

  686.             }

  687.             return false;

  688. 	}

  689.     }

  690. 

  691.     /*

  692.      * Handles minimizing an internal frame

  693.      */

  694.     protected class MinimizeAction extends AbstractAction {

  695. 	public void actionPerformed(ActionEvent evt) {

  696.             JDesktopPane dp = (JDesktopPane)evt.getSource();

  697.             SHARED_ACTION.setState(dp, Actions.MINIMIZE);

  698. 	}

  699. 

  700. 	public boolean isEnabled() { 

  701.             JInternalFrame iFrame = desktop.getSelectedFrame();

  702.             if (iFrame != null) {

  703. 	        return iFrame.isIconifiable();

  704.             }

  705.             return false;

  706. 	}

  707.     }

  708. 

  709.     /*

  710.      * Handles maximizing an internal frame

  711.      */

  712.     protected class MaximizeAction extends AbstractAction {

  713. 	public void actionPerformed(ActionEvent evt) {

  714.             JDesktopPane dp = (JDesktopPane)evt.getSource();

  715.             SHARED_ACTION.setState(dp, Actions.MAXIMIZE);

  716. 	}

  717. 

  718. 	public boolean isEnabled() { 

  719.             JInternalFrame iFrame = desktop.getSelectedFrame();

  720.             if (iFrame != null) {

  721. 	        return iFrame.isMaximizable();

  722.             }

  723.             return false;

  724.         }

  725.     }

  726. 

  727.     /*

  728.      * Handles navigating to the next internal frame. 

  729.      */

  730.     protected class NavigateAction extends AbstractAction {

  731. 	public void actionPerformed(ActionEvent evt) {

  732.             JDesktopPane dp = (JDesktopPane)evt.getSource();

  733.             SHARED_ACTION.selectFrame(dp, true);

  734. 	}

  735. 

  736. 	public boolean isEnabled() { 

  737. 	    return true;

  738. 	}

  739.     }

  740. 

  741.     private static void verifyFramesCache(JDesktopPane dp) {

  742. 	if (framesCache == null) {

  743. 	    framesCache = new Vector();

  744. 	}

  745. 

  746. 	// Check whether any internal frames have closed in

  747. 	// which case we have to refresh the frames cache.

  748.        	boolean framesHaveClosed = false;

  749. 	int len = framesCache.size();

  750. 	for (int i = 0; i < len; i++) {

  751. 	    JComponent c = 

  752. 		(JComponent)framesCache.elementAt(i);

  753. 	    if (c instanceof JInternalFrame) {

  754. 		JInternalFrame f = (JInternalFrame)c;

  755. 		if (f.isClosed()) {

  756. 		    framesHaveClosed = true;

  757. 		    break;

  758. 		}

  759. 	    }

  760. 	    else if (c instanceof JInternalFrame.JDesktopIcon) {

  761. 		JInternalFrame.JDesktopIcon icon = 

  762. 		    (JInternalFrame.JDesktopIcon)c;

  763. 		JInternalFrame f = (JInternalFrame)icon.getInternalFrame();

  764. 		if (f.isClosed()) {

  765. 		    framesHaveClosed = true;

  766. 		    break;

  767. 		}

  768. 	    }

  769. 	} 

  770.        	JInternalFrame [] allFrames = dp.getAllFrames();

  771.        	if (framesHaveClosed || allFrames.length != framesCache.size()) {

  772. 	    // Cache frames starting at the lowest layer.

  773. 	    framesCache.clear();

  774. 	    int low = dp.lowestLayer();

  775. 	    int high = dp.highestLayer();

  776. 	    for (int i = high; i >= low; i--) {

  777. 		Component [] comp = dp.getComponentsInLayer(i);

  778. 		if (comp.length > 0) {

  779. 		    for (int j = 0; j < comp.length; j++) {

  780. 			framesCache.addElement(comp[j]);

  781. 		    }

  782. 		}

  783. 	    }

  784.        	}

  785.     }

  786. }