1. /*

  2.  * @(#)BasicPopupMenuUI.java	1.69 00/02/02

  3.  *

  4.  * Copyright 1997-2000 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 javax.swing.*;

  14. import javax.swing.event.*;

  15. import javax.swing.plaf.*;

  16. import javax.swing.border.*;

  17. 

  18. import java.awt.Color;

  19. import java.awt.Component;

  20. import java.awt.Container;

  21. import java.awt.Dimension;

  22. import java.awt.Frame;

  23. import java.awt.Graphics;

  24. import java.awt.Insets;

  25. import java.awt.Point;

  26. import java.awt.Rectangle;

  27. import java.awt.Window;

  28. import java.awt.event.*;

  29. import java.util.*;

  30. 

  31. 

  32. 

  33. /**

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

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

  36.  *

  37.  * @version 1.69 02/02/00

  38.  * @author Georges Saab

  39.  * @author David Karlton

  40.  * @author Arnaud Weber

  41.  */

  42. public class BasicPopupMenuUI extends PopupMenuUI {

  43.     protected JPopupMenu popupMenu = null;

  44.     private Frame frame;

  45. 

  46.     public static ComponentUI createUI(JComponent x) {

  47. 	return new BasicPopupMenuUI();

  48.     }

  49. 

  50.     public void installUI(JComponent c) {

  51. 	popupMenu = (JPopupMenu) c;

  52. 

  53. 	installDefaults();

  54.         installListeners();

  55.         installKeyboardActions();

  56. 

  57.     }

  58. 

  59.     public void installDefaults() {

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

  61. 	    popupMenu.getLayout() instanceof UIResource)

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

  63. 

  64. 	popupMenu.setOpaque(true);

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

  66. 	LookAndFeel.installColorsAndFont(popupMenu,

  67. 					 "PopupMenu.background",

  68. 					 "PopupMenu.foreground",

  69. 					 "PopupMenu.font");

  70.     }

  71.     

  72.     protected void installListeners() {

  73. 	if (mouseGrabber == null)

  74. 	    mouseGrabber = new MouseGrabber();

  75.     }

  76. 

  77.     protected void installKeyboardActions() {}

  78. 

  79.     public void uninstallUI(JComponent c) {

  80.         uninstallDefaults();

  81.         uninstallListeners();

  82.         uninstallKeyboardActions();

  83. 	

  84. 	popupMenu = null;

  85.     }

  86.     

  87.     protected void uninstallDefaults() {

  88. 	LookAndFeel.uninstallBorder(popupMenu);

  89.     }

  90. 

  91.     protected void uninstallListeners() {

  92.     }

  93. 

  94.     protected void uninstallKeyboardActions() {}

  95. 

  96.     public Dimension getMinimumSize(JComponent c) {

  97.         return getPreferredSize(c);

  98.     }

  99. 

  100.     public Dimension getPreferredSize(JComponent c) {

  101. 	return null;

  102.     }

  103. 

  104.     public Dimension getMaximumSize(JComponent c) {

  105.         return getPreferredSize(c);

  106.     }

  107. 

  108. 

  109. ///////////////////////////////////////////////////////////////////////////////

  110. //// Grab Code

  111. ///////////////////////////////////////////////////////////////////////////////

  112.     private static Window getWindow(Component c) {

  113.         Component w = c;

  114. 

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

  116.             w = w.getParent();

  117.         }

  118.         return (Window)w;

  119.     }

  120. 

  121.     

  122.     private transient static MouseGrabber mouseGrabber = null;

  123. 

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

  125. 	Vector grabbed = new Vector();

  126. 	MenuElement lastGrabbed = null;

  127. 	boolean lastGrabbedMenuBarChild = false;

  128. 

  129.         public MouseGrabber() {

  130. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  131. 	    msm.addChangeListener(this);

  132.         }

  133. 	

  134. 	private void requestAddGrab(Component invoker) {

  135. 	    Window ancestor;

  136. 	    ancestor = getWindow(invoker);

  137. 

  138. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

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

  140. 	    Component excluded = null;

  141. 	    

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

  143. 		if (p[i] instanceof JPopupMenu)

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

  145. 	    }

  146. 

  147. 	    grabContainer(ancestor, excluded);

  148. 	}

  149. 

  150. 	private void requestRemoveGrab() {

  151. 	    ungrabContainers();

  152. 	}

  153.     

  154. 	void cancelPopupMenu() {

  155. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

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

  157. 

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

  159. 		MenuSelectionManager.defaultManager().clearSelectedPath();

  160. 		ungrabContainers();

  161. 	    } else {

  162. 		// The cancel has cause another menu selection

  163. 		lastGrabbed=getFirstPopup();

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

  165. 		    lastGrabbedMenuBarChild = true;

  166. 		} else {

  167. 		    lastGrabbedMenuBarChild = false;

  168. 		}

  169. 	    }

  170. 

  171. 	}

  172. 

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

  174. 

  175. 	public void stateChanged(ChangeEvent e) {

  176. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

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

  178. 

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

  180. 		p.length != 0) {

  181. 		// A grab needs to be added

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

  183. 		if (invoker instanceof JPopupMenu)

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

  185. 		requestAddGrab(invoker);

  186. 	    }

  187. 

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

  189. 		p.length == 0) {

  190. 		// The grab should be removed

  191. 		requestRemoveGrab();

  192. 	    }

  193. 

  194. 	    // Switch between menubar children

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

  196. 					  lastGrabbedMenuBarChild == true)) {

  197. 

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

  199. 		    lastGrabbed=getFirstPopup();

  200. 

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

  202. 			lastGrabbedMenuBarChild = true;

  203. 		    } else {

  204. 			lastGrabbedMenuBarChild = false;

  205. 		    }

  206. 		}

  207. 	    }

  208. 

  209. 	    // Remember the last path selected

  210. 	    lastPathSelected = p;

  211. 	}

  212. 	

  213. 	private MenuElement getFirstPopup() {

  214. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

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

  216. 	    MenuElement me = null;	    

  217. 

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

  219. 		if (p[i] instanceof JPopupMenu)

  220. 		    me = p[i];

  221. 	    }

  222. 

  223. 	    return me;

  224. 	}

  225. 	

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

  227. 	    if(c == excluded)

  228. 		return;

  229. 	    

  230. 	    MenuSelectionManager msm = MenuSelectionManager.defaultManager();

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

  232. 	    lastGrabbed = getFirstPopup();

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

  234. 		 lastGrabbedMenuBarChild = true;

  235. 	     } else {

  236. 		 lastGrabbedMenuBarChild = false;

  237. 	     }

  238. 

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

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

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

  242. 		grabbed.addElement(c);

  243. 	    }

  244. 	    synchronized(c.getTreeLock()) {

  245. 		int ncomponents = c.getComponentCount();

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

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

  248. 		    Component comp = component[i];

  249. 		    if(!comp.isVisible())

  250. 			continue;

  251. 		    comp.addMouseListener(this);

  252. 		    comp.addMouseMotionListener(this);

  253. 		    grabbed.addElement(comp);

  254.                     if (comp instanceof Container) {

  255.                         Container cont = (Container) comp;

  256.                         grabContainer(cont, excluded);

  257.                     } 

  258.                 }

  259.             }

  260. 	    

  261.         }

  262. 	

  263.         void ungrabContainers() {

  264.             int i,c;

  265.             Component cpn;

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

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

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

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

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

  271.                 } else {

  272.                     cpn.removeMouseListener(this);

  273.                     cpn.removeMouseMotionListener(this);

  274.                 }

  275.             }

  276.             grabbed = new Vector();

  277. 	    lastGrabbed = null;

  278. 	    lastGrabbedMenuBarChild = false;

  279.         }

  280. 	

  281.         public void mousePressed(MouseEvent e) {

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

  283.             MenuSelectionManager msm = MenuSelectionManager.defaultManager();

  284. 	    

  285. 	    cancelPopupMenu();

  286. 	    /*

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

  288. 	      return;

  289. 	      } else {

  290. 	      cancelPopupMenu();

  291. 	      }

  292. 	      */

  293.         }

  294.         

  295.         public void mouseReleased(MouseEvent e) {

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

  297.         }

  298.         public void mouseEntered(MouseEvent e) {

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

  300.         }

  301.         public void mouseExited(MouseEvent e) {

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

  303.         }

  304.         public void mouseMoved(MouseEvent e) {

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

  306.         }

  307.         public void mouseDragged(MouseEvent e) {

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

  309.         }

  310.         public void mouseClicked(MouseEvent e) {

  311.         }

  312.         public void componentResized(ComponentEvent e) {

  313.             cancelPopupMenu();

  314.         }

  315.         public void componentMoved(ComponentEvent e) {

  316.             cancelPopupMenu();

  317.         }

  318.         public void componentShown(ComponentEvent e) {

  319.             cancelPopupMenu();

  320.         }

  321.         public void componentHidden(ComponentEvent e) {

  322.             cancelPopupMenu();

  323.         }

  324.         public void windowOpened(WindowEvent e) {}

  325.         public void windowClosing(WindowEvent e) {

  326.             cancelPopupMenu();

  327.         }

  328.         public void windowClosed(WindowEvent e) {

  329.             cancelPopupMenu();

  330.         }

  331.         public void windowIconified(WindowEvent e) {

  332.             cancelPopupMenu();

  333.         }

  334.         public void windowDeiconified(WindowEvent e) {}

  335.         public void windowActivated(WindowEvent e) {

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

  337.                  this might happen when using cascading heavy weight 

  338.                  menus

  339.                  */

  340.         }

  341.         public void windowDeactivated(WindowEvent e) {

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

  343.                  this might happen when using cascading heavy weight 

  344.                  menus

  345.                  */

  346.         }

  347.     }

  348. 

  349.     public boolean isPopupTrigger(MouseEvent e) {

  350. 	return ((e.getID()==MouseEvent.MOUSE_RELEASED) 

  351. 		&& ((e.getModifiers() & MouseEvent.BUTTON3_MASK)!=0));

  352.     }	    

  353. 

  354. }

  355. 

  356. 

  357. 

  358.