1. /*

  2.  * @(#)BasicMenuUI.java	1.121 01/11/29

  3.  *

  4.  * Copyright 2002 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 java.awt.*;

  11. import java.awt.event.*;

  12. import java.beans.*;

  13. import javax.swing.*;

  14. import javax.swing.event.*;

  15. import javax.swing.plaf.*;

  16. import javax.swing.border.*;

  17. 

  18. 

  19. /**

  20.  * A default L&F implementation of MenuUI.  This implementation 

  21.  * is a "combined" view/controller.

  22.  *

  23.  * @version 1.121 11/29/01

  24.  * @author Georges Saab

  25.  * @author David Karlton

  26.  * @author Arnaud Weber

  27.  */

  28. public class BasicMenuUI extends BasicMenuItemUI 

  29. {

  30.     protected ChangeListener         changeListener;

  31.     protected PropertyChangeListener propertyChangeListener;

  32.     protected MenuListener           menuListener;

  33. 

  34.     private int lastMnemonic = 0;

  35. 

  36.     public static ComponentUI createUI(JComponent x) {

  37. 	return new BasicMenuUI();

  38.     }

  39. 

  40.     protected void installDefaults() {

  41. 	super.installDefaults();

  42. 	((JMenu)menuItem).setDelay(200);

  43.     }

  44. 

  45.     protected String getPropertyPrefix() {

  46. 	return "Menu";

  47.     }

  48. 

  49.     protected void installListeners() {

  50. 	super.installListeners();

  51. 

  52.         changeListener = createChangeListener(menuItem);

  53.         propertyChangeListener = createPropertyChangeListener(menuItem);

  54. 	menuListener = createMenuListener(menuItem);

  55. 

  56.         menuItem.addChangeListener(changeListener);

  57.         menuItem.addPropertyChangeListener(propertyChangeListener);

  58. 	((JMenu)menuItem).addMenuListener(menuListener);

  59.     }

  60. 

  61.     protected void installKeyboardActions() {

  62.         if(menuItem.getModel().getMnemonic() != lastMnemonic) {

  63.             menuItem.unregisterKeyboardAction(

  64. 		     KeyStroke.getKeyStroke(lastMnemonic,

  65. 					    ActionEvent.ALT_MASK,

  66. 					    false));

  67.             lastMnemonic = menuItem.getModel().getMnemonic();

  68.             menuItem.registerKeyboardAction(

  69. 		     new PostAction((JMenu)menuItem, true),            

  70. 		     KeyStroke.getKeyStroke(lastMnemonic,

  71. 					    ActionEvent.ALT_MASK,

  72. 					    false),

  73. 		     JComponent.WHEN_IN_FOCUSED_WINDOW);

  74.         } 

  75.     }

  76. 

  77.     protected void uninstallKeyboardActions() {

  78. 	menuItem.unregisterKeyboardAction(

  79. 			  KeyStroke.getKeyStroke(lastMnemonic,

  80. 						 ActionEvent.ALT_MASK,

  81. 						 false));

  82. 	lastMnemonic = 0;

  83.     }

  84. 

  85.     protected MouseInputListener createMouseInputListener(JComponent c) {

  86. 	return new MouseInputHandler();

  87.     }

  88. 

  89.     protected MenuListener createMenuListener(JComponent c) {

  90. 	return new MenuHandler();

  91.     }

  92. 

  93.     protected ChangeListener createChangeListener(JComponent c) {

  94.         return new ChangeHandler((JMenu)c, this);

  95.     }

  96. 

  97.     protected PropertyChangeListener createPropertyChangeListener(JComponent c) {

  98.         return new PropertyChangeHandler();

  99.     }

  100. 

  101.     protected void uninstallDefaults() {

  102. 	menuItem.setArmed(false);

  103. 	menuItem.setSelected(false);

  104. 	menuItem.resetKeyboardActions();

  105. 	super.uninstallDefaults();

  106.     }

  107. 

  108.     protected void uninstallListeners() {

  109. 	super.uninstallListeners();

  110.         menuItem.removeChangeListener(changeListener);

  111.         menuItem.removePropertyChangeListener(propertyChangeListener);

  112.         ((JMenu)menuItem).removeMenuListener(menuListener);

  113. 

  114. 	changeListener = null;

  115. 	propertyChangeListener = null;

  116. 	menuListener = null;

  117.     }

  118. 

  119.     protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {

  120. 	return new MenuDragMouseHandler();

  121.     }

  122.     

  123.     protected MenuKeyListener createMenuKeyListener(JComponent c) {

  124. 	return new MenuKeyHandler();

  125.     }

  126. 

  127.     public Dimension getMaximumSize(JComponent c) {

  128. 	if (((JMenu)menuItem).isTopLevelMenu() == true) {

  129. 	    Dimension d = c.getPreferredSize();

  130. 	    return new Dimension(d.width, Short.MAX_VALUE);

  131. 	}

  132.         return null;

  133.     }

  134. 

  135.     protected void setupPostTimer(JMenu menu) {

  136.         Timer timer = new Timer(menu.getDelay(),new PostAction(menu,false));

  137.         timer.setRepeats(false);

  138.         timer.start();

  139.     }

  140. 

  141.     private static class PostAction implements ActionListener {

  142. 	JMenu menu;

  143.         boolean force=false;

  144. 

  145.         PostAction(JMenu menu,boolean shouldForce) {

  146. 	    this.menu = menu;

  147.             this.force = shouldForce;

  148. 	}

  149. 	

  150. 	public void actionPerformed(ActionEvent e) {

  151.             MenuSelectionManager defaultManager = MenuSelectionManager.defaultManager();

  152.             if(force) {

  153.                 Container cnt = menu.getParent();

  154.                 if(cnt != null && cnt instanceof JMenuBar) {

  155.                     MenuElement me[];

  156.                     MenuElement subElements[];

  157. 

  158.                     subElements = menu.getPopupMenu().getSubElements();

  159.                     if(subElements.length > 0) {

  160.                         me = new MenuElement[4];

  161.                         me[0] = (MenuElement) cnt;

  162.                         me[1] = (MenuElement) menu;

  163.                         me[2] = (MenuElement) menu.getPopupMenu();

  164.                         me[3] = subElements[0];

  165.                         defaultManager.setSelectedPath(me);

  166.                     } else {

  167.                         me = new MenuElement[2];

  168.                         me[0] = (MenuElement)cnt;

  169.                         me[1] = menu;

  170.                         defaultManager.setSelectedPath(me);

  171.                     }

  172.                 }

  173.             } else {

  174.                 MenuElement path[] = defaultManager.getSelectedPath();

  175.                 if(path.length > 0 && path[path.length-1] == menu) {

  176.                     MenuElement newPath[] = new MenuElement[path.length+1];

  177.                     System.arraycopy(path,0,newPath,0,path.length);

  178.                     newPath[path.length] = menu.getPopupMenu();

  179.                     MenuSelectionManager.defaultManager().setSelectedPath(newPath);

  180.                 }

  181.             }

  182.         }

  183. 

  184. 	public boolean isEnabled() {

  185. 	    return menu.getModel().isEnabled();

  186. 	}

  187.     }

  188. 

  189. 

  190.     private class PropertyChangeHandler implements PropertyChangeListener {

  191.         public void propertyChange(PropertyChangeEvent e) {

  192. 	    String prop = e.getPropertyName();

  193. 	    if(prop.equals(AbstractButton.MNEMONIC_CHANGED_PROPERTY)) {

  194. 		installKeyboardActions();

  195. 	    }

  196. 	}

  197.     }

  198. 

  199.     private class MouseInputHandler implements MouseInputListener {

  200. 	public void mouseClicked(MouseEvent e) {}

  201.         public void mousePressed(MouseEvent e) {

  202. 	    JMenu menu = (JMenu)menuItem;

  203. 	    if (!menu.isEnabled())

  204. 		return;

  205. 

  206. 	    MenuSelectionManager manager = 

  207. 		MenuSelectionManager.defaultManager();

  208.             if(menu.isTopLevelMenu()) {

  209. 		if(menu.isSelected()) {

  210. 		    manager.clearSelectedPath();

  211. 		} else {

  212. 		    Container cnt = menu.getParent();

  213. 		    if(cnt != null && cnt instanceof JMenuBar) {

  214. 			MenuElement me[] = new MenuElement[2];

  215. 			me[0]=(MenuElement)cnt;

  216. 			me[1]=menu;

  217. 			manager.setSelectedPath(me);

  218. 		    }

  219. 		}

  220. 	    }

  221. 

  222.             MenuElement selectedPath[] = manager.getSelectedPath();

  223.             if(!(selectedPath.length > 0 && 

  224. 		 selectedPath[selectedPath.length-1] == 

  225. 		 menu.getPopupMenu())) {

  226. 		if(menu.isTopLevelMenu() || 

  227. 		   menu.getDelay() == 0) {

  228. 		    MenuElement newPath[] = new MenuElement[selectedPath.length+1];

  229. 		    System.arraycopy(selectedPath,0,newPath,0,selectedPath.length);

  230. 		    newPath[selectedPath.length] = menu.getPopupMenu();

  231. 		    manager.setSelectedPath(newPath);

  232. 		} else {

  233. 		    setupPostTimer(menu);

  234. 		}

  235.             }

  236.         }

  237. 

  238. 	public void mouseReleased(MouseEvent e) {

  239. 	    JMenu menu = (JMenu)menuItem;

  240. 	    if (!menu.isEnabled())

  241. 		return;

  242. 	    MenuSelectionManager manager = 

  243. 		MenuSelectionManager.defaultManager();

  244. 	    manager.processMouseEvent(e);

  245. 	    if (!e.isConsumed())

  246. 		manager.clearSelectedPath();		

  247. 	}

  248. 	public void mouseEntered(MouseEvent e) {

  249. 	    JMenu menu = (JMenu)menuItem;

  250. 	    if (!menu.isEnabled())

  251. 		return;

  252. 

  253. 	    MenuSelectionManager manager = 

  254. 		MenuSelectionManager.defaultManager();

  255. 	    MenuElement selectedPath[] = manager.getSelectedPath();	    

  256. 	    if (!menu.isTopLevelMenu()) {

  257. 		if(!(selectedPath.length > 0 && 

  258. 		     selectedPath[selectedPath.length-1] == 

  259. 		     menu.getPopupMenu())) {

  260. 		    if(menu.getDelay() == 0) {

  261. 			MenuElement newPath[] = new MenuElement[selectedPath.length+2];

  262. 			System.arraycopy(selectedPath,0,newPath,0,selectedPath.length);

  263. 			newPath[selectedPath.length] = menuItem;

  264. 			newPath[selectedPath.length+1] = menu.getPopupMenu();

  265. 			manager.setSelectedPath(newPath);

  266. 		    } else {

  267. 			manager.setSelectedPath(getPath());

  268. 			setupPostTimer(menu);

  269. 		    }

  270. 		}

  271. 	    } else {

  272. 		if(selectedPath.length > 0 &&

  273. 		   selectedPath[0] == menu.getParent()) {

  274. 		    MenuElement newPath[] = new MenuElement[3];

  275. 		    // A top level menu's parent is by definition 

  276. 		    // a JMenuBar

  277. 		    newPath[0] = (MenuElement)menu.getParent();

  278. 		    newPath[1] = menu;

  279. 		    newPath[2] = menu.getPopupMenu();

  280. 		    manager.setSelectedPath(newPath);

  281. 		}

  282. 	    }

  283. 	}

  284. 	public void mouseExited(MouseEvent e) {

  285. 	}

  286. 	public void mouseDragged(MouseEvent e) {

  287. 	    JMenu menu = (JMenu)menuItem;

  288. 	    if (!menu.isEnabled())

  289. 		return;

  290. 	    MenuSelectionManager.defaultManager().processMouseEvent(e);

  291. 	}

  292. 	public void mouseMoved(MouseEvent e) {

  293. 	}

  294.     }

  295. 

  296.     private static class MenuHandler implements MenuListener {

  297. 	public void menuSelected(MenuEvent e) {}

  298. 	public void menuDeselected(MenuEvent e) {}

  299. 	public void menuCanceled(MenuEvent e) {

  300. 	    JMenu m = (JMenu)e.getSource();

  301. 	    MenuSelectionManager manager = MenuSelectionManager.defaultManager();

  302. 	    if(manager.isComponentPartOfCurrentMenu(m))

  303. 		MenuSelectionManager.defaultManager().clearSelectedPath();

  304. 	}

  305. 	

  306.     }

  307. 

  308.     public class ChangeHandler implements ChangeListener {

  309.         public JMenu    menu;

  310. 	public BasicMenuUI ui;

  311.         public boolean  isSelected = false;

  312.         public Component wasFocused;

  313. 

  314.         public ChangeHandler(JMenu m, BasicMenuUI ui) {

  315.             menu = m;

  316.             this.ui = ui;

  317.             validateKeyboardActions(menu.isSelected());

  318.         }

  319. 

  320.         public void stateChanged(ChangeEvent e) {

  321.             validateKeyboardActions(menu.isSelected());

  322.         }

  323. 

  324.         private Component findFocusedComponent(Component c) {

  325.             Container parent;

  326.             for(parent = c.getParent() ; parent != null ; parent = parent.getParent()) {

  327.                 if(parent instanceof java.awt.Window)

  328.                     return ((java.awt.Window)parent).getFocusOwner();

  329.             }

  330.             return null;

  331.         }

  332. 

  333.         private void validateKeyboardActions(boolean sel) {

  334.             if(sel != isSelected) {

  335.                 isSelected = sel;

  336.                 if(isSelected) {

  337.                     boolean isRequestFocusEnabled = menu.isRequestFocusEnabled();

  338.                     wasFocused = findFocusedComponent(menu);

  339.                     if(!isRequestFocusEnabled)

  340.                         menu.setRequestFocusEnabled(true);

  341.                     menu.requestFocus();

  342.                     if(!isRequestFocusEnabled)

  343.                         menu.setRequestFocusEnabled(false);

  344.                     menu.registerKeyboardAction(new CancelAction(),

  345.                                                 KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,0,false),

  346.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  347.                     menu.registerKeyboardAction(new SelectNextItemAction(),

  348.                                                 KeyStroke.getKeyStroke(KeyEvent.VK_DOWN,0,false),

  349.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  350.                     menu.registerKeyboardAction(new SelectNextItemAction(),

  351.                                                 KeyStroke.getKeyStroke("KP_DOWN"),

  352.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  353.                     menu.registerKeyboardAction(new SelectPreviousItemAction(),

  354.                                                 KeyStroke.getKeyStroke(KeyEvent.VK_UP,0,false),

  355.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  356.                     menu.registerKeyboardAction(new SelectPreviousItemAction(),

  357.                                                 KeyStroke.getKeyStroke("KP_UP"),

  358.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  359.                     menu.registerKeyboardAction(new SelectParentItemAction(),

  360.                                                 KeyStroke.getKeyStroke(KeyEvent.VK_LEFT,0,false),

  361.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  362.                     menu.registerKeyboardAction(new SelectParentItemAction(),

  363.                                                 KeyStroke.getKeyStroke("KP_LEFT"),

  364.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  365.                     menu.registerKeyboardAction(new SelectChildItemAction(),

  366.                                                 KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT,0,false),

  367.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  368.                     menu.registerKeyboardAction(new SelectChildItemAction(),

  369.                                                 KeyStroke.getKeyStroke("KP_RIGHT"),

  370.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  371.                     menu.registerKeyboardAction(new ReturnAction(),

  372.                                                 KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0,false),

  373.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  374.                     menu.registerKeyboardAction(new ReturnAction(),

  375.                                                 KeyStroke.getKeyStroke(KeyEvent.VK_SPACE,0,false),

  376.                                                 JComponent.WHEN_IN_FOCUSED_WINDOW);

  377.                 } else {

  378.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE,0,false));

  379.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN,0,false));

  380.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke("KP_DOWN"));

  381.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_UP,0,false));

  382.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke("KP_UP"));

  383.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT,0,false));

  384.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke("KP_LEFT"));

  385.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT,0,false));

  386.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke("KP_RIGHT"));

  387.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0,false));

  388.                     menu.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE,0,false));

  389.                     if(wasFocused != null) {

  390.                         if(wasFocused instanceof JComponent) {

  391.                             JComponent jc = (JComponent) wasFocused;

  392.                             boolean isRFEnabled = jc.isRequestFocusEnabled();

  393.                             if(!isRFEnabled)

  394.                                 jc.setRequestFocusEnabled(true);

  395.                             wasFocused.requestFocus();

  396.                             if(!isRFEnabled)

  397.                                 jc.setRequestFocusEnabled(false);

  398.                         } else

  399.                             wasFocused.requestFocus();

  400.                         wasFocused = null;

  401.                     }

  402.                 }

  403.             }

  404.         }

  405. 

  406.         private class CancelAction implements ActionListener {

  407.             public void actionPerformed(ActionEvent e) {

  408. 		JMenu menu = (JMenu)menuItem;

  409. 		if (!menu.isEnabled())

  410. 		    return;

  411. 		

  412.                 MenuElement path[] = MenuSelectionManager.defaultManager().getSelectedPath();

  413.                 if(path.length > 4) { /* PENDING(arnaud) Change this to 2 when a mouse grabber is available for MenuBar */

  414.                     MenuElement newPath[] = new MenuElement[path.length - 2];

  415.                     System.arraycopy(path,0,newPath,0,path.length-2);

  416.                     MenuSelectionManager.defaultManager().setSelectedPath(newPath);

  417.                 } else

  418.                     MenuSelectionManager.defaultManager().clearSelectedPath();

  419.             }

  420.         }

  421. 

  422.         private class ReturnAction implements ActionListener {

  423.             public void actionPerformed(ActionEvent e) {

  424. 		JMenu menu = (JMenu)menuItem;

  425. 		if (!menu.isEnabled())

  426. 		    return;

  427. 

  428.                 MenuElement path[] = MenuSelectionManager.defaultManager().getSelectedPath();

  429.                 MenuElement lastElement;

  430.                 if(path.length > 0) {

  431.                     lastElement = path[path.length-1];

  432.                     if(lastElement instanceof JMenu) {

  433.                         MenuElement newPath[] = new MenuElement[path.length+1];

  434.                         System.arraycopy(path,0,newPath,0,path.length);

  435.                         newPath[path.length] = ((JMenu)lastElement).getPopupMenu();

  436.                         MenuSelectionManager.defaultManager().setSelectedPath(newPath);

  437.                     } else if(lastElement instanceof JMenuItem) {

  438.                         MenuSelectionManager.defaultManager().clearSelectedPath();

  439.                         ((JMenuItem)lastElement).doClick(0);

  440.                         ((JMenuItem)lastElement).setArmed(false);

  441.                     }

  442.                 }

  443.             }

  444.         }

  445. 

  446.         private MenuElement nextEnabledChild(MenuElement e[],int fromIndex) {

  447.             int i,c;

  448.             for(i=fromIndex,c=e.length ; i < c ; i++) {

  449. 		if (e[i]!=null) {

  450. 		    Component comp = e[i].getComponent();

  451. 		    if(comp != null && comp.isEnabled())

  452. 			return e[i];

  453. 		}

  454. 	    }

  455.             return null;

  456.         }

  457. 

  458.         private MenuElement previousEnabledChild(MenuElement e[],int fromIndex) {

  459.             int i;

  460.             for(i=fromIndex ; i >= 0 ; i--) {

  461. 		if (e[i]!=null) {

  462. 		    Component comp = e[i].getComponent();

  463. 		    if(comp != null && comp.isEnabled())

  464. 			return e[i];

  465. 		}

  466. 	    }

  467.             return null;

  468.         }

  469. 

  470.         private class SelectNextItemAction implements ActionListener {

  471.             public void actionPerformed(ActionEvent e) {

  472. 		JMenu menu = (JMenu)menuItem;

  473. 		if (!menu.isEnabled())

  474. 		    return;

  475. 

  476.                 MenuElement currentSelection[] = MenuSelectionManager.defaultManager().getSelectedPath();

  477.                 if(currentSelection.length > 1) {

  478.                     MenuElement parent = currentSelection[currentSelection.length-2];

  479.                     if(parent.getComponent() instanceof JMenu) {

  480.                         MenuElement childs[];

  481.                         parent = currentSelection[currentSelection.length-1];

  482.                         childs = parent.getSubElements();

  483.                         if(childs.length > 0) {

  484.                             MenuElement newPath[] = new MenuElement[currentSelection.length+1];

  485.                             System.arraycopy(currentSelection,0,

  486.                                              newPath,0,currentSelection.length);

  487.                             newPath[currentSelection.length] = nextEnabledChild(childs,0);

  488.                             if(newPath[currentSelection.length] != null)

  489.                                 MenuSelectionManager.defaultManager().setSelectedPath(newPath);

  490.                         }

  491.                     } else {

  492.                         MenuElement childs[] = parent.getSubElements();

  493.                         MenuElement nextChild;

  494.                         int i,c;

  495.                         for(i=0,c=childs.length;i<c;i++) {

  496.                             if(childs[i] == currentSelection[currentSelection.length-1]) {

  497.                                 nextChild = nextEnabledChild(childs,i+1);

  498.                                 if(nextChild == null)

  499.                                     nextChild = nextEnabledChild(childs,0);

  500.                                 if(nextChild != null) {

  501.                                     currentSelection[currentSelection.length-1] = nextChild;

  502.                                     MenuSelectionManager.defaultManager().setSelectedPath(currentSelection);

  503.                                 }

  504.                                 break;

  505.                             }

  506.                         }

  507.                     }

  508.                 }

  509.             }

  510.         }

  511. 

  512.         private class SelectPreviousItemAction implements ActionListener {

  513.             public void actionPerformed(ActionEvent e) {

  514. 		JMenu menu = (JMenu)menuItem;

  515. 		if (!menu.isEnabled())

  516. 		    return;

  517. 

  518.                 MenuElement currentSelection[] = MenuSelectionManager.defaultManager().getSelectedPath();

  519.                 if(currentSelection.length > 1) {

  520.                     MenuElement parent = currentSelection[currentSelection.length-2];

  521.                     if(parent.getComponent() instanceof JMenu) {

  522.                         MenuElement childs[];

  523.                         parent = currentSelection[currentSelection.length-1];

  524.                         childs = parent.getSubElements();

  525.                         if(childs.length > 0) {

  526.                             MenuElement newPath[] = new MenuElement[currentSelection.length+1];

  527.                             System.arraycopy(currentSelection,0,

  528.                                              newPath,0,currentSelection.length);

  529.                             newPath[currentSelection.length] = previousEnabledChild(childs,childs.length-1);

  530.                             if(newPath[currentSelection.length] != null)

  531.                                 MenuSelectionManager.defaultManager().setSelectedPath(newPath);

  532.                         }

  533.                     } else {

  534.                         MenuElement childs[] = parent.getSubElements();

  535.                         MenuElement nextChild;

  536.                         int i,c;

  537.                         for(i=0,c=childs.length;i<c;i++) {

  538.                             if(childs[i] == currentSelection[currentSelection.length-1]) {

  539.                                 nextChild = previousEnabledChild(childs,i-1);

  540.                                 if(nextChild == null)

  541.                                     nextChild = previousEnabledChild(childs,childs.length-1);

  542.                                 if(nextChild != null) {

  543.                                     currentSelection[currentSelection.length-1] = nextChild;

  544.                                     MenuSelectionManager.defaultManager().setSelectedPath(currentSelection);

  545.                                 }

  546.                                 break;

  547.                             }

  548.                         }

  549.                     }

  550.                 }

  551.             }

  552.         }

  553. 

  554.         private class SelectParentItemAction implements ActionListener {

  555.             public void actionPerformed(ActionEvent e) {

  556. 		JMenu menu = (JMenu)menuItem;

  557. 		if (!menu.isEnabled())

  558. 		    return;

  559. 

  560.                 MenuElement path[] = MenuSelectionManager.defaultManager().getSelectedPath();

  561.                 

  562.                 if(path.length > 3 && path[path.length-3].getComponent() instanceof JMenu &&

  563.                    !((JMenu)path[path.length-3].getComponent()).isTopLevelMenu()) {

  564.                     MenuElement newPath[] = new MenuElement[path.length-2];

  565.                     System.arraycopy(path,0,newPath,0,path.length-2);

  566.                     MenuSelectionManager.defaultManager().setSelectedPath(newPath);

  567.                 } else if(path.length > 0 && path[0].getComponent() instanceof JMenuBar) {

  568.                     MenuElement nextMenu=null,popup=null,firstItem=null;

  569.                     MenuElement tmp[];

  570.                     int i,c;

  571.                     

  572.                     if(path.length > 1) {

  573.                         MenuElement previousElement;

  574.                         tmp = path[0].getSubElements();

  575.                         for(i=0,c=tmp.length;i<c;i++) {

  576.                             if(tmp[i] == path[1]) {

  577.                                 nextMenu = previousEnabledChild(tmp,i-1);

  578.                                 if(nextMenu == null)

  579.                                     nextMenu = previousEnabledChild(tmp,tmp.length-1);

  580.                             }

  581.                         }

  582.                     }

  583.                     

  584.                     if(nextMenu != null) {

  585.                         MenuElement newSelection[];

  586.                         popup = ((JMenu)nextMenu).getPopupMenu();

  587.                         if(((JMenu)nextMenu).isTopLevelMenu()) 

  588.                             firstItem = null;

  589.                         else {

  590.                             tmp = popup.getSubElements();

  591.                             if(tmp.length > 0) 

  592.                                 firstItem = nextEnabledChild(tmp,0);

  593.                         }

  594. 

  595.                         if(firstItem != null) {

  596.                             newSelection = new MenuElement[4];

  597.                             newSelection[0] = path[0];

  598.                             newSelection[1] = nextMenu;

  599.                             newSelection[2] = popup;

  600.                             newSelection[3] = firstItem;

  601.                         } else {

  602.                             newSelection = new MenuElement[3];

  603.                             newSelection[0] = path[0];

  604.                             newSelection[1] = nextMenu;

  605.                             newSelection[2] = popup;

  606.                         }

  607.                         MenuSelectionManager.defaultManager().setSelectedPath(newSelection);

  608.                     }

  609.                 }

  610.             }

  611.         }

  612. 

  613.         private class SelectChildItemAction implements ActionListener {

  614.             public void actionPerformed(ActionEvent e) {

  615. 		JMenu menu = (JMenu)menuItem;

  616. 		if (!menu.isEnabled())

  617. 		    return;

  618. 

  619.                 MenuElement path[] = MenuSelectionManager.defaultManager().getSelectedPath();

  620.                 

  621.                 if(path.length > 0 && path[path.length-1].getComponent().isEnabled() && 

  622.                    path[path.length-1].getComponent() instanceof JMenu &&

  623.                    !((JMenu)path[path.length-1].getComponent()).isTopLevelMenu()) {

  624.                     MenuElement newPath[] = new MenuElement[path.length+2];

  625.                     MenuElement subElements[];

  626.                     System.arraycopy(path,0,newPath,0,path.length);

  627.                     newPath[path.length] = ((JMenu)path[path.length-1].getComponent()).getPopupMenu();

  628.                     subElements = newPath[path.length].getSubElements();

  629.                     if(subElements.length > 0) {

  630.                         newPath[path.length+1] = nextEnabledChild(subElements,0);

  631.                         MenuSelectionManager.defaultManager().setSelectedPath(newPath);

  632.                     }

  633.                 } else if(path.length > 0 && path[0].getComponent() instanceof JMenuBar) {

  634.                     MenuElement nextMenu=null,popup=null,firstItem=null;

  635.                     MenuElement tmp[];

  636.                     int i,c;

  637.                     

  638.                     if(path.length > 1) {

  639.                         tmp = path[0].getSubElements();

  640.                         for(i=0,c=tmp.length;i<c;i++) {

  641.                             if(tmp[i] == path[1]) {

  642.                                 nextMenu = nextEnabledChild(tmp,i+1);

  643.                                 if(nextMenu == null)

  644.                                     nextMenu = nextEnabledChild(tmp,0);

  645.                             }

  646.                         }

  647.                     }

  648.                     

  649.                     if(nextMenu != null) {

  650.                         MenuElement newSelection[];

  651.                         popup = ((JMenu)nextMenu).getPopupMenu();

  652.                         if(((JMenu)nextMenu).isTopLevelMenu()) 

  653.                             firstItem = null;

  654.                         else {

  655.                             tmp = popup.getSubElements();

  656.                             if(tmp.length > 0) 

  657.                                 firstItem = nextEnabledChild(tmp,0);

  658.                         }

  659. 

  660.                         if(firstItem != null) {

  661.                             newSelection = new MenuElement[4];

  662.                             newSelection[0] = path[0];

  663.                             newSelection[1] = nextMenu;

  664.                             newSelection[2] = popup;

  665.                             newSelection[3] = firstItem;

  666.                         } else {

  667.                             newSelection = new MenuElement[3];

  668.                             newSelection[0] = path[0];

  669.                             newSelection[1] = nextMenu;

  670.                             newSelection[2] = popup;

  671.                         }

  672.                         MenuSelectionManager.defaultManager().setSelectedPath(newSelection);

  673.                     }

  674.                 }

  675.             }

  676.         }

  677.     }

  678. 

  679. 

  680.     private class MenuDragMouseHandler implements MenuDragMouseListener {

  681. 	public void menuDragMouseEntered(MenuDragMouseEvent e) {}

  682. 	public void menuDragMouseDragged(MenuDragMouseEvent e) {

  683. 	    if (menuItem.isEnabled() == false)

  684. 		return;

  685. 	    

  686. 	    MenuSelectionManager manager = e.getMenuSelectionManager();

  687. 	    MenuElement path[] = e.getPath();

  688. 	    

  689. 	    Point p = e.getPoint();

  690. 	    if(p.x >= 0 && p.x < menuItem.getWidth() &&

  691. 	       p.y >= 0 && p.y < menuItem.getHeight()) {

  692. 		JMenu menu = (JMenu)menuItem;

  693. 		MenuElement selectedPath[] = manager.getSelectedPath();

  694. 		if(!(selectedPath.length > 0 && 

  695. 		     selectedPath[selectedPath.length-1] == 

  696. 		     menu.getPopupMenu())) {

  697. 		    if(menu.isTopLevelMenu() || 

  698. 		       menu.getDelay() == 0  ||

  699. 		       e.getID() == MouseEvent.MOUSE_DRAGGED) {

  700. 			MenuElement newPath[] = new MenuElement[path.length+1];

  701. 			System.arraycopy(path,0,newPath,0,path.length);

  702. 			newPath[path.length] = menu.getPopupMenu();

  703. 			manager.setSelectedPath(newPath);

  704. 		    } else {

  705. 			manager.setSelectedPath(path);

  706. 			setupPostTimer(menu);

  707. 		    }

  708. 		}

  709. 	    } else if(e.getID() == MouseEvent.MOUSE_RELEASED) {

  710. 		Component comp = manager.componentForPoint(e.getComponent(), e.getPoint());

  711. 		if (comp == null)

  712. 		    manager.clearSelectedPath();

  713. 	    }

  714. 	    

  715. 	}

  716. 	public void menuDragMouseExited(MenuDragMouseEvent e) {}

  717. 	public void menuDragMouseReleased(MenuDragMouseEvent e) {}	    

  718.     }

  719. 

  720.     private class MenuKeyHandler implements MenuKeyListener {

  721. 	public void menuKeyTyped(MenuKeyEvent e) { }

  722. 	public void menuKeyPressed(MenuKeyEvent e) {}

  723. 	public void menuKeyReleased(MenuKeyEvent e) {}

  724. 

  725. 	private int lower(int ascii) {

  726. 	    if(ascii >= 'A' && ascii <= 'Z')

  727. 		return ascii + 'a' - 'A';

  728. 	    else

  729. 		return ascii;

  730. 	}

  731. 

  732.     }

  733. }

  734. 

  735. 

  736. 

  737.