KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > javax > swing > plaf > basic > BasicDesktopPaneUI


1 /*
2  * @(#)BasicDesktopPaneUI.java 1.57 05/10/31
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 JavaDoc;
17 import java.awt.Insets JavaDoc;
18 import java.awt.Graphics JavaDoc;
19 import java.awt.KeyboardFocusManager JavaDoc;
20 import java.awt.*;
21 import java.util.Vector JavaDoc;
22 import sun.swing.DefaultLookup;
23 import sun.swing.UIAction;
24 import sun.awt.AppContext;
25
26 /**
27  * Basic L&F for a desktop.
28  *
29  * @version 1.57 10/31/05
30  * @author Steve Wilson
31  */

32 public class BasicDesktopPaneUI extends DesktopPaneUI {
33     // Old actions forward to an instance of this.
34
private static final Actions SHARED_ACTION = new Actions();
35     private static final Object JavaDoc FRAMES_CACHE_KEY =
36                 new StringBuilder JavaDoc("BASIC_DESKTOP_PANE_UI.FRAMES_CACHE");
37
38     private static Dimension JavaDoc minSize = new Dimension JavaDoc(0,0);
39     private static Dimension JavaDoc maxSize = new Dimension JavaDoc(Integer.MAX_VALUE,
40             Integer.MAX_VALUE);
41     private Handler handler;
42     private PropertyChangeListener pcl;
43
44     protected JDesktopPane desktop;
45     protected DesktopManager desktopManager;
46
47     /**
48      * As of Java 2 platform v1.3 this previously undocumented field is no
49      * longer used.
50      * Key bindings are now defined by the LookAndFeel, please refer to
51      * the key bindings specification for further details.
52      *
53      * @deprecated As of 1.3.
54      */

55     @Deprecated JavaDoc
56     protected KeyStroke minimizeKey;
57     /**
58      * As of Java 2 platform v1.3 this previously undocumented field is no
59      * longer used.
60      * Key bindings are now defined by the LookAndFeel, please refer to
61      * the key bindings specification for further details.
62      *
63      * @deprecated As of 1.3.
64      */

65     @Deprecated JavaDoc
66     protected KeyStroke maximizeKey;
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     @Deprecated JavaDoc
76     protected KeyStroke closeKey;
77     /**
78      * As of Java 2 platform v1.3 this previously undocumented field is no
79      * longer used.
80      * Key bindings are now defined by the LookAndFeel, please refer to
81      * the key bindings specification for further details.
82      *
83      * @deprecated As of 1.3.
84      */

85     @Deprecated JavaDoc
86     protected KeyStroke navigateKey;
87     /**
88      * As of Java 2 platform v1.3 this previously undocumented field is no
89      * longer used.
90      * Key bindings are now defined by the LookAndFeel, please refer to
91      * the key bindings specification for further details.
92      *
93      * @deprecated As of 1.3.
94      */

95     @Deprecated JavaDoc
96     protected KeyStroke navigateKey2;
97
98     public static ComponentUI createUI(JComponent c) {
99         return new BasicDesktopPaneUI JavaDoc();
100     }
101
102     public BasicDesktopPaneUI() {
103     }
104
105     private static Vector JavaDoc getCurrentFramesCache() {
106         synchronized (BasicDesktopPaneUI JavaDoc.class) {
107             AppContext appContext = AppContext.getAppContext();
108             Vector JavaDoc framesCache = (Vector JavaDoc) appContext.get(FRAMES_CACHE_KEY);
109             if(framesCache == null) {
110                 framesCache = new Vector JavaDoc();
111                 appContext.put(FRAMES_CACHE_KEY,framesCache);
112             }
113             return framesCache;
114         }
115     }
116
117     public void installUI(JComponent c) {
118     desktop = (JDesktopPane)c;
119     installDefaults();
120     installDesktopManager();
121         installListeners();
122     installKeyboardActions();
123     }
124
125     public void uninstallUI(JComponent c) {
126     uninstallKeyboardActions();
127         uninstallListeners();
128     uninstallDesktopManager();
129         uninstallDefaults();
130     desktop = null;
131         handler = null;
132     }
133
134     protected void installDefaults() {
135     if (desktop.getBackground() == null ||
136         desktop.getBackground() instanceof UIResource) {
137         desktop.setBackground(UIManager.getColor("Desktop.background"));
138     }
139         LookAndFeel.installProperty(desktop, "opaque", Boolean.TRUE);
140     }
141
142     protected void uninstallDefaults() { }
143
144     /**
145      * Installs the <code>PropertyChangeListener</code> returned from
146      * <code>createPropertyChangeListener</code> on the
147      * <code>JDesktopPane</code>.
148      *
149      * @since 1.5
150      * @see #createPropertyChangeListener
151      */

152     protected void installListeners() {
153         pcl = createPropertyChangeListener();
154         desktop.addPropertyChangeListener(pcl);
155     }
156
157     /**
158      * Uninstalls the <code>PropertyChangeListener</code> returned from
159      * <code>createPropertyChangeListener</code> from the
160      * <code>JDesktopPane</code>.
161      *
162      * @since 1.5
163      * @see #createPropertyChangeListener
164      */

165     protected void uninstallListeners() {
166         desktop.removePropertyChangeListener(pcl);
167         pcl = null;
168     }
169
170     protected void installDesktopManager() {
171         desktopManager = desktop.getDesktopManager();
172     if(desktopManager == null) {
173         desktopManager = new BasicDesktopManager();
174         desktop.setDesktopManager(desktopManager);
175     }
176     }
177
178     protected void uninstallDesktopManager() {
179     if(desktop.getDesktopManager() instanceof UIResource) {
180         desktop.setDesktopManager(null);
181     }
182     desktopManager = null;
183     }
184
185     protected void installKeyboardActions(){
186     InputMap inputMap = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
187     if (inputMap != null) {
188         SwingUtilities.replaceUIInputMap(desktop,
189             JComponent.WHEN_IN_FOCUSED_WINDOW, inputMap);
190     }
191     inputMap = getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
192     if (inputMap != null) {
193         SwingUtilities.replaceUIInputMap(desktop,
194             JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
195             inputMap);
196     }
197
198         LazyActionMap.installLazyActionMap(desktop, BasicDesktopPaneUI JavaDoc.class,
199                 "DesktopPane.actionMap");
200     registerKeyboardActions();
201     }
202
203     protected void registerKeyboardActions(){
204     }
205  
206     protected void unregisterKeyboardActions(){
207     }
208
209     InputMap getInputMap(int condition) {
210     if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {
211         return createInputMap(condition);
212     }
213     else if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
214         return (InputMap)DefaultLookup.get(desktop, this,
215                     "Desktop.ancestorInputMap");
216     }
217     return null;
218     }
219
220     InputMap createInputMap(int condition) {
221     if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {
222         Object JavaDoc[] bindings = (Object JavaDoc[])DefaultLookup.get(desktop,
223                     this, "Desktop.windowBindings");
224
225         if (bindings != null) {
226         return LookAndFeel.makeComponentInputMap(desktop, bindings);
227         }
228     }
229     return null;
230     }
231
232     static void loadActionMap(LazyActionMap JavaDoc map) {
233         map.put(new Actions(Actions.RESTORE));
234         map.put(new Actions(Actions.CLOSE));
235         map.put(new Actions(Actions.MOVE));
236         map.put(new Actions(Actions.RESIZE));
237         map.put(new Actions(Actions.LEFT));
238         map.put(new Actions(Actions.SHRINK_LEFT));
239         map.put(new Actions(Actions.RIGHT));
240         map.put(new Actions(Actions.SHRINK_RIGHT));
241         map.put(new Actions(Actions.UP));
242         map.put(new Actions(Actions.SHRINK_UP));
243         map.put(new Actions(Actions.DOWN));
244         map.put(new Actions(Actions.SHRINK_DOWN));
245         map.put(new Actions(Actions.ESCAPE));
246         map.put(new Actions(Actions.MINIMIZE));
247         map.put(new Actions(Actions.MAXIMIZE));
248         map.put(new Actions(Actions.NEXT_FRAME));
249         map.put(new Actions(Actions.PREVIOUS_FRAME));
250         map.put(new Actions(Actions.NAVIGATE_NEXT));
251         map.put(new Actions(Actions.NAVIGATE_PREVIOUS));
252     }
253
254     protected void uninstallKeyboardActions(){
255       unregisterKeyboardActions();
256       SwingUtilities.replaceUIInputMap(desktop, JComponent.
257                      WHEN_IN_FOCUSED_WINDOW, null);
258       SwingUtilities.replaceUIInputMap(desktop, JComponent.
259                      WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
260       SwingUtilities.replaceUIActionMap(desktop, null);
261     }
262
263     public void paint(Graphics JavaDoc g, JComponent c) {}
264
265     public Dimension JavaDoc getPreferredSize(JComponent c) {return null;}
266
267     public Dimension JavaDoc getMinimumSize(JComponent c) {
268     return minSize;
269     }
270     public Dimension JavaDoc getMaximumSize(JComponent c){
271     return maxSize;
272     }
273
274     /**
275      * Returns the <code>PropertyChangeListener</code> to install on
276      * the <code>JDesktopPane</code>.
277      *
278      * @since 1.5
279      * @return The PropertyChangeListener that will be added to track
280      * changes in the desktop pane.
281      */

282     protected PropertyChangeListener createPropertyChangeListener() {
283         return getHandler();
284     }
285
286     private Handler getHandler() {
287         if (handler == null) {
288             handler = new Handler();
289         }
290         return handler;
291     }
292
293     private class Handler implements PropertyChangeListener {
294         public void propertyChange(PropertyChangeEvent evt) {
295             String JavaDoc propertyName = evt.getPropertyName();
296
297             if ("desktopManager" == propertyName) {
298                 installDesktopManager();
299             }
300         }
301     }
302
303     /**
304      * The default DesktopManager installed by the UI.
305      */

306     private class BasicDesktopManager extends DefaultDesktopManager
307             implements UIResource {
308     }
309
310     private static class Actions extends UIAction {
311         private static String JavaDoc CLOSE = "close";
312         private static String JavaDoc ESCAPE = "escape";
313         private static String JavaDoc MAXIMIZE = "maximize";
314         private static String JavaDoc MINIMIZE = "minimize";
315         private static String JavaDoc MOVE = "move";
316         private static String JavaDoc RESIZE = "resize";
317         private static String JavaDoc RESTORE = "restore";
318         private static String JavaDoc LEFT = "left";
319         private static String JavaDoc RIGHT = "right";
320         private static String JavaDoc UP = "up";
321         private static String JavaDoc DOWN = "down";
322         private static String JavaDoc SHRINK_LEFT = "shrinkLeft";
323         private static String JavaDoc SHRINK_RIGHT = "shrinkRight";
324         private static String JavaDoc SHRINK_UP = "shrinkUp";
325         private static String JavaDoc SHRINK_DOWN = "shrinkDown";
326         private static String JavaDoc NEXT_FRAME = "selectNextFrame";
327         private static String JavaDoc PREVIOUS_FRAME = "selectPreviousFrame";
328         private static String JavaDoc NAVIGATE_NEXT = "navigateNext";
329         private static String JavaDoc NAVIGATE_PREVIOUS = "navigatePrevious";
330         private final int MOVE_RESIZE_INCREMENT = 10;
331         private static boolean moving = false;
332         private static boolean resizing = false;
333         private static JInternalFrame sourceFrame = null;
334         private static Component focusOwner = null;
335
336         Actions() {
337             super(null);
338         }
339
340         Actions(String JavaDoc name) {
341             super(name);
342         }
343
344         public void actionPerformed(ActionEvent e) {
345             JDesktopPane dp = (JDesktopPane)e.getSource();
346             String JavaDoc key = getName();
347
348             if (CLOSE == key || MAXIMIZE == key || MINIMIZE == key ||
349                     RESTORE == key) {
350                 setState(dp, key);
351             }
352             else if (ESCAPE == key) {
353                 if (sourceFrame == dp.getSelectedFrame() &&
354                         focusOwner != null) {
355                     focusOwner.requestFocus();
356                 }
357                 moving = false;
358                 resizing = false;
359                 sourceFrame = null;
360                 focusOwner = null;
361             }
362             else if (MOVE == key || RESIZE == key) {
363                 sourceFrame = dp.getSelectedFrame();
364                 if (sourceFrame == null) {
365                     return;
366                 }
367                 moving = (key == MOVE) ? true : false;
368                 resizing = (key == RESIZE) ? true : false;
369
370                 focusOwner = KeyboardFocusManager.
371                     getCurrentKeyboardFocusManager().getFocusOwner();
372                 if (!SwingUtilities.isDescendingFrom(focusOwner, sourceFrame)) {
373                     focusOwner = null;
374                 }
375                 sourceFrame.requestFocus();
376             }
377             else if (LEFT == key ||
378                      RIGHT == key ||
379                      UP == key ||
380                      DOWN == key ||
381                      SHRINK_RIGHT == key ||
382                      SHRINK_LEFT == key ||
383                      SHRINK_UP == key ||
384                      SHRINK_DOWN == key) {
385                 JInternalFrame c = dp.getSelectedFrame();
386                 if (sourceFrame == null || c != sourceFrame ||
387                         KeyboardFocusManager.
388                             getCurrentKeyboardFocusManager().getFocusOwner() !=
389                                 sourceFrame) {
390                     return;
391                 }
392                 Dimension JavaDoc size = c.getSize();
393                 Dimension JavaDoc minSize = c.getMinimumSize();
394                 Point loc = c.getLocation();
395                 if (LEFT == key) {
396                     if (moving) {
397                         c.setLocation(loc.x - MOVE_RESIZE_INCREMENT, loc.y);
398                     } else if (resizing) {
399                         c.setLocation(loc.x - MOVE_RESIZE_INCREMENT, loc.y);
400                         c.setSize(size.width + MOVE_RESIZE_INCREMENT,
401                                 size.height);
402                     }
403                 } else if (RIGHT == key) {
404                     if (moving) {
405                         c.setLocation(loc.x + MOVE_RESIZE_INCREMENT, loc.y);
406                     } else if (resizing) {
407                         c.setLocation(loc.x, loc.y);
408                         c.setSize(size.width + MOVE_RESIZE_INCREMENT,
409                                 size.height);
410                     }
411                 } else if (UP == key) {
412                     if (moving) {
413                         c.setLocation(loc.x, loc.y - MOVE_RESIZE_INCREMENT);
414                     } else if (resizing) {
415                         c.setLocation(loc.x, loc.y - MOVE_RESIZE_INCREMENT);
416                         c.setSize(size.width,
417                                 size.height + MOVE_RESIZE_INCREMENT);
418                     }
419                 } else if (DOWN == key) {
420                     if (moving) {
421                         c.setLocation(loc.x, loc.y + MOVE_RESIZE_INCREMENT);
422                     } else if (resizing) {
423                         c.setLocation(loc.x, loc.y);
424                         c.setSize(size.width,
425                                 size.height + MOVE_RESIZE_INCREMENT);
426                     }
427                 } else if (SHRINK_LEFT == key && resizing) {
428                     if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {
429                         c.setLocation(loc.x, loc.y);
430                         c.setSize(size.width - MOVE_RESIZE_INCREMENT,
431                                 size.height);
432                     } else {
433                         c.setSize(minSize.width, size.height);
434                     }
435                 } else if (SHRINK_RIGHT == key && resizing) {
436                     if (minSize.width < (size.width - MOVE_RESIZE_INCREMENT)) {
437                         c.setLocation(loc.x + MOVE_RESIZE_INCREMENT, loc.y);
438                         c.setSize(size.width - MOVE_RESIZE_INCREMENT,
439                                 size.height);
440                     } else {
441                         c.setLocation(loc.x - minSize.width + size.width,
442                                 loc.y);
443                         c.setSize(minSize.width, size.height);
444                     }
445                 } else if (SHRINK_UP == key && resizing) {
446                     if (minSize.height <
447                             (size.height - MOVE_RESIZE_INCREMENT)) {
448                         c.setLocation(loc.x, loc.y);
449                         c.setSize(size.width,
450                                 size.height - MOVE_RESIZE_INCREMENT);
451                     } else {
452                         c.setSize(size.width, minSize.height);
453                     }
454                 } else if (SHRINK_DOWN == key && resizing) {
455                     if (minSize.height <
456                             (size.height - MOVE_RESIZE_INCREMENT)) {
457                         c.setLocation(loc.x, loc.y + MOVE_RESIZE_INCREMENT);
458                         c.setSize(size.width,
459                                 size.height - MOVE_RESIZE_INCREMENT);
460                     } else {
461                         c.setLocation(loc.x,
462                                 loc.y - minSize.height + size.height);
463                         c.setSize(size.width, minSize.height);
464                     }
465                 }
466             }
467             else if (NEXT_FRAME == key || PREVIOUS_FRAME == key) {
468                 selectFrame(dp, (key == NEXT_FRAME) ? true : false);
469             }
470             else if (NAVIGATE_NEXT == key ||
471                      NAVIGATE_PREVIOUS == key) {
472                 boolean moveForward = true;
473                 if (NAVIGATE_PREVIOUS == key) {
474                     moveForward = false;
475                 }
476                 Container cycleRoot = dp.getFocusCycleRootAncestor();
477
478                 if (cycleRoot != null) {
479                     FocusTraversalPolicy policy =
480                         cycleRoot.getFocusTraversalPolicy();
481                     if (policy != null && policy instanceof
482                             SortingFocusTraversalPolicy) {
483                         SortingFocusTraversalPolicy sPolicy =
484                             (SortingFocusTraversalPolicy)policy;
485                         boolean idc = sPolicy.getImplicitDownCycleTraversal();
486                         try {
487                             sPolicy.setImplicitDownCycleTraversal(false);
488                             if (moveForward) {
489                                 KeyboardFocusManager.
490                                     getCurrentKeyboardFocusManager().
491                                         focusNextComponent(dp);
492                             } else {
493                                 KeyboardFocusManager.
494                                     getCurrentKeyboardFocusManager().
495                                     focusPreviousComponent(dp);
496                             }
497                         } finally {
498                             sPolicy.setImplicitDownCycleTraversal(idc);
499                         }
500                     }
501                 }
502             }
503         }
504
505         private void selectFrame(JDesktopPane dp, boolean forward) {
506             Vector JavaDoc framesCache = getCurrentFramesCache();
507             if (forward) {
508                 // navigate to the next frame
509
int i = 0;
510                 verifyFramesCache(dp);
511                 if (framesCache.size() == 0) {
512                     return;
513                 }
514
515                 JInternalFrame f = dp.getSelectedFrame();
516
517                 if (f != null) {
518                     i = framesCache.indexOf(f);
519                 }
520                 if (i == -1) {
521                     /* if the frame is not there, its icon may be */
522                     i = framesCache.indexOf(f.getDesktopIcon());
523                     if (i == -1) {
524                         /* error */
525                         return;
526                     }
527                 }
528                 if (++i == framesCache.size()) {
529                     /* wrap */
530                     i = 0;
531                 }
532                 JComponent c = (JComponent) framesCache.elementAt(i);
533                 if (c instanceof JInternalFrame) {
534                     try {
535                         ((JInternalFrame)c).setSelected(true);
536                         dp.getDesktopManager().activateFrame((JInternalFrame)c);
537                     } catch (PropertyVetoException pve) {}
538                 } else {
539                     /* it had better be an icon! */
540                     if (!(c instanceof JInternalFrame.JDesktopIcon)){
541                         /* error */
542                         return;
543                     }
544                     try {
545                         ((JInternalFrame)((JInternalFrame.JDesktopIcon)c).
546                                 getInternalFrame()).setSelected(true);
547                         dp.getDesktopManager().activateFrame(
548                                 ((JInternalFrame.JDesktopIcon)c).
549                                         getInternalFrame());
550                     } catch (PropertyVetoException pve) {}
551                 }
552             } else {
553                 // navigate to the previous internal frame
554
int i = 0;
555                 verifyFramesCache(dp);
556                 if (framesCache.size() == 0) {
557                     return;
558                 }
559                 JInternalFrame f = dp.getSelectedFrame();
560                 if (f != null) {
561                     i = framesCache.indexOf(f);
562                 }
563                 if (i == -1) {
564                     /* if the frame is not there, its icon may be */
565                     i = framesCache.indexOf(f.getDesktopIcon());
566                     if (i == -1) {
567                         /* error */
568                         return;
569                     }
570                 }
571                 if (--i == -1) {
572                     /* wrap */
573                     i = framesCache.size() - 1;
574                 }
575                 JComponent c = (JComponent) framesCache.elementAt(i);
576                 if (c instanceof JInternalFrame) {
577                     try {
578                         ((JInternalFrame)c).setSelected(true);
579                     } catch (PropertyVetoException pve) {}
580                 } else {
581                     /* it had better be an icon! */
582                     if (!(c instanceof JInternalFrame.JDesktopIcon)) {
583                         /* error */
584                         return;
585                     }
586                     try {
587                         ((JInternalFrame)((JInternalFrame.JDesktopIcon)c).
588                                 getInternalFrame()).setSelected(true);
589                     } catch (PropertyVetoException pve) {}
590                 }
591             }
592         }
593
594         private void setState(JDesktopPane dp, String JavaDoc state) {
595             if (state == CLOSE) {
596                 JInternalFrame f = dp.getSelectedFrame();
597                 if (f == null) {
598                     return;
599                 }
600                 f.doDefaultCloseAction();
601             } else if (state == MAXIMIZE) {
602                 // maximize the selected frame
603
JInternalFrame f = dp.getSelectedFrame();
604                 if (f == null) {
605                     return;
606                 }
607                 if (!f.isMaximum()) {
608                     if (f.isIcon()) {
609                         try {
610                             f.setIcon(false);
611                             f.setMaximum(true);
612                         } catch (PropertyVetoException pve) {}
613                     } else {
614                         try {
615                             f.setMaximum(true);
616                         } catch (PropertyVetoException pve) {
617                         }
618                     }
619                 }
620             } else if (state == MINIMIZE) {
621                 // minimize the selected frame
622
JInternalFrame f = dp.getSelectedFrame();
623                 if (f == null) {
624                     return;
625                 }
626                 if (!f.isIcon()) {
627                     try {
628                         f.setIcon(true);
629                     } catch (PropertyVetoException pve) {
630                     }
631                 }
632             } else if (state == RESTORE) {
633                 // restore the selected minimized or maximized frame
634
JInternalFrame f = dp.getSelectedFrame();
635                 if (f == null) {
636                     return;
637                 }
638                 try {
639                     if (f.isIcon()) {
640                         f.setIcon(false);
641                     } else if (f.isMaximum()) {
642                         f.setMaximum(false);
643                     }
644                     f.setSelected(true);
645                 } catch (PropertyVetoException pve) {
646                 }
647             }
648         }
649
650
651         public boolean isEnabled(Object JavaDoc sender) {
652             if (sender instanceof JDesktopPane) {
653                 JDesktopPane dp = (JDesktopPane)sender;
654                 JInternalFrame iFrame = dp.getSelectedFrame();
655                 if (iFrame == null) {
656                     return false;
657                 }
658                 String JavaDoc action = getName();
659                 if (action == Actions.CLOSE) {
660                     return iFrame.isClosable();
661                 } else if (action == Actions.MINIMIZE) {
662                     return iFrame.isIconifiable();
663                 } else if (action == Actions.MAXIMIZE) {
664                     return iFrame.isMaximizable();
665                 }
666                 return true;
667             }
668             return false;
669         }
670     }
671
672
673     /*
674      * Handles restoring a minimized or maximized internal frame.
675      */

676     protected class OpenAction extends AbstractAction {
677     public void actionPerformed(ActionEvent evt) {
678             JDesktopPane dp = (JDesktopPane)evt.getSource();
679             SHARED_ACTION.setState(dp, Actions.RESTORE);
680     }
681
682     public boolean isEnabled() {
683         return true;
684     }
685     }
686
687     /*
688      * Handles closing an internal frame
689      */

690     protected class CloseAction extends AbstractAction {
691     public void actionPerformed(ActionEvent evt) {
692             JDesktopPane dp = (JDesktopPane)evt.getSource();
693             SHARED_ACTION.setState(dp, Actions.CLOSE);
694     }
695
696     public boolean isEnabled() {
697             JInternalFrame iFrame = desktop.getSelectedFrame();
698             if (iFrame != null) {
699                 return iFrame.isClosable();
700             }
701             return false;
702     }
703     }
704
705     /*
706      * Handles minimizing an internal frame
707      */

708     protected class MinimizeAction extends AbstractAction {
709     public void actionPerformed(ActionEvent evt) {
710             JDesktopPane dp = (JDesktopPane)evt.getSource();
711             SHARED_ACTION.setState(dp, Actions.MINIMIZE);
712     }
713
714     public boolean isEnabled() {
715             JInternalFrame iFrame = desktop.getSelectedFrame();
716             if (iFrame != null) {
717             return iFrame.isIconifiable();
718             }
719             return false;
720     }
721     }
722
723     /*
724      * Handles maximizing an internal frame
725      */

726     protected class MaximizeAction extends AbstractAction {
727     public void actionPerformed(ActionEvent evt) {
728             JDesktopPane dp = (JDesktopPane)evt.getSource();
729             SHARED_ACTION.setState(dp, Actions.MAXIMIZE);
730     }
731
732     public boolean isEnabled() {
733             JInternalFrame iFrame = desktop.getSelectedFrame();
734             if (iFrame != null) {
735             return iFrame.isMaximizable();
736             }
737             return false;
738         }
739     }
740
741     /*
742      * Handles navigating to the next internal frame.
743      */

744     protected class NavigateAction extends AbstractAction {
745     public void actionPerformed(ActionEvent evt) {
746             JDesktopPane dp = (JDesktopPane)evt.getSource();
747             SHARED_ACTION.selectFrame(dp, true);
748     }
749
750     public boolean isEnabled() {
751         return true;
752     }
753     }
754
755     private static void verifyFramesCache(JDesktopPane dp) {
756         Vector JavaDoc framesCache = getCurrentFramesCache();
757     // Check whether any internal frames have closed in
758
// which case we have to refresh the frames cache.
759
boolean framesHaveClosed = false;
760     int len = framesCache.size();
761     for (int i = 0; i < len; i++) {
762         JComponent c =
763         (JComponent)framesCache.elementAt(i);
764         if (c instanceof JInternalFrame) {
765         JInternalFrame f = (JInternalFrame)c;
766         if (f.isClosed()) {
767             framesHaveClosed = true;
768             break;
769         }
770         }
771         else if (c instanceof JInternalFrame.JDesktopIcon) {
772         JInternalFrame.JDesktopIcon icon =
773             (JInternalFrame.JDesktopIcon)c;
774         JInternalFrame f = (JInternalFrame)icon.getInternalFrame();
775         if (f.isClosed()) {
776             framesHaveClosed = true;
777             break;
778         }
779         }
780     }
781         JInternalFrame [] allFrames = dp.getAllFrames();
782         if (framesHaveClosed || allFrames.length != framesCache.size()) {
783         // Cache frames starting at the lowest layer.
784
framesCache.clear();
785         int low = dp.lowestLayer();
786         int high = dp.highestLayer();
787         for (int i = high; i >= low; i--) {
788         Component [] comp = dp.getComponentsInLayer(i);
789         if (comp.length > 0) {
790             for (int j = 0; j < comp.length; j++) {
791             framesCache.addElement(comp[j]);
792             }
793         }
794         }
795         }
796     }
797 }
798
Popular Tags