BasicMenuUI


1   /*
2    * @(#)BasicMenuUI.java 1.158 04/02/26
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 sun.swing.DefaultLookup;
11  import sun.swing.UIAction;
12  import java.awt.*;
13  import java.awt.event.*;
14  import java.beans.*;
15  import javax.swing.*;
16  import javax.swing.event.*;
17  import javax.swing.plaf.*;
18  import javax.swing.border.*;
19  import java.util.Arrays  ;
20  import java.util.ArrayList  ;
21  
22  
23  /**
24   * A default L&F implementation of MenuUI.  This implementation 
25   * is a "combined" view/controller.
26   *
27   * @version 1.158 02/26/04
28   * @author Georges Saab
29   * @author David Karlton
30   * @author Arnaud Weber
31   */
32  public class BasicMenuUI extends BasicMenuItemUI   
33  {
34      protected ChangeListener         changeListener;
35      protected PropertyChangeListener propertyChangeListener;
36      protected MenuListener           menuListener;
37  
38      private int lastMnemonic = 0;
39  
40      /** Uses as the parent of the windowInputMap when selected. */
41      private InputMap selectedWindowInputMap;
42  
43      /* diagnostic aids -- should be false for production builds. */
44      private static final boolean TRACE =   false; // trace creates and disposes
45      private static final boolean VERBOSE = false; // show reuse hits/misses
46      private static final boolean DEBUG =   false;  // show bad params, misc.
47  
48      private static boolean crossMenuMnemonic = true;
49  
50      public static ComponentUI createUI(JComponent x) {
51      return new BasicMenuUI  ();
52      }
53  
54      static void loadActionMap(LazyActionMap   map) {
55          BasicMenuItemUI.loadActionMap(map);
56          map.put(new Actions(Actions.SELECT, null, true));
57      }
58  
59  
60      protected void installDefaults() {
61      super.installDefaults();
62      updateDefaultBackgroundColor();
63      ((JMenu)menuItem).setDelay(200);
64          crossMenuMnemonic = UIManager.getBoolean("Menu.crossMenuMnemonic");
65      }
66  
67      protected String   getPropertyPrefix() {
68      return "Menu";
69      }
70  
71      protected void installListeners() {
72      super.installListeners();
73  
74      if (changeListener == null)
75          changeListener = createChangeListener(menuItem);
76  
77      if (changeListener != null)
78          menuItem.addChangeListener(changeListener);
79  
80      if (propertyChangeListener == null)
81          propertyChangeListener = createPropertyChangeListener(menuItem);
82  
83      if (propertyChangeListener != null)
84          menuItem.addPropertyChangeListener(propertyChangeListener);
85          
86      if (menuListener == null)
87          menuListener = createMenuListener(menuItem);
88  
89      if (menuListener != null)
90          ((JMenu)menuItem).addMenuListener(menuListener);
91      }
92  
93      protected void installKeyboardActions() {
94      super.installKeyboardActions();
95      updateMnemonicBinding();
96      }
97  
98      void installLazyActionMap() {
99          LazyActionMap.installLazyActionMap(menuItem, BasicMenuUI  .class,
100                                            getPropertyPrefix() + ".actionMap");
101     }
102 
103     void updateMnemonicBinding() {
104     int mnemonic = menuItem.getModel().getMnemonic();
105         int[] shortcutKeys = (int[])DefaultLookup.get(menuItem, this,
106                                                    "Menu.shortcutKeys");
107         if (shortcutKeys == null) {
108             shortcutKeys = new int[] {KeyEvent.ALT_MASK};
109         }
110     if (mnemonic == lastMnemonic) {
111         return;
112     }
113         InputMap windowInputMap = SwingUtilities.getUIInputMap(
114                        menuItem, JComponent.WHEN_IN_FOCUSED_WINDOW);
115     if (lastMnemonic != 0 && windowInputMap != null) {
116             for (int i=0; i<shortcutKeys.length; i++) {
117                 windowInputMap.remove(KeyStroke.getKeyStroke
118                                       (lastMnemonic, shortcutKeys[i], false));
119             }
120     }
121     if (mnemonic != 0) {
122         if (windowInputMap == null) {
123         windowInputMap = createInputMap(JComponent.
124                           WHEN_IN_FOCUSED_WINDOW);
125         SwingUtilities.replaceUIInputMap(menuItem, JComponent.
126                        WHEN_IN_FOCUSED_WINDOW, windowInputMap);
127         }
128             for (int i=0; i<shortcutKeys.length; i++) {
129                 windowInputMap.put(KeyStroke.getKeyStroke(mnemonic,
130                                          shortcutKeys[i], false),
131                                    "selectMenu");
132             }
133         }
134     lastMnemonic = mnemonic;
135     }
136 
137     protected void uninstallKeyboardActions() {
138     super.uninstallKeyboardActions();
139         lastMnemonic = 0;
140     }
141 
142     protected MouseInputListener createMouseInputListener(JComponent c) {
143     return getHandler();
144     }
145 
146     protected MenuListener createMenuListener(JComponent c) {
147     return null;
148     }
149 
150     protected ChangeListener createChangeListener(JComponent c) {
151     return null;
152     }
153 
154     protected PropertyChangeListener createPropertyChangeListener(JComponent c) {
155         return getHandler();
156     }
157 
158     BasicMenuItemUI.Handler   getHandler() {
159         if (handler == null) {
160             handler = new Handler();
161         }
162         return handler;
163     }
164 
165     protected void uninstallDefaults() {
166     menuItem.setArmed(false);
167     menuItem.setSelected(false);
168     menuItem.resetKeyboardActions();
169     super.uninstallDefaults();
170     }
171 
172     protected void uninstallListeners() {
173     super.uninstallListeners();
174 
175     if (changeListener != null)
176         menuItem.removeChangeListener(changeListener);
177 
178     if (propertyChangeListener != null)
179         menuItem.removePropertyChangeListener(propertyChangeListener);
180 
181     if (menuListener != null)
182         ((JMenu)menuItem).removeMenuListener(menuListener);
183 
184     changeListener = null;
185     propertyChangeListener = null;
186     menuListener = null;
187         handler = null;
188     }
189 
190     protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {
191     return getHandler();
192     }
193     
194     protected MenuKeyListener createMenuKeyListener(JComponent c) {
195     return (MenuKeyListener)getHandler();
196     }
197 
198     public Dimension getMaximumSize(JComponent c) {
199     if (((JMenu)menuItem).isTopLevelMenu() == true) {
200         Dimension d = c.getPreferredSize();
201         return new Dimension(d.width, Short.MAX_VALUE);
202     }
203         return null;
204     }
205 
206     protected void setupPostTimer(JMenu menu) {
207         Timer timer = new Timer(menu.getDelay(), new Actions(
208                                     Actions.SELECT, menu,false));
209         timer.setRepeats(false);
210         timer.start();
211     }
212 
213     private static void appendPath(MenuElement[] path, MenuElement elem) {
214         MenuElement newPath[] = new MenuElement[path.length+1];
215         System.arraycopy(path, 0, newPath, 0, path.length);
216         newPath[path.length] = elem;
217         MenuSelectionManager.defaultManager().setSelectedPath(newPath);
218     }
219 
220     private static class Actions extends UIAction {
221         private static final String   SELECT = "selectMenu";
222 
223         // NOTE: This will be null if the action is registered in the
224         // ActionMap. For the timer use it will be non-null.
225     private JMenu menu;
226         private boolean force=false;
227 
228         Actions(String   key, JMenu menu, boolean shouldForce) {
229             super(key);
230         this.menu = menu;
231             this.force = shouldForce;
232     }
233     
234         private JMenu getMenu(ActionEvent e) {
235             if (e.getSource() instanceof JMenu) {
236                 return (JMenu)e.getSource();
237             }
238             return menu;
239         }
240 
241     public void actionPerformed(ActionEvent e) {
242             JMenu menu = getMenu(e);
243             if (!crossMenuMnemonic) {
244                 JPopupMenu pm = BasicPopupMenuUI.getLastPopup();
245                 if (pm != null && pm != menu.getParent()) {
246                     return;
247                 }
248             }
249 
250         final MenuSelectionManager defaultManager = MenuSelectionManager.defaultManager();
251             if(force) {
252                 Container cnt = menu.getParent();
253                 if(cnt != null && cnt instanceof JMenuBar) {
254                     MenuElement me[];
255                     MenuElement subElements[];
256             
257                     subElements = menu.getPopupMenu().getSubElements();
258                     if(subElements.length > 0) {
259                         me = new MenuElement[4];
260                         me[0] = (MenuElement) cnt;
261                         me[1] = (MenuElement) menu;
262                         me[2] = (MenuElement) menu.getPopupMenu();
263                         me[3] = subElements[0];
264                     } else {
265                         me = new MenuElement[3];
266                         me[0] = (MenuElement)cnt;
267                         me[1] = menu;
268                         me[2] = (MenuElement) menu.getPopupMenu();
269                     }
270                     defaultManager.setSelectedPath(me);
271         }
272             } else {
273                 MenuElement path[] = defaultManager.getSelectedPath();
274                 if(path.length > 0 && path[path.length-1] == menu) {
275                     appendPath(path, menu.getPopupMenu());
276                 }
277             }
278         }
279 
280     public boolean isEnabled(Object   c) {
281             if (c instanceof JMenu) {
282                 return ((JMenu)c).isEnabled();
283             }
284             return true;
285     }
286     }
287 
288     /*
289      * Set the background color depending on whether this is a toplevel menu
290      * in a menubar or a submenu of another menu.
291      */
292     private void updateDefaultBackgroundColor() {
293     if (!UIManager.getBoolean("Menu.useMenuBarBackgroundForTopLevel")) {
294        return;
295     }
296     JMenu menu = (JMenu)menuItem;
297     if (menu.getBackground() instanceof UIResource) {
298         if (menu.isTopLevelMenu()) {
299         menu.setBackground(UIManager.getColor("MenuBar.background"));
300         } else {
301         menu.setBackground(UIManager.getColor(getPropertyPrefix() + ".background"));
302         }
303     }           
304     }
305 
306     /**
307      * Instantiated and used by a menu item to handle the current menu selection
308      * from mouse events. A MouseInputHandler processes and forwards all mouse events
309      * to a shared instance of the MenuSelectionManager. 
310      * <p>
311      * This class is protected so that it can be subclassed by other look and
312      * feels to implement their own mouse handling behavior. All overridden
313      * methods should call the parent methods so that the menu selection
314      * is correct.
315      *
316      * @see javax.swing.MenuSelectionManager
317      * @since 1.4
318      */
319     protected class MouseInputHandler implements MouseInputListener {
320         // NOTE: This class exists only for backward compatability. All
321         // its functionality has been moved into Handler. If you need to add
322         // new functionality add it to the Handler, but make sure this
323         // class calls into the Handler.
324 
325     public void mouseClicked(MouseEvent e) {
326             getHandler().mouseClicked(e);
327         }
328 
329     /**
330      * Invoked when the mouse has been clicked on the menu. This
331      * method clears or sets the selection path of the
332      * MenuSelectionManager.
333      * 
334      * @param e the mouse event
335      */
336         public void mousePressed(MouseEvent e) {
337             getHandler().mousePressed(e);
338         }
339 
340     /**
341      * Invoked when the mouse has been released on the menu. Delegates the 
342      * mouse event to the MenuSelectionManager.
343      *
344      * @param e the mouse event
345      */
346     public void mouseReleased(MouseEvent e) {
347             getHandler().mouseReleased(e);
348     }
349 
350     /**
351      * Invoked when the cursor enters the menu. This method sets the selected
352      * path for the MenuSelectionManager and handles the case
353      * in which a menu item is used to pop up an additional menu, as in a 
354      * hierarchical menu system.
355      * 
356      * @param e the mouse event; not used
357      */ 
358     public void mouseEntered(MouseEvent e) {
359             getHandler().mouseEntered(e);
360     }
361     public void mouseExited(MouseEvent e) {
362             getHandler().mouseExited(e);
363     }
364     
365     /**
366      * Invoked when a mouse button is pressed on the menu and then dragged.
367      * Delegates the mouse event to the MenuSelectionManager.
368      *
369      * @param e the mouse event
370      * @see java.awt.event.MouseMotionListener#mouseDragged
371      */
372     public void mouseDragged(MouseEvent e) {
373             getHandler().mouseDragged(e);
374     }
375 
376     public void mouseMoved(MouseEvent e) {
377             getHandler().mouseMoved(e);
378     }
379     }
380 
381     /**
382      * As of Java 2 platform 1.4, this previously undocumented class
383      * is now obsolete. KeyBindings are now managed by the popup menu.
384      */
385     public class ChangeHandler implements ChangeListener {
386         public JMenu    menu;
387     public BasicMenuUI   ui;
388         public boolean  isSelected = false;
389         public Component wasFocused;
390 
391         public ChangeHandler(JMenu m, BasicMenuUI   ui) {
392             menu = m;
393             this.ui = ui;
394         }
395 
396         public void stateChanged(ChangeEvent e) { }
397     }
398 
399     private class Handler extends BasicMenuItemUI.Handler   implements
400             MenuKeyListener {
401         //
402         // PropertyChangeListener
403         //
404         public void propertyChange(PropertyChangeEvent e) {
405         if (e.getPropertyName() == AbstractButton.
406                              MNEMONIC_CHANGED_PROPERTY) {
407                 updateMnemonicBinding();
408         }
409             else {
410         if (e.getPropertyName().equals("ancestor")) {
411             updateDefaultBackgroundColor();
412             }
413                 super.propertyChange(e);
414             }
415     }
416 
417         //
418         // MouseInputListener
419         //
420     public void mouseClicked(MouseEvent e) {
421         }
422 
423     /**
424      * Invoked when the mouse has been clicked on the menu. This
425      * method clears or sets the selection path of the
426      * MenuSelectionManager.
427      * 
428      * @param e the mouse event
429      */
430         public void mousePressed(MouseEvent e) {
431         JMenu menu = (JMenu)menuItem;
432         if (!menu.isEnabled())
433         return;
434 
435         MenuSelectionManager manager = 
436         MenuSelectionManager.defaultManager();
437             if(menu.isTopLevelMenu()) {
438         if(menu.isSelected()) {
439             manager.clearSelectedPath();
440         } else {
441             Container cnt = menu.getParent();
442             if(cnt != null && cnt instanceof JMenuBar) {
443             MenuElement me[] = new MenuElement[2];
444             me[0]=(MenuElement)cnt;
445             me[1]=menu;
446             manager.setSelectedPath(me);
447             }
448         }
449         }
450 
451             MenuElement selectedPath[] = manager.getSelectedPath();
452             if (selectedPath.length > 0 && 
453                 selectedPath[selectedPath.length-1] != menu.getPopupMenu()) {
454 
455         if(menu.isTopLevelMenu() || 
456            menu.getDelay() == 0) {
457                     appendPath(selectedPath, menu.getPopupMenu());
458         } else {
459             setupPostTimer(menu);
460         }
461             }
462         }
463 
464     /**
465      * Invoked when the mouse has been released on the menu. Delegates the 
466      * mouse event to the MenuSelectionManager.
467      *
468      * @param e the mouse event
469      */
470     public void mouseReleased(MouseEvent e) {
471         JMenu menu = (JMenu)menuItem;
472         if (!menu.isEnabled())
473         return;
474         MenuSelectionManager manager = 
475         MenuSelectionManager.defaultManager();
476         manager.processMouseEvent(e);
477         if (!e.isConsumed())
478         manager.clearSelectedPath();        
479     }
480 
481     /**
482      * Invoked when the cursor enters the menu. This method sets the selected
483      * path for the MenuSelectionManager and handles the case
484      * in which a menu item is used to pop up an additional menu, as in a 
485      * hierarchical menu system.
486      * 
487      * @param e the mouse event; not used
488      */ 
489     public void mouseEntered(MouseEvent e) {
490         JMenu menu = (JMenu)menuItem;
491         if (!menu.isEnabled())
492         return;
493 
494         MenuSelectionManager manager = 
495         MenuSelectionManager.defaultManager();
496         MenuElement selectedPath[] = manager.getSelectedPath();     
497         if (!menu.isTopLevelMenu()) {
498         if(!(selectedPath.length > 0 && 
499              selectedPath[selectedPath.length-1] == 
500              menu.getPopupMenu())) {
501             if(menu.getDelay() == 0) {
502                         appendPath(getPath(), menu.getPopupMenu());
503                     } else {
504             manager.setSelectedPath(getPath());
505             setupPostTimer(menu);
506             }
507         }
508         } else {
509         if(selectedPath.length > 0 &&
510            selectedPath[0] == menu.getParent()) {
511             MenuElement newPath[] = new MenuElement[3];
512             // A top level menu's parent is by definition 
513             // a JMenuBar
514             newPath[0] = (MenuElement)menu.getParent();
515             newPath[1] = menu;
516             newPath[2] = menu.getPopupMenu();
517             manager.setSelectedPath(newPath);
518         }
519         }
520     }
521     public void mouseExited(MouseEvent e) {
522     }
523     
524     /**
525      * Invoked when a mouse button is pressed on the menu and then dragged.
526      * Delegates the mouse event to the MenuSelectionManager.
527      *
528      * @param e the mouse event
529      * @see java.awt.event.MouseMotionListener#mouseDragged
530      */
531     public void mouseDragged(MouseEvent e) {
532         JMenu menu = (JMenu)menuItem;
533         if (!menu.isEnabled())
534         return;
535         MenuSelectionManager.defaultManager().processMouseEvent(e);
536     }
537     public void mouseMoved(MouseEvent e) {
538     }
539 
540 
541         //
542         // MenuDragHandler
543         //
544     public void menuDragMouseEntered(MenuDragMouseEvent e) {}
545     public void menuDragMouseDragged(MenuDragMouseEvent e) {
546         if (menuItem.isEnabled() == false)
547         return;
548         
549         MenuSelectionManager manager = e.getMenuSelectionManager();
550         MenuElement path[] = e.getPath();
551         
552         Point p = e.getPoint();
553         if(p.x >= 0 && p.x < menuItem.getWidth() &&
554            p.y >= 0 && p.y < menuItem.getHeight()) {
555         JMenu menu = (JMenu)menuItem;
556         MenuElement selectedPath[] = manager.getSelectedPath();
557         if(!(selectedPath.length > 0 && 
558              selectedPath[selectedPath.length-1] == 
559              menu.getPopupMenu())) {
560             if(menu.isTopLevelMenu() || 
561                menu.getDelay() == 0  ||
562                e.getID() == MouseEvent.MOUSE_DRAGGED) {
563                         appendPath(path, menu.getPopupMenu());
564             } else {
565             manager.setSelectedPath(path);
566             setupPostTimer(menu);
567             }
568         }
569         } else if(e.getID() == MouseEvent.MOUSE_RELEASED) {
570         Component comp = manager.componentForPoint(e.getComponent(), e.getPoint());
571         if (comp == null)
572             manager.clearSelectedPath();
573         }
574         
575     }
576     public void menuDragMouseExited(MenuDragMouseEvent e) {}
577     public void menuDragMouseReleased(MenuDragMouseEvent e) {}      
578 
579 
580         //
581         // MenuKeyListener
582         //
583     /**
584      * Open the Menu
585      */
586     public void menuKeyTyped(MenuKeyEvent e) {
587             if (!crossMenuMnemonic && BasicPopupMenuUI.getLastPopup() != null) {
588                 // when crossMenuMnemonic is not set, we don't open a toplevel
589                 // menu if another toplevel menu is already open
590                     return;
591                 }
592 
593             char key = Character.toLowerCase((char)menuItem.getMnemonic());
594             MenuElement path[] = e.getPath();
595             if (key == Character.toLowerCase(e.getKeyChar())) {
596                 JPopupMenu popupMenu = ((JMenu)menuItem).getPopupMenu();
597                 ArrayList   newList = new ArrayList  (Arrays.asList(path));
598                 newList.add(popupMenu);
599                 MenuElement subs[] = popupMenu.getSubElements();
600                 MenuElement sub =
601                         BasicPopupMenuUI.findEnabledChild(subs, -1, true);
602                 if(sub != null) {
603                     newList.add(sub);
604                 }
605                 MenuSelectionManager manager = e.getMenuSelectionManager();
606                 MenuElement newPath[] = new MenuElement[0];;
607                 newPath = (MenuElement[]) newList.toArray(newPath);
608                 manager.setSelectedPath(newPath);
609                 e.consume();
610             }
611         }
612 
613         public void menuKeyPressed(MenuKeyEvent e) {}
614     public void menuKeyReleased(MenuKeyEvent e) {}
615     }
616 }
617
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags