1. /*

  2.  * @(#)BasicPopupMenuUI.java	1.67 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 javax.swing.*;

  11. import javax.swing.event.*;

  12. import javax.swing.plaf.*;

  13. import javax.swing.border.*;

  14. 

  15. import java.awt.Color;

  16. import java.awt.Component;

  17. import java.awt.Container;

  18. import java.awt.Dimension;

  19. import java.awt.Frame;

  20. import java.awt.Graphics;

  21. import java.awt.Insets;

  22. import java.awt.Point;

  23. import java.awt.Rectangle;

  24. import java.awt.Window;

  25. import java.awt.event.*;

  26. import java.util.*;

  27. 

  28. 

  29. 

  30. /**

  31.  * A Windows L&F implementation of PopupMenuUI.  This implementation 

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

  33.  *

  34.  * @version 1.67 11/29/01

  35.  * @author Georges Saab

  36.  * @author David Karlton

  37.  * @author Arnaud Weber

  38.  */

  39. public class BasicPopupMenuUI extends PopupMenuUI {

  40.     protected JPopupMenu popupMenu = null;

  41.     private Frame frame;

  42. 

  43.     public static ComponentUI createUI(JComponent x) {

  44. 	return new BasicPopupMenuUI();

  45.     }

  46. 

  47.     public void installUI(JComponent c) {

  48. 	popupMenu = (JPopupMenu) c;

  49. 

  50. 	installDefaults();

  51.         installListeners();

  52.         installKeyboardActions();

  53. 

  54.     }

  55. 

  56.     public void installDefaults() {

  57. 	if (popupMenu.getLayout() == null ||

  58. 	    popupMenu.getLayout() instanceof UIResource)

  59. 	    popupMenu.setLayout(new DefaultMenuLayout(popupMenu, BoxLayout.Y_AXIS));

  60. 

  61. 	popupMenu.setOpaque(true);

  62. 	LookAndFeel.installBorder(popupMenu, "PopupMenu.border");

  63. 	LookAndFeel.installColorsAndFont(popupMenu,

  64. 					 "PopupMenu.background",

  65. 					 "PopupMenu.foreground",

  66. 					 "PopupMenu.font");

  67.     }

  68.     

  69.     protected void installListeners() {

  70. 	if (mouseGrabber == null)

  71. 	    mouseGrabber = new MouseGrabber();

  72.     }

  73. 

  74.     protected void installKeyboardActions() {}

  75. 

  76.     public void uninstallUI(JComponent c) {

  77.         uninstallDefaults();

  78.         uninstallListeners();

  79.         uninstallKeyboardActions();

  80. 	

  81. 	popupMenu = null;

  82.     }

  83.     

  84.     protected void uninstallDefaults() {

  85. 	LookAndFeel.uninstallBorder(popupMenu);

  86.     }

  87. 

  88.     protected void uninstallListeners() {

  89.     }

  90. 

  91.     protected void uninstallKeyboardActions() {}

  92. 

  93.     public Dimension getMinimumSize(JComponent c) {

  94.         return getPreferredSize(c);

  95.     }

  96. 

  97.     public Dimension getPreferredSize(JComponent c) {

  98. 	return null;

  99.     }

  100. 

  101.     public Dimension getMaximumSize(JComponent c) {

  102.         return getPreferredSize(c);

  103.     }

  104. 

  105. ///////////////////////////////////////////////////////////////////////////////

  106. //// Grab Code

  107. ///////////////////////////////////////////////////////////////////////////////

  108.     private static Window getWindow(Component c) {

  109.         Component w = c;

  110. 

  111.         while(!(w instanceof Window) && (w!=null)) {

  112.             w = w.getParent();

  113.         }

  114.         return (Window)w;

  115.     }

  116. 

  117.     

  118.     private transient static MouseGrabber mouseGrabber = null;

  119. 

  120.     private static class MouseGrabber implements MouseListener, MouseMotionListener,WindowListener,ComponentListener, ChangeListener {

  121. 	Vector grabbed = new Vector();

  122. 	MenuElement lastGrabbed = null;

  123. 	boolean lastGrabbedMenuBarChild = false;

  124. 

  125.         public MouseGrabber() {

  126. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  127. 	    msm.addChangeListener(this);

  128.         }

  129. 	

  130. 	private void requestAddGrab(Component invoker) {

  131. 	    Window ancestor;

  132. 	    ancestor = getWindow(invoker);

  133. 

  134. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  135. 	    MenuElement[] p = msm.getSelectedPath();

  136. 	    Component excluded = null;

  137. 	    

  138. 	    for(int i = 0 ; excluded == null && i < p.length ; i++) {

  139. 		if (p[i] instanceof JPopupMenu)

  140. 		    excluded = p[i].getComponent();

  141. 	    }

  142. 

  143. 	    grabContainer(ancestor, excluded);

  144. 	}

  145. 

  146. 	private void requestRemoveGrab() {

  147. 	    ungrabContainers();

  148. 	}

  149.     

  150. 	void cancelPopupMenu() {

  151. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  152. 	    MenuElement[] p = msm.getSelectedPath();

  153. 

  154. 	    if (lastGrabbed==getFirstPopup()) {

  155. 		MenuSelectionManager.defaultManager().clearSelectedPath();

  156. 		ungrabContainers();

  157. 	    } else {

  158. 		// The cancel has cause another menu selection

  159. 		lastGrabbed=getFirstPopup();

  160. 		if (p[0] instanceof JMenuBar) {

  161. 		    lastGrabbedMenuBarChild = true;

  162. 		} else {

  163. 		    lastGrabbedMenuBarChild = false;

  164. 		}

  165. 	    }

  166. 

  167. 	}

  168. 

  169. 	MenuElement[] lastPathSelected = new MenuElement[0];

  170. 

  171. 	public void stateChanged(ChangeEvent e) {

  172. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  173. 	    MenuElement[] p = msm.getSelectedPath();

  174. 

  175. 	    if (lastPathSelected.length == 0 &&

  176. 		p.length != 0) {

  177. 		// A grab needs to be added

  178. 		Component invoker = p[0].getComponent();

  179. 		if (invoker instanceof JPopupMenu)

  180. 		    invoker = ((JPopupMenu)invoker).getInvoker();

  181. 		requestAddGrab(invoker);

  182. 	    }

  183. 

  184. 	    if (lastPathSelected.length != 0 &&

  185. 		p.length == 0) {

  186. 		// The grab should be removed

  187. 		requestRemoveGrab();

  188. 	    }

  189. 

  190. 	    // Switch between menubar children

  191. 	    if (p!=null && p.length>2 && (p[0] instanceof JMenuBar &&

  192. 					  lastGrabbedMenuBarChild == true)) {

  193. 

  194. 		if (!(lastGrabbed==getFirstPopup())) {

  195. 		    lastGrabbed=getFirstPopup();

  196. 

  197. 		    if (p[0] instanceof JMenuBar) {

  198. 			lastGrabbedMenuBarChild = true;

  199. 		    } else {

  200. 			lastGrabbedMenuBarChild = false;

  201. 		    }

  202. 		}

  203. 	    }

  204. 

  205. 	    // Remember the last path selected

  206. 	    lastPathSelected = p;

  207. 	}

  208. 	

  209. 	private MenuElement getFirstPopup() {

  210. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  211. 	    MenuElement[] p = msm.getSelectedPath();

  212. 	    MenuElement me = null;	    

  213. 

  214. 	    for(int i = 0 ; me == null && i < p.length ; i++) {

  215. 		if (p[i] instanceof JPopupMenu)

  216. 		    me = p[i];

  217. 	    }

  218. 

  219. 	    return me;

  220. 	}

  221. 	

  222. 	void grabContainer(Container c, Component excluded) {

  223. 	    if(c == excluded)

  224. 		return;

  225. 	    

  226. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  227. 	    MenuElement[] p = msm.getSelectedPath();

  228. 	    lastGrabbed = getFirstPopup();

  229. 	     if (p[0] instanceof JMenuBar) {

  230. 		 lastGrabbedMenuBarChild = true;

  231. 	     } else {

  232. 		 lastGrabbedMenuBarChild = false;

  233. 	     }

  234. 

  235. 	    if(c instanceof java.awt.Window) {

  236. 		((java.awt.Window)c).addWindowListener(this);

  237. 		((java.awt.Window)c).addComponentListener(this);

  238. 		grabbed.addElement(c);

  239. 	    }

  240. 	    synchronized(c.getTreeLock()) {

  241. 		int ncomponents = c.getComponentCount();

  242. 		Component[] component = c.getComponents();

  243. 		for (int i = 0 ; i < ncomponents ; i++) {

  244. 		    Component comp = component[i];

  245. 		    if(!comp.isVisible())

  246. 			continue;

  247. 		    comp.addMouseListener(this);

  248. 		    comp.addMouseMotionListener(this);

  249. 		    grabbed.addElement(comp);

  250.                     if (comp instanceof Container) {

  251.                         Container cont = (Container) comp;

  252.                         grabContainer(cont, excluded);

  253.                     } 

  254.                 }

  255.             }

  256. 	    

  257.         }

  258. 	

  259.         void ungrabContainers() {

  260.             int i,c;

  261.             Component cpn;

  262.             for(i=0,c=grabbed.size();i<c;i++) {

  263.                 cpn = (Component)grabbed.elementAt(i);

  264.                 if(cpn instanceof java.awt.Window) {

  265.                     ((java.awt.Window)cpn).removeWindowListener(this);

  266.                     ((java.awt.Window)cpn).removeComponentListener(this);

  267.                 } else {

  268.                     cpn.removeMouseListener(this);

  269.                     cpn.removeMouseMotionListener(this);

  270.                 }

  271.             }

  272.             grabbed = new Vector();

  273. 	    lastGrabbed = null;

  274. 	    lastGrabbedMenuBarChild = false;

  275.         }

  276. 	

  277.         public void mousePressed(MouseEvent e) {

  278.             Component c = (Component)e.getSource();

  279.             MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  280. 	    

  281. 	    cancelPopupMenu();

  282. 	    /*

  283. 	      if(msm.isComponentPartOfCurrentMenu(popupMenu) && msm.isComponentPartOfCurrentMenu(c)) {

  284. 	      return;

  285. 	      } else {

  286. 	      cancelPopupMenu();

  287. 	      }

  288. 	      */

  289.         }

  290.         

  291.         public void mouseReleased(MouseEvent e) {

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

  293.         }

  294.         public void mouseEntered(MouseEvent e) {

  295.             // MenuSelectionManager.defaultManager().processMouseEvent(e);

  296.         }

  297.         public void mouseExited(MouseEvent e) {

  298.             // MenuSelectionManager.defaultManager().processMouseEvent(e);

  299.         }

  300.         public void mouseMoved(MouseEvent e) {

  301.             // MenuSelectionManager.defaultManager().processMouseEvent(e);

  302.         }

  303.         public void mouseDragged(MouseEvent e) {

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

  305.         }

  306.         public void mouseClicked(MouseEvent e) {

  307.         }

  308.         public void componentResized(ComponentEvent e) {

  309.             cancelPopupMenu();

  310.         }

  311.         public void componentMoved(ComponentEvent e) {

  312.             cancelPopupMenu();

  313.         }

  314.         public void componentShown(ComponentEvent e) {

  315.             cancelPopupMenu();

  316.         }

  317.         public void componentHidden(ComponentEvent e) {

  318.             cancelPopupMenu();

  319.         }

  320.         public void windowOpened(WindowEvent e) {}

  321.         public void windowClosing(WindowEvent e) {

  322.             cancelPopupMenu();

  323.         }

  324.         public void windowClosed(WindowEvent e) {

  325.             cancelPopupMenu();

  326.         }

  327.         public void windowIconified(WindowEvent e) {

  328.             cancelPopupMenu();

  329.         }

  330.         public void windowDeiconified(WindowEvent e) {}

  331.         public void windowActivated(WindowEvent e) {

  332.             /*   cancelPopupMenu(); cannot do this because

  333.                  this might happen when using cascading heavy weight 

  334.                  menus

  335.                  */

  336.         }

  337.         public void windowDeactivated(WindowEvent e) {

  338.             /*   cancelPopupMenu(); cannot do this because

  339.                  this might happen when using cascading heavy weight 

  340.                  menus

  341.                  */

  342.         }

  343.     }

  344. 

  345. }

  346. 

  347. 

  348. 

  349.