1. /*

  2.  * @(#)BasicMenuUI.java	1.131 01/02/09

  3.  *

  4.  * Copyright 1997-2001 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package javax.swing.plaf.basic;

  12. 

  13. import java.awt.*;

  14. import java.awt.event.*;

  15. import java.beans.*;

  16. import javax.swing.*;

  17. import javax.swing.event.*;

  18. import javax.swing.plaf.*;

  19. import javax.swing.border.*;

  20. 

  21. 

  22. /**

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

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

  25.  *

  26.  * @version 1.131 02/09/01

  27.  * @author Georges Saab

  28.  * @author David Karlton

  29.  * @author Arnaud Weber

  30.  */

  31. public class BasicMenuUI extends BasicMenuItemUI 

  32. {

  33.     protected ChangeListener         changeListener;

  34.     protected PropertyChangeListener propertyChangeListener;

  35.     protected MenuListener           menuListener;

  36. 

  37.     private int lastMnemonic = 0;

  38. 

  39.     /** Uses as the parent of the windowInputMap when selected. */

  40.     private InputMap selectedWindowInputMap;

  41. 

  42.     /* diagnostic aids -- should be false for production builds. */

  43.     private static final boolean TRACE =   false; // trace creates and disposes

  44.     private static final boolean VERBOSE = false; // show reuse hits/misses

  45.     private static final boolean DEBUG =   false;  // show bad params, misc.

  46. 

  47.     public static ComponentUI createUI(JComponent x) {

  48. 	return new BasicMenuUI();

  49.     }

  50. 

  51.     protected void installDefaults() {

  52. 	super.installDefaults();

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

  54.     }

  55. 

  56.     protected String getPropertyPrefix() {

  57. 	return "Menu";

  58.     }

  59. 

  60.     protected void installListeners() {

  61. 	super.installListeners();

  62. 

  63.         changeListener = createChangeListener(menuItem);

  64.         propertyChangeListener = createPropertyChangeListener(menuItem);

  65. 	menuListener = createMenuListener(menuItem);

  66. 

  67.         menuItem.addChangeListener(changeListener);

  68.         menuItem.addPropertyChangeListener(propertyChangeListener);

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

  70.     }

  71. 

  72.     protected void installKeyboardActions() {

  73. 	super.installKeyboardActions();

  74. 	updateMnemonicBinding();

  75.     }

  76. 

  77.     void updateMnemonicBinding() {

  78. 	int mnemonic = menuItem.getModel().getMnemonic();

  79. 	if (mnemonic == lastMnemonic) {

  80. 	    return;

  81. 	}

  82. 	if (lastMnemonic != 0 && windowInputMap != null) {

  83. 	    windowInputMap.remove(KeyStroke.getKeyStroke

  84. 				(lastMnemonic, ActionEvent.ALT_MASK, false));

  85. 	}

  86. 	if (mnemonic != 0) {

  87. 	    if (windowInputMap == null) {

  88. 		windowInputMap = createInputMap(JComponent.

  89. 					      WHEN_IN_FOCUSED_WINDOW);

  90. 		SwingUtilities.replaceUIInputMap(menuItem, JComponent.

  91. 				       WHEN_IN_FOCUSED_WINDOW, windowInputMap);

  92. 	    }

  93. 	    windowInputMap.put(KeyStroke.getKeyStroke(mnemonic,

  94. 						    ActionEvent.ALT_MASK,

  95. 						    false),

  96. 			     "selectMenu");

  97.         }

  98. 	lastMnemonic = mnemonic;

  99.     }

  100. 

  101.     protected void uninstallKeyboardActions() {

  102. 	super.uninstallKeyboardActions();

  103.     }

  104. 

  105.     /**

  106.      * The ActionMap for BasicMenUI can not be shared, this is subclassed

  107.      * to create a new one for each invocation.

  108.      */

  109.     ActionMap getActionMap() {

  110. 	return createActionMap();

  111.     }

  112. 

  113.     /**

  114.      * Invoked to create the ActionMap.

  115.      */

  116.     ActionMap createActionMap() {

  117. 	ActionMap am = super.createActionMap();

  118. 	if (am != null) {

  119. 	    am.put("selectMenu", new PostAction((JMenu)menuItem, true));

  120. 	    // Get the ActionMap that can be shared.

  121. 	    ActionMap parent = (ActionMap)UIManager.

  122. 		               get("Menu.sharedActionMap");

  123. 	    if (parent == null) {

  124. 		parent = createSharedActionMap();

  125. 		if (parent != null) {

  126. 		    UIManager.put("MenuUI.sharedActionMap", parent);

  127. 		}

  128. 	    }

  129. 	    if (parent != null) {

  130. 		am.setParent(parent);

  131. 	    }

  132. 	}

  133. 	return am;

  134.     }

  135. 

  136.     /**

  137.      * Creates the ActionMap containing the actions that can be shared.

  138.      */

  139.     ActionMap createSharedActionMap() {

  140. 	ActionMap am = new ActionMapUIResource();

  141. 	am.put("cancel", new CancelAction());

  142. 	am.put("selectNext", new SelectNextItemAction());

  143. 	am.put("selectPrevious", new SelectPreviousItemAction());

  144. 	am.put("selectParent", new SelectParentItemAction());

  145. 	am.put("selectChild", new SelectChildItemAction());

  146. 	am.put("return", new ReturnAction());

  147. 	return am;

  148.     }

  149. 

  150.     protected MouseInputListener createMouseInputListener(JComponent c) {

  151. 	return new MouseInputHandler();

  152.     }

  153. 

  154.     protected MenuListener createMenuListener(JComponent c) {

  155. 	return new MenuHandler();

  156.     }

  157. 

  158.     protected ChangeListener createChangeListener(JComponent c) {

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

  160.     }

  161. 

  162.     protected PropertyChangeListener createPropertyChangeListener(JComponent c) {

  163.         return new PropertyChangeHandler();

  164.     }

  165. 

  166.     protected void uninstallDefaults() {

  167. 	menuItem.setArmed(false);

  168. 	menuItem.setSelected(false);

  169. 	menuItem.resetKeyboardActions();

  170. 	super.uninstallDefaults();

  171.     }

  172. 

  173.     protected void uninstallListeners() {

  174. 	super.uninstallListeners();

  175.         menuItem.removeChangeListener(changeListener);

  176.         menuItem.removePropertyChangeListener(propertyChangeListener);

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

  178. 

  179. 	changeListener = null;

  180. 	propertyChangeListener = null;

  181. 	menuListener = null;

  182.     }

  183. 

  184.     protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {

  185. 	return new MenuDragMouseHandler();

  186.     }

  187.     

  188.     protected MenuKeyListener createMenuKeyListener(JComponent c) {

  189. 	return new MenuKeyHandler();

  190.     }

  191. 

  192.     public Dimension getMaximumSize(JComponent c) {

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

  194. 	    Dimension d = c.getPreferredSize();

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

  196. 	}

  197.         return null;

  198.     }

  199. 

  200.     protected void setupPostTimer(JMenu menu) {

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

  202.         timer.setRepeats(false);

  203.         timer.start();

  204.     }

  205. 

  206.     private static class PostAction extends AbstractAction {

  207. 	JMenu menu;

  208.         boolean force=false;

  209. 

  210.         PostAction(JMenu menu,boolean shouldForce) {

  211. 	    this.menu = menu;

  212.             this.force = shouldForce;

  213. 	}

  214. 	

  215. 	public void actionPerformed(ActionEvent e) {

  216. 	    /* Must be commented out to work around compiler bug (4242000)

  217. 	       if (DEBUG) {

  218. 		System.out.println("In PostAction.actionPerformed");

  219. 		Thread.dumpStack();

  220. 	    } */

  221. 	    final MenuSelectionManager defaultManager = MenuSelectionManager.defaultManager();

  222.             if(force) {

  223.                 Container cnt = menu.getParent();

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

  225.                     final MenuElement me[];

  226.                     MenuElement subElements[];

  227. 		    

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

  229.                     if(subElements.length > 0) {

  230.                         me = new MenuElement[4];

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

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

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

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

  235.                     } else {

  236.                         me = new MenuElement[3];

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

  238.                         me[1] = menu;

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

  240.                     }

  241. 		    // Clear the path now so that no menu items

  242. 		    // of currently selected menus get a chance

  243. 		    // at this KeyEvent

  244. 		    defaultManager.clearSelectedPath();

  245.                     defaultManager.setSelectedPath(me);

  246. 		}

  247.             } else {

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

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

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

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

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

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

  254.                 }

  255.             }

  256.         }

  257. 

  258. 	public boolean isEnabled() {

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

  260. 	}

  261.     }

  262. 

  263. 

  264.     private class PropertyChangeHandler implements PropertyChangeListener {

  265.         public void propertyChange(PropertyChangeEvent e) {

  266. 	    String prop = e.getPropertyName();

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

  268. 		updateMnemonicBinding();

  269. 	    }

  270. 	}

  271.     }

  272. 

  273.     private class MouseInputHandler implements MouseInputListener {

  274. 	public void mouseClicked(MouseEvent e) {}

  275.         public void mousePressed(MouseEvent e) {

  276. 	    JMenu menu = (JMenu)menuItem;

  277. 	    if (!menu.isEnabled())

  278. 		return;

  279. 

  280. 	    MenuSelectionManager manager = 

  281. 		MenuSelectionManager.defaultManager();

  282.             if(menu.isTopLevelMenu()) {

  283. 		if(menu.isSelected()) {

  284. 		    manager.clearSelectedPath();

  285. 		} else {

  286. 		    Container cnt = menu.getParent();

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

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

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

  290. 			me[1]=menu;

  291. 			manager.setSelectedPath(me);

  292. 		    }

  293. 		}

  294. 	    }

  295. 

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

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

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

  299. 		 menu.getPopupMenu())) {

  300. 		if(menu.isTopLevelMenu() || 

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

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

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

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

  305. 		    manager.setSelectedPath(newPath);

  306. 		} else {

  307. 		    setupPostTimer(menu);

  308. 		}

  309.             }

  310.         }

  311. 

  312. 	public void mouseReleased(MouseEvent e) {

  313. 	    JMenu menu = (JMenu)menuItem;

  314. 	    if (!menu.isEnabled())

  315. 		return;

  316. 	    MenuSelectionManager manager = 

  317. 		MenuSelectionManager.defaultManager();

  318. 	    manager.processMouseEvent(e);

  319. 	    if (!e.isConsumed())

  320. 		manager.clearSelectedPath();		

  321. 	}

  322. 	public void mouseEntered(MouseEvent e) {

  323. 	    JMenu menu = (JMenu)menuItem;

  324. 	    if (!menu.isEnabled())

  325. 		return;

  326. 

  327. 	    MenuSelectionManager manager = 

  328. 		MenuSelectionManager.defaultManager();

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

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

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

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

  333. 		     menu.getPopupMenu())) {

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

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

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

  337. 			newPath[selectedPath.length] = menuItem;

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

  339. 			manager.setSelectedPath(newPath);

  340. 		    } else {

  341. 			manager.setSelectedPath(getPath());

  342. 			setupPostTimer(menu);

  343. 		    }

  344. 		}

  345. 	    } else {

  346. 		if(selectedPath.length > 0 &&

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

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

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

  350. 		    // a JMenuBar

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

  352. 		    newPath[1] = menu;

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

  354. 		    manager.setSelectedPath(newPath);

  355. 		}

  356. 	    }

  357. 	}

  358. 	public void mouseExited(MouseEvent e) {

  359. 	}

  360. 	public void mouseDragged(MouseEvent e) {

  361. 	    JMenu menu = (JMenu)menuItem;

  362. 	    if (!menu.isEnabled())

  363. 		return;

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

  365. 	}

  366. 	public void mouseMoved(MouseEvent e) {

  367. 	}

  368.     }

  369. 

  370.     private static class MenuHandler implements MenuListener {

  371. 	public void menuSelected(MenuEvent e) {}

  372. 	public void menuDeselected(MenuEvent e) {}

  373. 	public void menuCanceled(MenuEvent e) {

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

  375. 	    MenuSelectionManager manager = MenuSelectionManager.defaultManager();

  376. 	    if(manager.isComponentPartOfCurrentMenu(m))

  377. 		MenuSelectionManager.defaultManager().clearSelectedPath();

  378. 	}

  379. 	

  380.     }

  381. 

  382.     public class ChangeHandler implements ChangeListener {

  383.         public JMenu    menu;

  384. 	public BasicMenuUI ui;

  385.         public boolean  isSelected = false;

  386.         public Component wasFocused;

  387. 

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

  389.             menu = m;

  390.             this.ui = ui;

  391.             validateKeyboardActions(menu.isSelected());

  392.         }

  393. 

  394.         public void stateChanged(ChangeEvent e) {

  395.             validateKeyboardActions(menu.isSelected());

  396.         }

  397. 

  398.         private Component findFocusedComponent(Component c) {

  399.             Container parent;

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

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

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

  403.             }

  404.             return null;

  405.         }

  406. 

  407.         private void validateKeyboardActions(boolean sel) {

  408.             if(sel != isSelected) {

  409.                 isSelected = sel;

  410.                 if(isSelected) {

  411.                     boolean isRequestFocusEnabled = menu.isRequestFocusEnabled();

  412.                     wasFocused = findFocusedComponent(menu);

  413. 		    if ((wasFocused instanceof JComponent) &&

  414. 			((JComponent)wasFocused).getRootPane() != menu.getRootPane()) {

  415. 		      wasFocused = null;

  416. 		    }

  417.                     if(!isRequestFocusEnabled)

  418.                         menu.setRequestFocusEnabled(true);

  419.                     menu.requestFocus();

  420.                     if(!isRequestFocusEnabled)

  421.                         menu.setRequestFocusEnabled(false);

  422. 		    if (selectedWindowInputMap == null) {

  423. 			Object[] bindings = (Object[])UIManager.get

  424. 			          ("Menu.selectedWindowInputMapBindings");

  425. 			if (bindings != null) {

  426. 			    selectedWindowInputMap = LookAndFeel.

  427. 				makeComponentInputMap(menuItem, bindings);

  428. 			}

  429. 		    }

  430. 		    if (windowInputMap == null) {

  431. 			windowInputMap = createInputMap(JComponent.

  432. 						    WHEN_IN_FOCUSED_WINDOW);

  433. 			SwingUtilities.replaceUIInputMap(menuItem, JComponent.

  434. 						   WHEN_IN_FOCUSED_WINDOW,

  435. 						   windowInputMap);

  436. 		    }

  437. 		    if (windowInputMap != null && selectedWindowInputMap != null) {

  438. 			windowInputMap.setParent(selectedWindowInputMap);

  439. 		    }

  440.                 } else {

  441. 		    if (windowInputMap != null && selectedWindowInputMap != null) {

  442. 			windowInputMap.setParent(null);

  443. 		    }

  444.                     if(wasFocused != null) {

  445.                         if(wasFocused instanceof JComponent) {

  446.                             JComponent jc = (JComponent) wasFocused;

  447.                             boolean isRFEnabled = jc.isRequestFocusEnabled();

  448.                             if(!isRFEnabled)

  449.                                 jc.setRequestFocusEnabled(true);

  450.                             wasFocused.requestFocus();

  451.                             if(!isRFEnabled)

  452.                                 jc.setRequestFocusEnabled(false);

  453.                         } else

  454.                             wasFocused.requestFocus();

  455.                         wasFocused = null;

  456.                     }

  457.                 }

  458.             }

  459.         }

  460.     }

  461. 

  462.     private static class CancelAction extends AbstractAction {

  463. 	public void actionPerformed(ActionEvent e) {

  464. 	    /* Must be commented out to work around compiler bug (4242000)

  465. 	      if (DEBUG) {

  466. 		System.out.println("In CancelAction.actionPerformed");

  467. 		Thread.dumpStack();

  468. 	    }

  469. 	    */

  470. 	    JMenu menu = (JMenu)e.getSource();

  471. 	    if (!menu.isEnabled())

  472. 		return;

  473. 		

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

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

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

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

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

  479. 	    } else

  480. 		MenuSelectionManager.defaultManager().clearSelectedPath();

  481. 	}

  482.     }

  483. 

  484.     private class ReturnAction extends AbstractAction {

  485. 	public void actionPerformed(ActionEvent e) {

  486. 	    JMenu menu = (JMenu)e.getSource();

  487. 	    if (!menu.isEnabled())

  488. 		return;

  489. 

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

  491. 	    MenuElement lastElement;

  492. 	    if(path.length > 0) {

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

  494. 		if(lastElement instanceof JMenu) {

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

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

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

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

  499. 		} else if(lastElement instanceof JMenuItem) {

  500. 		    MenuSelectionManager.defaultManager().clearSelectedPath();

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

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

  503. 		}

  504. 	    }

  505. 	}

  506.     }

  507. 

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

  509. 	int i,c;

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

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

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

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

  514. 		    return e[i];

  515. 	    }

  516. 	}

  517. 	return null;

  518.     }

  519. 

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

  521. 	int i;

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

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

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

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

  526. 		    return e[i];

  527. 	    }

  528. 	}

  529. 	return null;

  530.     }

  531. 

  532.     private static class SelectNextItemAction extends AbstractAction {

  533. 	public void actionPerformed(ActionEvent e) {

  534. 	    /* Must be commented out to work around compiler bug (4242000)

  535. 	      if (DEBUG) {

  536. 		System.out.println("In SelectNextItemAction.actionPerformed");

  537. 	    }

  538. 	    */

  539. 

  540. 	    JMenu menu = (JMenu)e.getSource();

  541. 	    if (!menu.isEnabled())

  542. 		return;

  543. 

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

  545. 	    if(currentSelection.length > 1) {

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

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

  548. 		    MenuElement childs[];

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

  550. 		    childs = parent.getSubElements();

  551. 		    if(childs.length > 0) {

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

  553. 			System.arraycopy(currentSelection,0,

  554. 					 newPath,0,currentSelection.length);

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

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

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

  558. 			}

  559. 		    }

  560. 		} else {

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

  562. 		    MenuElement nextChild;

  563. 		    int i,c;

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

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

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

  567. 			    if(nextChild == null)

  568. 				nextChild = nextEnabledChild(childs,0);

  569. 			    if(nextChild != null) {

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

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

  572. 			    }

  573. 			    break;

  574. 			}

  575. 		    }

  576. 		}

  577. 	    }

  578. 	}

  579.     }

  580. 

  581.     private static class SelectPreviousItemAction extends AbstractAction {

  582. 	public void actionPerformed(ActionEvent e) {

  583. 	    /* Must be commented out to work around compiler bug (4242000)

  584. 	      if (DEBUG) {

  585. 		System.out.println("In SelectPreviousItemAction.actionPerformed");

  586. 	    }

  587. 	    */

  588. 	    JMenu menu = (JMenu)e.getSource();

  589. 	    if (!menu.isEnabled())

  590. 		return;

  591. 

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

  593. 	    if(currentSelection.length > 1) {

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

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

  596. 		    MenuElement childs[];

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

  598. 		    childs = parent.getSubElements();

  599. 		    if(childs.length > 0) {

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

  601. 			System.arraycopy(currentSelection,0,

  602. 					 newPath,0,currentSelection.length);

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

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

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

  606. 		    }

  607. 		} else {

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

  609. 		    MenuElement nextChild;

  610. 		    int i,c;

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

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

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

  614. 			    if(nextChild == null)

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

  616. 			    if(nextChild != null) {

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

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

  619. 			    }

  620. 			    break;

  621. 			}

  622. 		    }

  623. 		}

  624. 	    }

  625. 	}

  626.     }

  627. 

  628.     private static class SelectParentItemAction extends AbstractAction {

  629. 	public void actionPerformed(ActionEvent e) {

  630. 	    JMenu menu = (JMenu)e.getSource();

  631. 	    if (!menu.isEnabled())

  632. 		return;

  633. 

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

  635.                 

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

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

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

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

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

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

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

  643. 		MenuElement tmp[];

  644. 		int i,c;

  645.                     

  646. 		if(path.length > 1) {

  647. 		    MenuElement previousElement;

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

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

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

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

  652. 			    if(nextMenu == null)

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

  654. 			}

  655. 		    }

  656. 		}

  657.                     

  658. 		if(nextMenu != null) {

  659. 		    MenuElement newSelection[];

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

  661. 		    if(((JMenu)nextMenu).isTopLevelMenu()) 

  662. 			firstItem = null;

  663. 		    else {

  664. 			tmp = popup.getSubElements();

  665. 			if(tmp.length > 0) 

  666. 			    firstItem = nextEnabledChild(tmp,0);

  667. 		    }

  668. 

  669. 		    if(firstItem != null) {

  670. 			newSelection = new MenuElement[4];

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

  672. 			newSelection[1] = nextMenu;

  673. 			newSelection[2] = popup;

  674. 			newSelection[3] = firstItem;

  675. 		    } else {

  676. 			newSelection = new MenuElement[3];

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

  678. 			newSelection[1] = nextMenu;

  679. 			newSelection[2] = popup;

  680. 		    }

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

  682. 		}

  683. 	    }

  684. 	}

  685.     }

  686. 

  687.     private static class SelectChildItemAction extends AbstractAction {

  688. 	public void actionPerformed(ActionEvent e) {

  689. 	    JMenu menu = (JMenu)e.getSource();

  690. 	    if (!menu.isEnabled())

  691. 		return;

  692. 

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

  694.                 

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

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

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

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

  699. 		MenuElement subElements[];

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

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

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

  703. 		if(subElements.length > 0) {

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

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

  706. 		}

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

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

  709. 		MenuElement tmp[];

  710. 		int i,c;

  711.                     

  712. 		if(path.length > 1) {

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

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

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

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

  717. 			    if(nextMenu == null)

  718. 				nextMenu = nextEnabledChild(tmp,0);

  719. 			}

  720. 		    }

  721. 		}

  722.                     

  723. 		if(nextMenu != null) {

  724. 		    MenuElement newSelection[];

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

  726. 		    if(((JMenu)nextMenu).isTopLevelMenu()) 

  727. 			firstItem = null;

  728. 		    else {

  729. 			tmp = popup.getSubElements();

  730. 			if(tmp.length > 0) 

  731. 			    firstItem = nextEnabledChild(tmp,0);

  732. 		    }

  733. 

  734. 		    if(firstItem != null) {

  735. 			newSelection = new MenuElement[4];

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

  737. 			newSelection[1] = nextMenu;

  738. 			newSelection[2] = popup;

  739. 			newSelection[3] = firstItem;

  740. 		    } else {

  741. 			newSelection = new MenuElement[3];

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

  743. 			newSelection[1] = nextMenu;

  744. 			newSelection[2] = popup;

  745. 		    }

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

  747. 		}

  748. 	    }

  749. 	}

  750.     }

  751. 

  752. 

  753.     private class MenuDragMouseHandler implements MenuDragMouseListener {

  754. 	public void menuDragMouseEntered(MenuDragMouseEvent e) {}

  755. 	public void menuDragMouseDragged(MenuDragMouseEvent e) {

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

  757. 		return;

  758. 	    

  759. 	    MenuSelectionManager manager = e.getMenuSelectionManager();

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

  761. 	    

  762. 	    Point p = e.getPoint();

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

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

  765. 		JMenu menu = (JMenu)menuItem;

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

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

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

  769. 		     menu.getPopupMenu())) {

  770. 		    if(menu.isTopLevelMenu() || 

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

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

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

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

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

  776. 			manager.setSelectedPath(newPath);

  777. 		    } else {

  778. 			manager.setSelectedPath(path);

  779. 			setupPostTimer(menu);

  780. 		    }

  781. 		}

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

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

  784. 		if (comp == null)

  785. 		    manager.clearSelectedPath();

  786. 	    }

  787. 	    

  788. 	}

  789. 	public void menuDragMouseExited(MenuDragMouseEvent e) {}

  790. 	public void menuDragMouseReleased(MenuDragMouseEvent e) {}	    

  791.     }

  792. 

  793.     private class MenuKeyHandler implements MenuKeyListener {

  794. 	public void menuKeyTyped(MenuKeyEvent e) { 

  795.         int key = menuItem.getMnemonic();

  796.         if(key == 0)

  797.             return;

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

  799.         if(lower(key) == lower((int)(e.getKeyChar()))) {

  800.             JPopupMenu popupMenu = ((JMenu)menuItem).getPopupMenu();

  801.             MenuElement sub[] = popupMenu.getSubElements();

  802.             if(sub.length > 0) {

  803.                 MenuSelectionManager manager = e.getMenuSelectionManager();

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

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

  806.                 newPath[path.length] = popupMenu;

  807.                 newPath[path.length+1] = sub[0];

  808.                 manager.setSelectedPath(newPath);

  809.             }

  810.             e.consume();

  811.         }

  812. 	}

  813. 	public void menuKeyPressed(MenuKeyEvent e) {}

  814. 	public void menuKeyReleased(MenuKeyEvent e) {}

  815. 

  816. 	private int lower(int ascii) {

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

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

  819. 	    else

  820. 		return ascii;

  821. 	}

  822. 

  823.     }

  824. }

  825. 

  826. 

  827. 

  828.