1. /*

  2.  * @(#)BasicMenuItemUI.java	1.101 00/04/05

  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 licence terms.

  8.  */

  9.  

  10. package javax.swing.plaf.basic;

  11. 

  12. import java.awt.*;

  13. import java.awt.event.*;

  14. import java.beans.PropertyChangeEvent;

  15. import java.beans.PropertyChangeListener;

  16. 

  17. import javax.swing.*;

  18. import javax.swing.event.*;

  19. import javax.swing.border.*;

  20. import javax.swing.plaf.*;

  21. import javax.swing.text.View;

  22. 

  23. 

  24. /**

  25.  * BasicMenuItem implementation

  26.  *

  27.  * @version 1.101 04/05/00

  28.  * @author Georges Saab

  29.  * @author David Karlton

  30.  * @author Arnaud Weber

  31.  * @author Fredrik Lagerblad

  32.  */

  33. public class BasicMenuItemUI extends MenuItemUI

  34. {

  35.     protected JMenuItem menuItem = null;

  36.     protected Color selectionBackground;

  37.     protected Color selectionForeground;    

  38.     protected Color disabledForeground;

  39.     protected Color acceleratorForeground;

  40.     protected Color acceleratorSelectionForeground;

  41.     private   String acceleratorDelimiter;

  42. 

  43.     protected int defaultTextIconGap;

  44.     protected Font acceleratorFont;

  45. 

  46.     protected MouseInputListener mouseInputListener;

  47.     protected MenuDragMouseListener menuDragMouseListener;

  48.     protected MenuKeyListener menuKeyListener;

  49.     private   PropertyChangeListener propertyChangeListener;

  50.     

  51.     protected Icon arrowIcon = null;

  52.     protected Icon checkIcon = null;

  53. 

  54.     protected boolean oldBorderPainted;

  55. 

  56.     /** Used for accelerator binding, lazily created. */

  57.     InputMap windowInputMap;

  58. 

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

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

  61. 

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

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

  64. 

  65.     /* Client Property keys for text and accelerator text widths */

  66.     private static final String MAX_TEXT_WIDTH =  "maxTextWidth";

  67.     private static final String MAX_ACC_WIDTH  =  "maxAccWidth";

  68. 

  69.     public static ComponentUI createUI(JComponent c) {

  70.         return new BasicMenuItemUI();

  71.     }

  72. 

  73.     public void installUI(JComponent c) {

  74.         menuItem = (JMenuItem) c;

  75. 

  76.         installDefaults();

  77.         installComponents(menuItem);

  78.         installListeners();

  79.         installKeyboardActions();

  80.     }

  81. 	

  82. 

  83.     protected void installDefaults() {

  84.         String prefix = getPropertyPrefix();

  85. 

  86.         acceleratorFont = UIManager.getFont("MenuItem.acceleratorFont");

  87. 

  88.         menuItem.setOpaque(true);

  89.         if(menuItem.getMargin() == null || 

  90.            (menuItem.getMargin() instanceof UIResource)) {

  91.             menuItem.setMargin(UIManager.getInsets(prefix + ".margin"));

  92.         }

  93. 

  94.         defaultTextIconGap = 4;   // Should be from table

  95. 

  96.         LookAndFeel.installBorder(menuItem, prefix + ".border");

  97.         oldBorderPainted = menuItem.isBorderPainted();

  98.         menuItem.setBorderPainted( ( (Boolean) (UIManager.get(prefix + ".borderPainted")) ).booleanValue() );

  99.         LookAndFeel.installColorsAndFont(menuItem,

  100.                                          prefix + ".background",

  101.                                          prefix + ".foreground",

  102.                                          prefix + ".font");

  103.         

  104.         // MenuItem specific defaults

  105.         if (selectionBackground == null || 

  106.             selectionBackground instanceof UIResource) {

  107.             selectionBackground = 

  108.                 UIManager.getColor(prefix + ".selectionBackground");

  109.         }

  110.         if (selectionForeground == null || 

  111.             selectionForeground instanceof UIResource) {

  112.             selectionForeground = 

  113.                 UIManager.getColor(prefix + ".selectionForeground");

  114.         }

  115.         if (disabledForeground == null || 

  116.             disabledForeground instanceof UIResource) {

  117.             disabledForeground = 

  118.                 UIManager.getColor(prefix + ".disabledForeground");

  119.         }

  120.         if (acceleratorForeground == null || 

  121.             acceleratorForeground instanceof UIResource) {

  122.             acceleratorForeground = 

  123.                 UIManager.getColor(prefix + ".acceleratorForeground");

  124.         }

  125.         if (acceleratorSelectionForeground == null || 

  126.             acceleratorSelectionForeground instanceof UIResource) {

  127.             acceleratorSelectionForeground = 

  128.                 UIManager.getColor(prefix + ".acceleratorSelectionForeground");

  129.         }

  130. 	// Get accelerator delimiter

  131. 	acceleratorDelimiter = 

  132. 	    UIManager.getString("MenuItem.acceleratorDelimiter");

  133. 	if (acceleratorDelimiter == null) { acceleratorDelimiter = "+"; }

  134.         // Icons

  135.         if (arrowIcon == null ||

  136.             arrowIcon instanceof UIResource) {

  137.             arrowIcon = UIManager.getIcon(prefix + ".arrowIcon");

  138.         }

  139.         if (checkIcon == null ||

  140.             checkIcon instanceof UIResource) {

  141.             checkIcon = UIManager.getIcon(prefix + ".checkIcon");

  142.         }

  143.     }

  144. 

  145.     /**

  146.      * @since 1.3

  147.      */

  148.     protected void installComponents(JMenuItem menuItem){

  149.  	BasicHTML.updateRenderer(menuItem, menuItem.getText());

  150.     }

  151. 

  152.     protected String getPropertyPrefix() {

  153.         return "MenuItem";

  154.     }

  155. 

  156.     protected void installListeners() {

  157.         mouseInputListener = createMouseInputListener(menuItem);

  158.         menuDragMouseListener = createMenuDragMouseListener(menuItem);

  159.         menuKeyListener = createMenuKeyListener(menuItem);

  160.         propertyChangeListener = createPropertyChangeListener(menuItem);

  161. 

  162.         menuItem.addMouseListener(mouseInputListener);

  163.         menuItem.addMouseMotionListener(mouseInputListener);

  164.         menuItem.addMenuDragMouseListener(menuDragMouseListener);

  165.         menuItem.addMenuKeyListener(menuKeyListener);

  166. 	menuItem.addPropertyChangeListener(propertyChangeListener);

  167.     }

  168. 

  169.     protected void installKeyboardActions() {

  170. 	ActionMap actionMap = getActionMap();

  171. 	

  172. 	SwingUtilities.replaceUIActionMap(menuItem, actionMap);

  173. 	updateAcceleratorBinding();

  174.     }

  175. 

  176.     public void uninstallUI(JComponent c) {

  177. 	menuItem = (JMenuItem)c;

  178.         uninstallDefaults();

  179.         uninstallComponents(menuItem);

  180.         uninstallListeners();

  181.         uninstallKeyboardActions();

  182. 

  183. 	

  184. 	//Remove the textWidth and accWidth values from the parent's Client Properties.

  185. 	Container parent = menuItem.getParent();

  186. 	if ( (parent != null && parent instanceof JComponent)  && 

  187. 	     !(menuItem instanceof JMenu && ((JMenu) menuItem).isTopLevelMenu())) {

  188. 	    JComponent p = (JComponent) parent;

  189. 	    p.putClientProperty(BasicMenuItemUI.MAX_ACC_WIDTH, null );

  190. 	    p.putClientProperty(BasicMenuItemUI.MAX_TEXT_WIDTH, null ); 

  191. 	}

  192. 

  193. 	menuItem = null;

  194.     }

  195. 

  196. 

  197.     protected void uninstallDefaults() {

  198.         LookAndFeel.uninstallBorder(menuItem);

  199.         menuItem.setBorderPainted( oldBorderPainted );

  200.         if (menuItem.getMargin() instanceof UIResource)

  201.             menuItem.setMargin(null);

  202.         if (arrowIcon instanceof UIResource)

  203.             arrowIcon = null;

  204.         if (checkIcon instanceof UIResource)

  205.             checkIcon = null;

  206.     }

  207. 

  208.     /**

  209.      * @since 1.3

  210.      */

  211.     protected void uninstallComponents(JMenuItem menuItem){

  212. 	BasicHTML.updateRenderer(menuItem, "");

  213.     }

  214. 

  215.     protected void uninstallListeners() {

  216.         menuItem.removeMouseListener(mouseInputListener);

  217.         menuItem.removeMouseMotionListener(mouseInputListener);

  218.         menuItem.removeMenuDragMouseListener(menuDragMouseListener);

  219.         menuItem.removeMenuKeyListener(menuKeyListener);

  220.         menuItem.removePropertyChangeListener(propertyChangeListener);

  221. 

  222.         mouseInputListener = null;

  223.         menuDragMouseListener = null;

  224.         menuKeyListener = null;

  225. 	propertyChangeListener = null;

  226.     }

  227. 

  228.     protected void uninstallKeyboardActions() {

  229. 	SwingUtilities.replaceUIActionMap(menuItem, null);

  230. 	if (windowInputMap != null) {

  231. 	    SwingUtilities.replaceUIInputMap(menuItem, JComponent.

  232. 					   WHEN_IN_FOCUSED_WINDOW, null);

  233. 	    windowInputMap = null;

  234. 	}

  235.     }

  236. 

  237.     protected MouseInputListener createMouseInputListener(JComponent c) {

  238.         return new MouseInputHandler();

  239.     }

  240. 

  241.     protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {

  242.         return new MenuDragMouseHandler();

  243.     }

  244. 

  245.     protected MenuKeyListener createMenuKeyListener(JComponent c) {

  246.         return new MenuKeyHandler();

  247.     }

  248. 

  249.     private PropertyChangeListener createPropertyChangeListener(JComponent c) {

  250.         return new PropertyChangeHandler();

  251.     }

  252. 

  253.     ActionMap getActionMap() {

  254. 	String propertyPrefix = getPropertyPrefix();

  255. 	String uiKey = propertyPrefix + ".actionMap";

  256. 	ActionMap am = (ActionMap)UIManager.get(uiKey);

  257. 	if (am == null) {

  258. 	    am = createActionMap();

  259. 	    UIManager.put(uiKey, am);

  260. 	}

  261. 	return am;

  262.     }

  263. 

  264.     ActionMap createActionMap() {

  265. 	ActionMap map = new ActionMapUIResource();

  266. 	map.put("doClick", new ClickAction());

  267. 	return map;

  268.     }

  269. 

  270.     InputMap createInputMap(int condition) {

  271. 	if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {

  272. 	    return new ComponentInputMapUIResource(menuItem);

  273. 	}

  274. 	return null;

  275.     }

  276. 

  277.     void updateAcceleratorBinding() {

  278. 	KeyStroke accelerator = menuItem.getAccelerator();

  279. 

  280. 	if (accelerator != null) {

  281. 	    if (windowInputMap == null) {

  282. 		windowInputMap = createInputMap(JComponent.

  283. 						WHEN_IN_FOCUSED_WINDOW);

  284. 		SwingUtilities.replaceUIInputMap(menuItem,

  285. 			   JComponent.WHEN_IN_FOCUSED_WINDOW, windowInputMap);

  286. 	    }

  287. 	    windowInputMap.put(accelerator, "doClick");

  288. 	}

  289. 	else if (windowInputMap != null) {

  290. 	    windowInputMap.clear();

  291. 	}

  292.     }

  293. 

  294.     public Dimension getMinimumSize(JComponent c) {

  295. 	Dimension d = null;

  296.  	View v = (View) c.getClientProperty(BasicHTML.propertyKey);

  297.  	if (v != null) {

  298. 	    d = getPreferredSize(c);

  299.  	    d.width -= v.getPreferredSpan(View.X_AXIS) - v.getMinimumSpan(View.X_AXIS);

  300.  	}

  301.  	return d;	

  302.     }

  303. 

  304.     public Dimension getPreferredSize(JComponent c) {

  305.         return getPreferredMenuItemSize(c,

  306.                                         checkIcon, 

  307.                                         arrowIcon, 

  308.                                         defaultTextIconGap);

  309.     }

  310. 

  311.     public Dimension getMaximumSize(JComponent c) {

  312. 	Dimension d = null;

  313.  	View v = (View) c.getClientProperty(BasicHTML.propertyKey);

  314.  	if (v != null) {

  315. 	    d = getPreferredSize(c);

  316.  	    d.width += v.getMaximumSpan(View.X_AXIS) - v.getPreferredSpan(View.X_AXIS);

  317.  	}

  318.  	return d;

  319.     }

  320. 

  321.   // these rects are used for painting and preferredsize calculations.

  322.   // they used to be regenerated constantly.  Now they are reused.

  323.     static Rectangle zeroRect = new Rectangle(0,0,0,0);

  324.     static Rectangle iconRect = new Rectangle();

  325.     static Rectangle textRect = new Rectangle();

  326.     static Rectangle acceleratorRect = new Rectangle();

  327.     static Rectangle checkIconRect = new Rectangle();

  328.     static Rectangle arrowIconRect = new Rectangle();

  329.     static Rectangle viewRect = new Rectangle(Short.MAX_VALUE, Short.MAX_VALUE);

  330.     static Rectangle r = new Rectangle();

  331. 

  332.     private void resetRects() {

  333.         iconRect.setBounds(zeroRect);

  334.         textRect.setBounds(zeroRect);

  335.         acceleratorRect.setBounds(zeroRect);

  336.         checkIconRect.setBounds(zeroRect);

  337.         arrowIconRect.setBounds(zeroRect);

  338.         viewRect.setBounds(0,0,Short.MAX_VALUE, Short.MAX_VALUE);

  339.         r.setBounds(zeroRect);

  340.     }

  341. 

  342.     protected Dimension getPreferredMenuItemSize(JComponent c,

  343.                                                      Icon checkIcon,

  344.                                                      Icon arrowIcon,

  345.                                                      int defaultTextIconGap) {

  346.         JMenuItem b = (JMenuItem) c;

  347.         Icon icon = (Icon) b.getIcon(); 

  348.         String text = b.getText();

  349.         KeyStroke accelerator =  b.getAccelerator();

  350.         String acceleratorText = "";

  351. 

  352.         if (accelerator != null) {

  353.             int modifiers = accelerator.getModifiers();

  354.             if (modifiers > 0) {

  355.                 acceleratorText = KeyEvent.getKeyModifiersText(modifiers);

  356.                 //acceleratorText += "-";

  357.                 acceleratorText += acceleratorDelimiter;

  358.           }

  359.             acceleratorText += KeyEvent.getKeyText(accelerator.getKeyCode());

  360.         }

  361. 

  362.         Font font = b.getFont();

  363.         FontMetrics fm = b.getToolkit().getFontMetrics(font);

  364.         FontMetrics fmAccel = b.getToolkit().getFontMetrics( acceleratorFont );

  365. 

  366.         resetRects();

  367.         

  368.         layoutMenuItem(

  369.                   fm, text, fmAccel, acceleratorText, icon, checkIcon, arrowIcon,

  370.                   b.getVerticalAlignment(), b.getHorizontalAlignment(),

  371.                   b.getVerticalTextPosition(), b.getHorizontalTextPosition(),

  372.                   viewRect, iconRect, textRect, acceleratorRect, checkIconRect, arrowIconRect,

  373.                   text == null ? 0 : defaultTextIconGap,

  374.                   defaultTextIconGap

  375.                   );

  376.         // find the union of the icon and text rects

  377.         r.setBounds(textRect);

  378.         r = SwingUtilities.computeUnion(iconRect.x,

  379.                                         iconRect.y,

  380.                                         iconRect.width,

  381.                                         iconRect.height,

  382.                                         r);

  383.         //   r = iconRect.union(textRect);

  384. 

  385. 	

  386. 	// To make the accelerator texts appear in a column, find the widest MenuItem text

  387. 	// and the widest accelerator text.

  388. 

  389. 	//Get the parent, which stores the information.

  390. 	Container parent = menuItem.getParent();

  391. 	

  392. 	//Check the parent, and see that it is not a top-level menu.

  393.         if (parent != null && parent instanceof JComponent && 

  394. 	    !(menuItem instanceof JMenu && ((JMenu) menuItem).isTopLevelMenu())) {

  395. 	    JComponent p = (JComponent) parent;

  396. 	    

  397. 	    //Get widest text so far from parent, if no one exists null is returned.

  398. 	    Integer maxTextWidth = (Integer) p.getClientProperty(BasicMenuItemUI.MAX_TEXT_WIDTH);

  399. 	    Integer maxAccWidth = (Integer) p.getClientProperty(BasicMenuItemUI.MAX_ACC_WIDTH);

  400. 	    

  401. 	    int maxTextValue = maxTextWidth!=null ? maxTextWidth.intValue() : 0;

  402. 	    int maxAccValue = maxAccWidth!=null ? maxAccWidth.intValue() : 0;

  403. 	    

  404. 	    //Compare the text widths, and adjust the r.width to the widest.

  405. 	    if (r.width < maxTextValue) {

  406. 		r.width = maxTextValue;

  407. 	    } else {

  408. 		p.putClientProperty(BasicMenuItemUI.MAX_TEXT_WIDTH, new Integer(r.width) );

  409. 	    }

  410. 	    

  411. 	  //Compare the accelarator widths.

  412. 	    if (acceleratorRect.width > maxAccValue) {

  413. 		maxAccValue = acceleratorRect.width;

  414. 		p.putClientProperty(BasicMenuItemUI.MAX_ACC_WIDTH, new Integer(acceleratorRect.width) );

  415. 	    }

  416. 	    

  417. 	    //Add on the widest accelerator 

  418. 	    r.width += maxAccValue;

  419. 	    r.width += defaultTextIconGap;

  420. 	    

  421. 	}

  422. 	

  423. 	if( useCheckAndArrow() ) {

  424. 	    // Add in the checkIcon

  425. 	    r.width += checkIconRect.width;

  426. 	    r.width += defaultTextIconGap;

  427. 

  428. 	    // Add in the arrowIcon

  429. 	    r.width += defaultTextIconGap;

  430. 	    r.width += arrowIconRect.width;

  431.         }	

  432. 

  433. 	r.width += 2*defaultTextIconGap;

  434. 

  435.         Insets insets = b.getInsets();

  436.         if(insets != null) {

  437.             r.width += insets.left + insets.right;

  438.             r.height += insets.top + insets.bottom;

  439.         }

  440. 

  441.         // if the width is even, bump it up one. This is critical

  442.         // for the focus dash line to draw properly

  443.         if(r.width%2 == 0) {

  444.             r.width++;

  445.         }

  446. 

  447.         // if the height is even, bump it up one. This is critical

  448.         // for the text to center properly

  449.         if(r.height%2 == 0) {

  450.             r.height++;

  451.         }

  452. /*

  453. 	if(!(b instanceof JMenu && ((JMenu) b).isTopLevelMenu()) ) {

  454. 	    

  455. 	    // Container parent = menuItem.getParent();

  456. 	    JComponent p = (JComponent) parent;

  457. 	    

  458. 	    System.out.println("MaxText: "+p.getClientProperty(BasicMenuItemUI.MAX_TEXT_WIDTH));

  459. 	    System.out.println("MaxACC"+p.getClientProperty(BasicMenuItemUI.MAX_ACC_WIDTH));

  460. 	    

  461. 	    System.out.println("returning pref.width: " + r.width);

  462. 	    System.out.println("Current getSize: " + b.getSize() + "\n");

  463.         }*/

  464. 	return r.getSize();

  465.     }

  466. 

  467.     /**

  468.      * We draw the background in paintMenuItem()

  469.      * so override update (which fills the background of opaque

  470.      * components by default) to just call paint().

  471.      *

  472.      */

  473.     public void update(Graphics g, JComponent c) {

  474.         paint(g, c);

  475.     }

  476. 

  477.     public void paint(Graphics g, JComponent c) {

  478.         paintMenuItem(g, c, checkIcon, arrowIcon,

  479.                       selectionBackground, selectionForeground,

  480.                       defaultTextIconGap);

  481.     }

  482. 

  483. 

  484.     protected void paintMenuItem(Graphics g, JComponent c,

  485.                                      Icon checkIcon, Icon arrowIcon,

  486.                                      Color background, Color foreground,

  487.                                      int defaultTextIconGap) {

  488.         JMenuItem b = (JMenuItem) c;

  489.         ButtonModel model = b.getModel();

  490. 

  491.         //   Dimension size = b.getSize();

  492.         int menuWidth = b.getWidth();

  493.         int menuHeight = b.getHeight();

  494.         Insets i = c.getInsets();

  495. 	

  496.         resetRects();

  497. 

  498.         viewRect.setBounds( 0, 0, menuWidth, menuHeight );

  499. 

  500.         viewRect.x += i.left;

  501.         viewRect.y += i.top;

  502.         viewRect.width -= (i.right + viewRect.x);

  503.         viewRect.height -= (i.bottom + viewRect.y);

  504. 

  505. 

  506.         Font holdf = g.getFont();

  507.         Font f = c.getFont();

  508.         g.setFont( f );

  509.         FontMetrics fm = g.getFontMetrics( f );

  510.         FontMetrics fmAccel = g.getFontMetrics( acceleratorFont );

  511. 

  512.         // Paint background

  513.         Color holdc = g.getColor();

  514.         if(c.isOpaque()) {

  515.             if (model.isArmed()|| (c instanceof JMenu && model.isSelected())) {

  516.                 g.setColor(background);

  517.                 g.fillRect(0,0, menuWidth, menuHeight);

  518.             } else {

  519.                 g.setColor(b.getBackground());

  520.                 g.fillRect(0,0, menuWidth, menuHeight);

  521.             }

  522.             g.setColor(holdc);

  523.         }

  524. 

  525.         // get Accelerator text

  526.         KeyStroke accelerator =  b.getAccelerator();

  527.         String acceleratorText = "";

  528.         if (accelerator != null) {

  529.             int modifiers = accelerator.getModifiers();

  530.             if (modifiers > 0) {

  531.                 acceleratorText = KeyEvent.getKeyModifiersText(modifiers);

  532.                 //acceleratorText += "-";

  533.                 acceleratorText += acceleratorDelimiter;

  534.           }

  535.             acceleratorText += KeyEvent.getKeyText(accelerator.getKeyCode());

  536.         }

  537.         

  538.         // layout the text and icon

  539.         String text = layoutMenuItem(

  540.             fm, b.getText(), fmAccel, acceleratorText, b.getIcon(),

  541.             checkIcon, arrowIcon,

  542.             b.getVerticalAlignment(), b.getHorizontalAlignment(),

  543.             b.getVerticalTextPosition(), b.getHorizontalTextPosition(),

  544.             viewRect, iconRect, textRect, acceleratorRect, 

  545.             checkIconRect, arrowIconRect,

  546.             b.getText() == null ? 0 : defaultTextIconGap,

  547.             defaultTextIconGap

  548.         );

  549.           

  550.         // Paint the Check

  551.         if (checkIcon != null) {

  552.             if(model.isArmed() || (c instanceof JMenu && model.isSelected())) {

  553.                 g.setColor(foreground);

  554.             } else {

  555.                 g.setColor(holdc);

  556.             }

  557.             if( useCheckAndArrow() )

  558. 		checkIcon.paintIcon(c, g, checkIconRect.x, checkIconRect.y);

  559.             g.setColor(holdc);

  560.         }

  561. 

  562.         // Paint the Icon

  563.         if(b.getIcon() != null) { 

  564.             Icon icon;

  565.             if(!model.isEnabled()) {

  566.                 icon = (Icon) b.getDisabledIcon();

  567.             } else if(model.isPressed() && model.isArmed()) {

  568.                 icon = (Icon) b.getPressedIcon();

  569.                 if(icon == null) {

  570.                     // Use default icon

  571.                     icon = (Icon) b.getIcon();

  572.                 } 

  573.             } else {

  574.                 icon = (Icon) b.getIcon();

  575.             }

  576.               

  577.             if (icon!=null)   

  578.                 icon.paintIcon(c, g, iconRect.x, iconRect.y);

  579.         }

  580. 

  581.         // Draw the Text

  582.         if(text != null) {

  583.  	    View v = (View) c.getClientProperty(BasicHTML.propertyKey);

  584.  	    if (v != null) {

  585.  		v.paint(g, textRect);

  586.  	    } else {

  587. 		if(!model.isEnabled()) {

  588. 		    // *** paint the text disabled

  589. 		    if ( UIManager.get("MenuItem.disabledForeground") instanceof Color )

  590. 			{

  591. 			    g.setColor( UIManager.getColor("MenuItem.disabledForeground") );

  592. 			    BasicGraphicsUtils.drawString(g,text,model.getMnemonic(),

  593. 							  textRect.x, textRect.y + fm.getAscent());

  594. 			}

  595. 		    else

  596. 			{

  597. 			    g.setColor(b.getBackground().brighter());

  598. 			    BasicGraphicsUtils.drawString(g,text,model.getMnemonic(),

  599. 							  textRect.x, textRect.y + fm.getAscent());

  600. 			    g.setColor(b.getBackground().darker());

  601. 			    BasicGraphicsUtils.drawString(g,text,model.getMnemonic(),

  602. 							  textRect.x - 1, textRect.y + fm.getAscent() - 1);

  603. 			}

  604. 		} else {

  605. 		    // *** paint the text normally

  606. 		    if (model.isArmed()|| (c instanceof JMenu && model.isSelected())) {

  607. 			g.setColor(foreground);

  608. 		    } else {

  609. 			g.setColor(holdc);

  610. 		    }

  611. 		    BasicGraphicsUtils.drawString(g,text, 

  612. 						  model.getMnemonic(),

  613. 						  textRect.x,

  614. 						  textRect.y + fm.getAscent());

  615. 		}

  616. 	    }

  617. 	}

  618. 	

  619.         // Draw the Accelerator Text

  620.         if(acceleratorText != null && !acceleratorText.equals("")) {

  621. 

  622. 	  //Get the maxAccWidth from the parent to calculate the offset.

  623. 	  int accOffset = 0;

  624. 	  Container parent = menuItem.getParent();

  625. 	  if (parent != null && parent instanceof JComponent) {

  626. 	    JComponent p = (JComponent) parent;

  627. 	    Integer maxValueInt = (Integer) p.getClientProperty(BasicMenuItemUI.MAX_ACC_WIDTH);

  628. 	    int maxValue = maxValueInt!=null ? maxValueInt.intValue() : 0;

  629. 	    

  630. 	    //Calculate the offset, with which the accelerator texts will be drawn with.

  631. 	    accOffset = maxValue - acceleratorRect.width;

  632. 	  }

  633. 	  

  634. 	  g.setFont( acceleratorFont );

  635.             if(!model.isEnabled()) {

  636.                 // *** paint the acceleratorText disabled

  637. 	      if ( disabledForeground != null )

  638. 		  {

  639.                   g.setColor( disabledForeground );

  640.                   BasicGraphicsUtils.drawString(g,acceleratorText,0,

  641.                                                 acceleratorRect.x - accOffset, 

  642.                                                 acceleratorRect.y + fmAccel.getAscent());

  643.                 }

  644.                 else

  645.                 {

  646.                   g.setColor(b.getBackground().brighter());

  647.                   BasicGraphicsUtils.drawString(g,acceleratorText,0,

  648.                                                 acceleratorRect.x - accOffset, 

  649. 						acceleratorRect.y + fmAccel.getAscent());

  650.                   g.setColor(b.getBackground().darker());

  651.                   BasicGraphicsUtils.drawString(g,acceleratorText,0,

  652.                                                 acceleratorRect.x - accOffset - 1, 

  653. 						acceleratorRect.y + fmAccel.getAscent() - 1);

  654.                 }

  655.             } else {

  656.                 // *** paint the acceleratorText normally

  657.                 if (model.isArmed()|| (c instanceof JMenu && model.isSelected())) {

  658.                     g.setColor( acceleratorSelectionForeground );

  659.                 } else {

  660.                     g.setColor( acceleratorForeground );

  661.                 }

  662.                 BasicGraphicsUtils.drawString(g,acceleratorText, 0,

  663.                                               acceleratorRect.x - accOffset,

  664.                                               acceleratorRect.y + fmAccel.getAscent());

  665.             }

  666.         }

  667. 

  668.         // Paint the Arrow

  669.         if (arrowIcon != null) {

  670.             if(model.isArmed() || (c instanceof JMenu &&model.isSelected()))

  671.                 g.setColor(foreground);

  672.             if(useCheckAndArrow())

  673.                 arrowIcon.paintIcon(c, g, arrowIconRect.x, arrowIconRect.y);

  674.         }

  675.         g.setColor(holdc);

  676.         g.setFont(holdf);

  677.     }

  678. 

  679. 

  680.     /** 

  681.      * Compute and return the location of the icons origin, the 

  682.      * location of origin of the text baseline, and a possibly clipped

  683.      * version of the compound labels string.  Locations are computed

  684.      * relative to the viewRect rectangle. 

  685.      */

  686. 

  687.     private String layoutMenuItem(

  688.         FontMetrics fm,

  689.         String text,

  690.         FontMetrics fmAccel,

  691.         String acceleratorText,

  692.         Icon icon,

  693.         Icon checkIcon,

  694.         Icon arrowIcon,

  695.         int verticalAlignment,

  696.         int horizontalAlignment,

  697.         int verticalTextPosition,

  698.         int horizontalTextPosition,

  699.         Rectangle viewRect, 

  700.         Rectangle iconRect, 

  701.         Rectangle textRect,

  702.         Rectangle acceleratorRect,

  703.         Rectangle checkIconRect, 

  704.         Rectangle arrowIconRect, 

  705.         int textIconGap,

  706.         int menuItemGap

  707.         )

  708.     {

  709. 

  710.         SwingUtilities.layoutCompoundLabel(

  711.                             menuItem, fm, text, icon, verticalAlignment, 

  712.                             horizontalAlignment, verticalTextPosition, 

  713.                             horizontalTextPosition, viewRect, iconRect, textRect, 

  714.                             textIconGap);

  715. 

  716.         /* Initialize the acceelratorText bounds rectangle textRect.  If a null 

  717.          * or and empty String was specified we substitute "" here 

  718.          * and use 0,0,0,0 for acceleratorTextRect.

  719.          */

  720.         if( (acceleratorText == null) || acceleratorText.equals("") ) {

  721.             acceleratorRect.width = acceleratorRect.height = 0;

  722.             acceleratorText = "";

  723.         }

  724.         else {

  725.             acceleratorRect.width = SwingUtilities.computeStringWidth( fmAccel, acceleratorText );

  726.             acceleratorRect.height = fmAccel.getHeight();

  727.         }

  728. 

  729.         /* Initialize the checkIcon bounds rectangle's width & height.

  730.          */

  731. 

  732. 	if( useCheckAndArrow()) {

  733. 	    if (checkIcon != null) {

  734. 		checkIconRect.width = checkIcon.getIconWidth();

  735. 		checkIconRect.height = checkIcon.getIconHeight();

  736. 	    } 

  737. 	    else {

  738. 		checkIconRect.width = checkIconRect.height = 0;

  739. 	    }

  740. 	    

  741. 	    /* Initialize the arrowIcon bounds rectangle width & height.

  742. 	     */

  743. 	    

  744. 	    if (arrowIcon != null) {

  745. 		arrowIconRect.width = arrowIcon.getIconWidth();

  746. 		arrowIconRect.height = arrowIcon.getIconHeight();

  747. 	    } else {

  748. 		arrowIconRect.width = arrowIconRect.height = 0;

  749. 	    }

  750.         }

  751. 

  752.         Rectangle labelRect = iconRect.union(textRect);

  753.         if( BasicGraphicsUtils.isLeftToRight(menuItem) ) {

  754.             textRect.x += menuItemGap;

  755.             iconRect.x += menuItemGap;

  756. 

  757.             // Position the Accelerator text rect

  758.             acceleratorRect.x = viewRect.x + viewRect.width - arrowIconRect.width 

  759.                              - menuItemGap - acceleratorRect.width;

  760.             

  761.             // Position the Check and Arrow Icons 

  762.             if (useCheckAndArrow()) {

  763.                 checkIconRect.x = viewRect.x + menuItemGap;

  764.                 textRect.x += menuItemGap + checkIconRect.width;

  765.                 iconRect.x += menuItemGap + checkIconRect.width;

  766.                 arrowIconRect.x = viewRect.x + viewRect.width - menuItemGap

  767.                                   - arrowIconRect.width;

  768.             }

  769.         } else {

  770.             textRect.x -= menuItemGap;

  771.             iconRect.x -= menuItemGap;

  772. 

  773.             // Position the Accelerator text rect

  774.             acceleratorRect.x = viewRect.x + arrowIconRect.width + menuItemGap;

  775. 

  776.             // Position the Check and Arrow Icons 

  777.             if (useCheckAndArrow()) {

  778.                 checkIconRect.x = viewRect.x + viewRect.width - menuItemGap

  779.                                   - checkIconRect.width;

  780.                 textRect.x -= menuItemGap + checkIconRect.width;

  781.                 iconRect.x -= menuItemGap + checkIconRect.width;      

  782.                 arrowIconRect.x = viewRect.x + menuItemGap;

  783.             }

  784.         }

  785. 

  786.         // Align the accelertor text and the check and arrow icons vertically

  787.         // with the center of the label rect.  

  788.         acceleratorRect.y = labelRect.y + (labelRect.height2) - (acceleratorRect.height2);

  789.         if( useCheckAndArrow() ) {

  790.             arrowIconRect.y = labelRect.y + (labelRect.height2) - (arrowIconRect.height2);

  791.             checkIconRect.y = labelRect.y + (labelRect.height2) - (checkIconRect.height2);

  792.         }

  793. 

  794.         /*

  795.         System.out.println("Layout: text="+menuItem.getText()+"\n\tv="

  796.                            +viewRect+"\n\tc="+checkIconRect+"\n\ti="

  797.                            +iconRect+"\n\tt="+textRect+"\n\tacc="

  798.                            +acceleratorRect+"\n\ta="+arrowIconRect+"\n");

  799.         */

  800.         

  801.         return text;

  802.     }

  803. 

  804.     /*

  805.      * Returns false if the component is a JMenu and it is a top

  806.      * level menu (on the menubar).

  807.      */

  808.     private boolean useCheckAndArrow(){

  809. 	boolean b = true;

  810. 	if((menuItem instanceof JMenu) &&

  811. 	   (((JMenu)menuItem).isTopLevelMenu())) {

  812. 	    b = false;

  813. 	}

  814. 	return b;

  815.     }

  816. 

  817.     public MenuElement[] getPath() {

  818.         MenuSelectionManager m = MenuSelectionManager.defaultManager();

  819.         MenuElement oldPath[] = m.getSelectedPath();

  820.         MenuElement newPath[];

  821.         int i = oldPath.length;

  822.         if (i == 0)

  823.             return new MenuElement[0];

  824.         Component parent = menuItem.getParent();

  825.         if (oldPath[i-1].getComponent() == parent) {

  826.             // The parent popup menu is the last so far

  827.             newPath = new MenuElement[i+1];

  828.             System.arraycopy(oldPath, 0, newPath, 0, i);

  829.             newPath[i] = menuItem;

  830.         } else {

  831.             // A sibling menuitem is the current selection

  832.             // 

  833.             //  This probably needs to handle 'exit submenu into 

  834.             // a menu item.  Search backwards along the current

  835.             // selection until you find the parent popup menu,

  836.             // then copy up to that and add yourself...

  837.             int j;

  838.             for (j = oldPath.length-1; j >= 0; j--) {

  839.                 if (oldPath[j].getComponent() == parent)

  840.                     break;

  841.             }

  842.             newPath = new MenuElement[j+2];

  843.             System.arraycopy(oldPath, 0, newPath, 0, j+1);

  844.             newPath[j+1] = menuItem;

  845.             /*

  846.             System.out.println("Sibling condition -- ");

  847.             System.out.println("Old array : ");

  848.             printMenuElementArray(oldPath, false);

  849.             System.out.println("New array : ");

  850.             printMenuElementArray(newPath, false);

  851.             */

  852.         }

  853.         return newPath;

  854.     }

  855. 

  856.     void printMenuElementArray(MenuElement path[], boolean dumpStack) {

  857.         System.out.println("Path is(");

  858.         int i, j;

  859.         for(i=0,j=path.length; i<j ;i++){

  860.             for (int k=0; k<=i; k++)

  861.                 System.out.print("  ");

  862.             MenuElement me = (MenuElement) path[i];

  863.             if(me instanceof JMenuItem) 

  864.                 System.out.println(((JMenuItem)me).getText() + ", ");

  865.             else if (me == null)

  866.                 System.out.println("NULL , ");

  867.             else

  868.                 System.out.println("" + me + ", ");

  869.         }

  870.         System.out.println(")");

  871. 

  872.         if (dumpStack == true)

  873.             Thread.dumpStack();

  874.     }

  875.     protected class MouseInputHandler implements MouseInputListener {

  876.         public void mouseClicked(MouseEvent e) {}

  877.         public void mousePressed(MouseEvent e) {

  878.         }

  879.         public void mouseReleased(MouseEvent e) {

  880.             MenuSelectionManager manager = 

  881.                 MenuSelectionManager.defaultManager();

  882.             Point p = e.getPoint();

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

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

  885.                manager.clearSelectedPath();

  886.                menuItem.doClick(0);

  887.             } else {

  888.                 manager.processMouseEvent(e);

  889.             }

  890.         }

  891.         public void mouseEntered(MouseEvent e) {

  892.             MenuSelectionManager manager = MenuSelectionManager.defaultManager();

  893. 	    int modifiers = e.getModifiers();

  894. 	    // 4188027: drag enter/exit added in JDK 1.1.7A, JDK1.2	    

  895. 	    if ((modifiers & (InputEvent.BUTTON1_MASK |

  896. 			      InputEvent.BUTTON2_MASK | InputEvent.BUTTON3_MASK)) !=0 ) {

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

  898. 	    } else {

  899. 	    manager.setSelectedPath(getPath());

  900. 	     }

  901.         }

  902.         public void mouseExited(MouseEvent e) {

  903.             MenuSelectionManager manager = MenuSelectionManager.defaultManager();

  904. 

  905. 	    int modifiers = e.getModifiers();

  906. 	    // 4188027: drag enter/exit added in JDK 1.1.7A, JDK1.2

  907. 	    if ((modifiers & (InputEvent.BUTTON1_MASK |

  908. 			      InputEvent.BUTTON2_MASK | InputEvent.BUTTON3_MASK)) !=0 ) {

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

  910. 	    } else {

  911. 

  912. 		MenuElement path[] = manager.getSelectedPath();

  913. 		if (path.length > 1) {

  914. 		    MenuElement newPath[] = new MenuElement[path.length-1];

  915. 		    int i,c;

  916. 		    for(i=0,c=path.length-1;i<c;i++)

  917. 			newPath[i] = path[i];

  918. 		    manager.setSelectedPath(newPath);

  919. 		}

  920. 		}

  921.         }

  922. 

  923.         public void mouseDragged(MouseEvent e) {

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

  925.         }

  926.         public void mouseMoved(MouseEvent e) {

  927.         }

  928.     }

  929. 

  930. 

  931.     private class MenuDragMouseHandler implements MenuDragMouseListener {

  932.         public void menuDragMouseEntered(MenuDragMouseEvent e) {}

  933.         public void menuDragMouseDragged(MenuDragMouseEvent e) {

  934.             MenuSelectionManager manager = e.getMenuSelectionManager();

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

  936.             manager.setSelectedPath(path);

  937.         }

  938.         public void menuDragMouseExited(MenuDragMouseEvent e) {}

  939.         public void menuDragMouseReleased(MenuDragMouseEvent e) {

  940.             MenuSelectionManager manager = e.getMenuSelectionManager();

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

  942.             Point p = e.getPoint();

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

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

  945.                manager.clearSelectedPath();

  946.                menuItem.doClick(0);

  947.             } else {

  948.                 manager.clearSelectedPath();

  949.             }

  950.         }

  951.     }

  952. 

  953.     private class MenuKeyHandler implements MenuKeyListener {

  954.         public void menuKeyTyped(MenuKeyEvent e) {

  955. 	    if (DEBUG) {

  956. 		System.out.println("in BasicMenuItemUI.menuKeyTyped for " + menuItem.getText());

  957. 	    }

  958.             int key = menuItem.getMnemonic();

  959.             if(key == 0)

  960.                 return;

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

  962.                 MenuSelectionManager manager = 

  963.                     e.getMenuSelectionManager();

  964.                 manager.clearSelectedPath();

  965.                 menuItem.doClick(0);

  966.                 e.consume();

  967.             }

  968.         }

  969.         public void menuKeyPressed(MenuKeyEvent e) {

  970. 	    if (DEBUG) {

  971. 		System.out.println("in BasicMenuItemUI.menuKeyPressed for " + menuItem.getText());

  972. 	    }

  973. 	}

  974.         public void menuKeyReleased(MenuKeyEvent e) {}

  975. 

  976.         private int lower(int ascii) {

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

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

  979.             else

  980.                 return ascii;

  981.         }

  982. 

  983.     }

  984. 

  985.     private class PropertyChangeHandler implements PropertyChangeListener {

  986. 	public void propertyChange(PropertyChangeEvent e) {

  987. 	    String name = e.getPropertyName();

  988. 

  989. 	    if (name.equals("labelFor") || name.equals("displayedMnemonic") ||

  990. 		name.equals("accelerator")) {

  991. 		updateAcceleratorBinding();

  992. 	    } else if (name.equals("text")) {

  993. 		// remove the old html view client property if one

  994. 		// existed, and install a new one if the text installed

  995. 		// into the JLabel is html source.

  996. 		JMenuItem lbl = ((JMenuItem) e.getSource());

  997. 		String text = lbl.getText();

  998. 		BasicHTML.updateRenderer(lbl, text);

  999. 	    }

  1000. 	}

  1001.     }  

  1002. 

  1003.     private static class ClickAction extends AbstractAction {

  1004. 	public void actionPerformed(ActionEvent e) {

  1005. 	    JMenuItem mi = (JMenuItem)e.getSource();

  1006. 	    MenuSelectionManager.defaultManager().clearSelectedPath();

  1007. 	    mi.doClick();

  1008. 	}

  1009.     }

  1010. }