1. /*

  2.  * @(#)SynthDesktopPaneUI.java	1.9 03/01/23

  3.  *

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

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

  6.  */

  7. 

  8. package com.sun.java.swing.plaf.gtk;

  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. 

  23. /**

  24.  * Synth L&F for a desktop.

  25.  *

  26.  * @version 1.9, 01/23/03 (originally from version 1.44 of BasicDesktopPaneUI)

  27.  * @author Joshua Outwater

  28.  * @author Steve Wilson

  29.  */

  30. class SynthDesktopPaneUI extends DesktopPaneUI implements

  31.                   PropertyChangeListener, SynthUI, LazyActionMap.Loader {

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

  33.     private static Dimension maxSize =

  34.         new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);

  35. 

  36.     private SynthStyle style;

  37.     protected JDesktopPane desktop;

  38.     protected DesktopManager desktopManager;

  39. 

  40.     /**

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

  42.      * longer used.

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

  44.      * the key bindings specification for further details.

  45.      *

  46.      * @deprecated As of 1.3.

  47.      */

  48.     protected KeyStroke minimizeKey;

  49.     /**

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

  51.      * longer used.

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

  53.      * the key bindings specification for further details.

  54.      *

  55.      * @deprecated As of 1.3.

  56.      */

  57.     protected KeyStroke maximizeKey;

  58.     /**

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

  60.      * longer used.

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

  62.      * the key bindings specification for further details.

  63.      *

  64.      * @deprecated As of 1.3.

  65.      */

  66.     protected KeyStroke closeKey;

  67.     /**

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

  69.      * longer used.

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

  71.      * the key bindings specification for further details.

  72.      *

  73.      * @deprecated As of 1.3.

  74.      */

  75.     protected KeyStroke navigateKey;

  76.     /**

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

  78.      * longer used.

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

  80.      * the key bindings specification for further details.

  81.      *

  82.      * @deprecated As of 1.3.

  83.      */

  84.     protected KeyStroke navigateKey2;

  85. 

  86.     public static ComponentUI createUI(JComponent c) {

  87.         return new SynthDesktopPaneUI();

  88.     }

  89. 

  90.     public SynthDesktopPaneUI() {

  91.     }

  92. 

  93.     public void installUI(JComponent c)   {

  94.         desktop = (JDesktopPane)c;

  95.         installDefaults();

  96.         installDesktopManager();

  97.         installKeyboardActions();

  98.         installListeners();

  99.     }

  100. 

  101.     public void uninstallUI(JComponent c) {

  102.         uninstallKeyboardActions();

  103.         uninstallDesktopManager();

  104.         uninstallDefaults();

  105.         uninstallListeners();

  106.         desktop = null;

  107.     }

  108. 

  109.     protected void installListeners() {

  110.         desktop.addPropertyChangeListener(this);

  111.     }

  112. 

  113.     protected void installDefaults() {

  114.         fetchStyle(desktop);

  115.     }

  116. 

  117.     private void fetchStyle(JDesktopPane c) {

  118.         SynthContext context = getContext(c, ENABLED);

  119.         style = SynthLookAndFeel.updateStyle(context, this);

  120.         context.dispose();

  121.     }

  122. 

  123.     protected void uninstallListeners() {

  124.         desktop.removePropertyChangeListener(this);

  125.     }

  126. 

  127.     protected void uninstallDefaults() {

  128.         SynthContext context = getContext(desktop, ENABLED);

  129. 

  130.         style.uninstallDefaults(context);

  131.         context.dispose();

  132.         style = null;

  133.     }

  134. 

  135.     protected void installDesktopManager() {

  136.         if(desktop.getDesktopManager() == null) {

  137.             desktopManager = new DefaultDesktopManager();

  138.             desktop.setDesktopManager(desktopManager);

  139.         }

  140.     }

  141. 

  142.     protected void uninstallDesktopManager() {

  143.         if(desktop.getDesktopManager() == desktopManager) {

  144.             desktop.setDesktopManager(null);

  145.         }

  146.         desktopManager = null;

  147.     }

  148. 

  149.     protected void installKeyboardActions(){

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

  151.         if (inputMap != null) {

  152.             SwingUtilities.replaceUIInputMap(desktop,

  153.                 JComponent.WHEN_IN_FOCUSED_WINDOW, inputMap);

  154.         }

  155.         inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  156.         if (inputMap != null) {

  157.             SwingUtilities.replaceUIInputMap(desktop,

  158.                 JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, inputMap);

  159.         }

  160.         LazyActionMap.installLazyActionMap(desktop, this);

  161.         registerKeyboardActions();

  162.     }

  163. 

  164.     protected void registerKeyboardActions(){

  165.     }

  166.  

  167.     protected void unregisterKeyboardActions(){

  168.     }

  169. 

  170.     InputMap getInputMap(int condition) {

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

  172.             return createInputMap(condition);

  173.         }

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

  175.             return (InputMap)UIManager.get("Desktop.ancestorInputMap");

  176.         }

  177.         return null;

  178.     }

  179. 

  180.     InputMap createInputMap(int condition) {

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

  182.             Object[] bindings =

  183.                 (Object[])UIManager.get("Desktop.windowBindings");

  184. 

  185.             if (bindings != null) {

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

  187.             }

  188.         }

  189.         return null;

  190.     }

  191. 

  192. 

  193.     public void loadActionMap(JComponent c, ActionMap map) {

  194.         map.put("restore", new OpenAction());

  195.         map.put("close", new CloseAction());

  196.         map.put("move", new MoveResizeAction("move"));

  197.         map.put("resize", new MoveResizeAction("resize"));

  198.         map.put("left", new MoveResizeAction("left"));

  199.         map.put("shrinkLeft", new MoveResizeAction("shrinkLeft"));

  200.         map.put("right", new MoveResizeAction("right"));

  201.         map.put("shrinkRight", new MoveResizeAction("shrinkRight"));

  202.         map.put("up", new MoveResizeAction("up"));

  203.         map.put("shrinkUp", new MoveResizeAction("shrinkUp"));

  204.         map.put("down", new MoveResizeAction("down"));

  205.         map.put("shrinkDown", new MoveResizeAction("shrinkDown"));

  206.         map.put("escape", new MoveResizeAction("escape"));

  207.         map.put("minimize", new MinimizeAction());

  208.         map.put("maximize", new MaximizeAction());

  209.         map.put("selectNextFrame", new NavigateAction());

  210.         map.put("selectPreviousFrame", new PreviousAction());

  211.         map.put("navigateNext", new NavigateOutAction(true));

  212.         map.put("navigatePrevious", new NavigateOutAction(false));

  213.     }

  214. 

  215.     protected void uninstallKeyboardActions() {

  216.       unregisterKeyboardActions();

  217.       SwingUtilities.replaceUIInputMap(

  218.           desktop, JComponent.WHEN_IN_FOCUSED_WINDOW, null);

  219.       SwingUtilities.replaceUIInputMap(

  220.             desktop, JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);

  221.       SwingUtilities.replaceUIActionMap(desktop, null);

  222.     }

  223. 

  224.     public SynthContext getContext(JComponent c) {

  225.         return getContext(c, getComponentState(c));

  226.     }

  227. 

  228.     private SynthContext getContext(JComponent c, int state) {

  229.         return SynthContext.getContext(SynthContext.class, c,

  230.                      SynthLookAndFeel.getRegion(c), style, state);

  231.     }

  232. 

  233.     private Region getRegion(JComponent c) {

  234.         return SynthLookAndFeel.getRegion(c);

  235.     }

  236. 

  237.     private int getComponentState(JComponent c) {

  238.         return SynthLookAndFeel.getComponentState(c);

  239.     }

  240. 

  241.     public void update(Graphics g, JComponent c) {

  242.         SynthContext context = getContext(c);

  243. 

  244.         SynthLookAndFeel.update(context, g);

  245.         paint(context, g);

  246.         context.dispose();

  247.     }

  248. 

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

  250.         SynthContext context = getContext(c);

  251. 

  252.         paint(context, g);

  253.         context.dispose();

  254.     }

  255. 

  256.     protected void paint(SynthContext context, Graphics g) {

  257.     }

  258. 

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

  260. 

  261.     public Dimension getMinimumSize(JComponent c) {

  262.         return minSize;

  263.     }

  264.     public Dimension getMaximumSize(JComponent c){

  265.         return maxSize;

  266.     }

  267. 

  268. 

  269.     public void propertyChange(PropertyChangeEvent evt) {

  270.         if (SynthLookAndFeel.shouldUpdateStyle(evt)) {

  271.             fetchStyle((JDesktopPane)evt.getSource());

  272.         }

  273.     }

  274. 

  275.     /*

  276.      * Key binding for accessibility -----------------

  277.      */

  278.     private static Vector framesCache;

  279.     private boolean moving = false;

  280.     private boolean resizing = false;

  281.     private final int MOVE_RESIZE_INCREMENT = 10;

  282. 

  283.     /*

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

  285.      */

  286.     protected class OpenAction extends AbstractAction {

  287.         public void actionPerformed(ActionEvent e) {

  288.             // restore the selected minimized or maximized frame

  289.             JInternalFrame f = desktop.getSelectedFrame();

  290.             if (f == null) return;

  291.                 try {

  292.                     if (f.isIcon()) {

  293.                         f.setIcon(false);

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

  295.                         f.setMaximum(false);

  296.                     }

  297.                     f.setSelected(true);

  298.                 } catch (PropertyVetoException pve) {

  299.                 }

  300.         }

  301. 

  302.         public boolean isEnabled() { 

  303.             return true;

  304.         }

  305.     }

  306. 

  307.     /*

  308.      * Handles closing an internal frame

  309.      */

  310.     protected class CloseAction extends AbstractAction {

  311.         public void actionPerformed(ActionEvent e) {

  312.             JInternalFrame f = desktop.getSelectedFrame();

  313.             if (f == null) {

  314.                 return;

  315.             }

  316.             if (f.isClosable()) {

  317.                 try {

  318.                     f.setClosed(true);

  319.                 } catch (PropertyVetoException pve) {

  320.                 }

  321.             }

  322.         }

  323. 

  324.         public boolean isEnabled() { 

  325.             return true;

  326.         }

  327.     }

  328. 

  329.     /*

  330.      * Handles moving and resizing an internal frame

  331.      */

  332.     private class MoveResizeAction extends AbstractAction {

  333.         private String command;

  334.         

  335.         public MoveResizeAction(String command) {

  336.             this.command = command;

  337.         }

  338.     

  339.         public void actionPerformed(ActionEvent e) {

  340.             JInternalFrame c = desktop.getSelectedFrame(); 

  341.             if (c == null) {

  342.                 return;

  343.             }

  344.             if ("move".equals(command)) {

  345.                 moving = true;

  346.                 resizing = false;

  347.                 return;

  348.             } else if ("resize".equals(command)) {

  349.                 moving = false;

  350.                 resizing = true;

  351.                 return;

  352.             } else if ("escape".equals(command)) {

  353.                 moving = resizing = false;

  354.                 return;

  355.             }

  356.             if (!moving && !resizing) {

  357.                 return;

  358.             }

  359.     

  360.             Dimension size = c.getSize();

  361.             Dimension minSize = c.getMinimumSize();

  362.             Point loc = c.getLocation();

  363.     

  364.             if ("left".equals(command)) {

  365.                 if (moving) {

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

  367.                 } else if (resizing) {

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

  369.                     c.setSize(size.width + MOVE_RESIZE_INCREMENT, size.height);

  370.                 }

  371.             } else if ("right".equals(command)) {

  372.                 if (moving) {

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

  374.                 } else if (resizing) {

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

  376.                     c.setSize(size.width + MOVE_RESIZE_INCREMENT, size.height);

  377.                 }

  378.             } else if ("up".equals(command)) {

  379.                 if (moving) {

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

  381.                 } else if (resizing) {

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

  383.                     c.setSize(size.width, size.height + MOVE_RESIZE_INCREMENT);

  384.                 }

  385.             } else if ("down".equals(command)) {

  386.                 if (moving) {

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

  388.                 } else if (resizing) {

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

  390.                     c.setSize(size.width, size.height + MOVE_RESIZE_INCREMENT);

  391.                 }

  392.             } else if ("shrinkLeft".equals(command) && resizing) {

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

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

  395.                     c.setSize(size.width - MOVE_RESIZE_INCREMENT, size.height);

  396.                 } else {

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

  398.                 }

  399.             } else if ("shrinkRight".equals(command) && resizing) {

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

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

  402.                     c.setSize(size.width - MOVE_RESIZE_INCREMENT, size.height);

  403.                 } else {

  404.                     c.setLocation(loc.x - minSize.width + size.width , loc.y);

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

  406.                 }

  407.             } else if ("shrinkUp".equals(command) && resizing) {

  408.                 if (minSize.height < (size.height - MOVE_RESIZE_INCREMENT)) {

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

  410.                     c.setSize(size.width, size.height - MOVE_RESIZE_INCREMENT);

  411.                 } else {

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

  413.                 }

  414.             } else if ("shrinkDown".equals(command) && resizing) {

  415.                 if (minSize.height < (size.height - MOVE_RESIZE_INCREMENT)) {

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

  417.                     c.setSize(size.width, size.height - MOVE_RESIZE_INCREMENT);

  418.                 } else {

  419.                     c.setLocation(loc.x, loc.y - minSize.height + size.height);

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

  421.                 }

  422.             }

  423.         }

  424. 

  425.         public boolean isEnabled() { 

  426.             return true;

  427.         }

  428.     }

  429. 

  430.     /*

  431.      * Handles minimizing an internal frame

  432.      */

  433.     protected class MinimizeAction extends AbstractAction {

  434.         public void actionPerformed(ActionEvent e) {

  435.             // minimize the selected frame

  436.             JInternalFrame f = desktop.getSelectedFrame();

  437.             if (f == null) {

  438.                 return;

  439.             }

  440.             if (f.isIconifiable() && ! f.isIcon()) {

  441.                 try {

  442.                     f.setIcon(true);

  443.                 } catch (PropertyVetoException pve) {

  444.                 }

  445.             }

  446.         }

  447.     

  448.         public boolean isEnabled() {

  449.             return true;

  450.         }

  451.     }

  452. 

  453.     /*

  454.      * Handles maximizing an internal frame

  455.      */

  456.     protected class MaximizeAction extends AbstractAction {

  457.         public void actionPerformed(ActionEvent e) {

  458.             // maximize the selected frame

  459.             JInternalFrame f = desktop.getSelectedFrame();

  460.             if (f == null) {

  461.                 return;

  462.             }

  463.             if (f.isMaximizable() && !f.isMaximum()) {

  464.                 if (f.isIcon()) {

  465.                     try {

  466.                        f.setIcon(false);

  467.                        f.setMaximum(true);

  468.                     } catch (PropertyVetoException pve) {}

  469.                 } else

  470.                     try {

  471.                         f.setMaximum(true);

  472.                     } catch (PropertyVetoException pve) {

  473.                 }

  474.             }

  475.         }

  476.     

  477.         public boolean isEnabled() { 

  478.             return true;

  479.         }

  480.     }

  481. 

  482.     /*

  483.      * Handles navigating to the next internal frame. 

  484.      */

  485.     protected class NavigateAction extends AbstractAction {

  486.         public void actionPerformed(ActionEvent e) {

  487.             // navigate to the next frame

  488.             int i = 0;

  489.             verifyFramesCache();

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

  491.                 return;

  492.             }

  493.             JInternalFrame f = desktop.getSelectedFrame();

  494.             if (f != null) {

  495.                 i = framesCache.indexOf(f);

  496.             }

  497.             if (i == -1) {

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

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

  500.                 if (i == -1) {

  501.                     return; /* error */

  502.                 }

  503.             }

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

  505.                 i = 0; /* wrap */

  506.             }

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

  508.             if (c instanceof JInternalFrame) {

  509.                 try {

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

  511.                     desktopManager.activateFrame((JInternalFrame) c);

  512.                 }

  513.                 catch (PropertyVetoException pve) {}

  514.             } else {

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

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

  517.                     /* error */

  518.                     return;

  519.                 }

  520.                 try {

  521.                     ((JInternalFrame)((JInternalFrame.JDesktopIcon)c).

  522.                         getInternalFrame()).setSelected(true);

  523.                     desktopManager.activateFrame(

  524.                         ((JInternalFrame.JDesktopIcon) c).getInternalFrame());

  525.                 } catch (PropertyVetoException pve) {}

  526.             }

  527.         }

  528. 

  529.         public boolean isEnabled() { 

  530.             return true;

  531.         }

  532.     }

  533. 

  534.     /*

  535.      * Handles navigating to the previous internal frame. 

  536.      */

  537.     private class PreviousAction extends AbstractAction {

  538.     public void actionPerformed(ActionEvent e) {

  539.         // navigate to the previous internal frame

  540.             int i = 0;

  541.         verifyFramesCache();

  542.         if (framesCache.size() == 0) return;

  543.         JInternalFrame f = desktop.getSelectedFrame();

  544.         if (f != null) i = framesCache.indexOf(f);

  545.         if (i == -1) {

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

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

  548.           if (i == -1) {

  549.         /* error */ return;

  550.           }

  551.         }

  552.         if (--i == -1) /* wrap */ i = framesCache.size() - 1;

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

  554.         if (c instanceof JInternalFrame) {

  555.           try {

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

  557.           }

  558.           catch (PropertyVetoException pve) {}

  559.         } else {

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

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

  562.         /* error */

  563.         return;

  564.           }

  565.           try {

  566.         ((JInternalFrame)((JInternalFrame.JDesktopIcon) c).getInternalFrame()).setSelected(true);

  567.           }

  568.           catch (PropertyVetoException pve) {}

  569.         }

  570.     }

  571.     public boolean isEnabled() { 

  572.         return true;

  573.     }

  574.     }

  575. 

  576.     /**

  577.      * Handles navigating to the component before or after the desktop.

  578.      */

  579.     private class NavigateOutAction extends AbstractAction {

  580.         private boolean moveForward;

  581. 

  582.         public NavigateOutAction(boolean moveForward) {

  583.             this.moveForward = moveForward;

  584.         }

  585. 

  586.         public void actionPerformed(ActionEvent e) {

  587.             Container cycleRoot = desktop.getFocusCycleRootAncestor();

  588. 

  589.             if (cycleRoot != null) {

  590.                 FocusTraversalPolicy policy =

  591.                         cycleRoot.getFocusTraversalPolicy();

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

  593.                         SortingFocusTraversalPolicy) {

  594.                     SortingFocusTraversalPolicy sPolicy =

  595.                             (SortingFocusTraversalPolicy)policy;

  596.                     boolean idc = sPolicy.getImplicitDownCycleTraversal();

  597.                     try {

  598.                         sPolicy.setImplicitDownCycleTraversal(false);

  599.                         if (moveForward) {

  600.                             KeyboardFocusManager.

  601.                                 getCurrentKeyboardFocusManager().

  602.                                 focusNextComponent(desktop);

  603.                         } else {

  604.                             KeyboardFocusManager.

  605.                                 getCurrentKeyboardFocusManager().

  606.                                 focusPreviousComponent(desktop);

  607.                         }

  608.                     } finally {

  609.                         sPolicy.setImplicitDownCycleTraversal(idc);

  610.                     }

  611.                 }

  612.             }

  613.         }

  614. 

  615.         public boolean isEnabled() {

  616.             return true;

  617.         }

  618.     }

  619. 

  620.     /*

  621.      * Verifies the internal frames cache is up to date.

  622.      */

  623.     private void verifyFramesCache() {

  624. 

  625.     // Need to initialize?

  626.     if (framesCache == null) {

  627.         framesCache = new Vector();

  628.     }

  629. 

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

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

  632.            boolean framesHaveClosed = false;

  633.     int len = framesCache.size();

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

  635.         JComponent c = 

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

  637.         if (c instanceof JInternalFrame) {

  638.         JInternalFrame f = (JInternalFrame)c;

  639.         if (f.isClosed()) {

  640.             framesHaveClosed = true;

  641.             break;

  642.         }

  643.         }

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

  645.         JInternalFrame.JDesktopIcon icon = 

  646.             (JInternalFrame.JDesktopIcon)c;

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

  648.         if (f.isClosed()) {

  649.             framesHaveClosed = true;

  650.             break;

  651.         }

  652.         }

  653.     } 

  654.            JInternalFrame [] allFrames = desktop.getAllFrames();

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

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

  657.         framesCache.clear();

  658.         int low = desktop.lowestLayer();

  659.         int high = desktop.highestLayer();

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

  661.         Component [] comp = desktop.getComponentsInLayer(i);

  662.         if (comp.length > 0) {

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

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

  665.             }

  666.         }

  667.         }

  668.            }

  669.     }

  670.     // End of accessibility keybindings

  671. }

  672.