1. /*

  2.  * @(#)BasicMenuItemUI.java	1.88 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7.  

  8. package javax.swing.plaf.basic;

  9. 

  10. import java.awt.*;

  11. import java.awt.event.*;

  12. import java.beans.PropertyChangeEvent;

  13. import java.beans.PropertyChangeListener;

  14. 

  15. import javax.swing.*;

  16. import javax.swing.event.*;

  17. import javax.swing.border.*;

  18. import javax.swing.plaf.*;

  19. import javax.swing.text.View;

  20. 

  21. 

  22. /**

  23.  * BasicMenuItem implementation

  24.  *

  25.  * @version 1.88 11/29/01

  26.  * @author Georges Saab

  27.  * @author David Karlton

  28.  * @author Arnaud Weber

  29.  */

  30. public class BasicMenuItemUI extends MenuItemUI

  31. {

  32.     protected JMenuItem menuItem = null;

  33.     protected Color selectionBackground;

  34.     protected Color selectionForeground;    

  35.     protected Color disabledForeground;

  36.     protected Color acceleratorForeground;

  37.     protected Color acceleratorSelectionForeground;

  38.     private   String acceleratorDelimiter;

  39.     

  40.     protected int defaultTextIconGap;

  41.     protected Font acceleratorFont;

  42. 

  43.     protected MouseInputListener mouseInputListener;

  44.     protected MenuDragMouseListener menuDragMouseListener;

  45.     protected MenuKeyListener menuKeyListener;

  46.     private   PropertyChangeListener propertyChangeListener;

  47.     

  48.     protected Icon arrowIcon = null;

  49.     protected Icon checkIcon = null;

  50. 

  51.     protected boolean oldBorderPainted;

  52. 

  53.     public static ComponentUI createUI(JComponent c) {

  54.         return new BasicMenuItemUI();

  55.     }

  56. 

  57.     public void installUI(JComponent c) {

  58.         menuItem = (JMenuItem) c;

  59. 

  60.         installDefaults();

  61.         installComponents();

  62.         installListeners();

  63.         installKeyboardActions();

  64. 

  65.     }

  66. 

  67.     protected void installDefaults() {

  68.         String prefix = getPropertyPrefix();

  69. 

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

  71. 

  72.         menuItem.setOpaque(true);

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

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

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

  76.         }

  77. 

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

  79. 

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

  81.         oldBorderPainted = menuItem.isBorderPainted();

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

  83.         LookAndFeel.installColorsAndFont(menuItem,

  84.                                          prefix + ".background",

  85.                                          prefix + ".foreground",

  86.                                          prefix + ".font");

  87.         

  88.         // MenuItem specific defaults

  89.         if (selectionBackground == null || 

  90.             selectionBackground instanceof UIResource) {

  91.             selectionBackground = 

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

  93.         }

  94.         if (selectionForeground == null || 

  95.             selectionForeground instanceof UIResource) {

  96.             selectionForeground = 

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

  98.         }

  99.         if (disabledForeground == null || 

  100.             disabledForeground instanceof UIResource) {

  101.             disabledForeground = 

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

  103.         }

  104.         if (acceleratorForeground == null || 

  105.             acceleratorForeground instanceof UIResource) {

  106.             acceleratorForeground = 

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

  108.         }

  109.         if (acceleratorSelectionForeground == null || 

  110.             acceleratorSelectionForeground instanceof UIResource) {

  111.             acceleratorSelectionForeground = 

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

  113.         }

  114. 	// Get accelerator delimiter

  115. 	acceleratorDelimiter = 

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

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

  118.         // Icons

  119.         if (arrowIcon == null ||

  120.             arrowIcon instanceof UIResource) {

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

  122.         }

  123.         if (checkIcon == null ||

  124.             checkIcon instanceof UIResource) {

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

  126.         }

  127.     }

  128. 

  129.     /* Unfortunately this has to remain private until we can make API additions.

  130.      */

  131.     private void installComponents(){

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

  133.     }

  134. 

  135.     protected String getPropertyPrefix() {

  136.         return "MenuItem";

  137.     }

  138. 

  139.     protected void installListeners() {

  140.         mouseInputListener = createMouseInputListener(menuItem);

  141.         menuDragMouseListener = createMenuDragMouseListener(menuItem);

  142.         menuKeyListener = createMenuKeyListener(menuItem);

  143.         propertyChangeListener = createPropertyChangeListener(menuItem);

  144. 

  145.         menuItem.addMouseListener(mouseInputListener);

  146.         menuItem.addMouseMotionListener(mouseInputListener);

  147.         menuItem.addMenuDragMouseListener(menuDragMouseListener);

  148.         menuItem.addMenuKeyListener(menuKeyListener);

  149. 	menuItem.addPropertyChangeListener(propertyChangeListener);

  150.     }

  151. 

  152.     protected void installKeyboardActions() {}

  153. 

  154.     public void uninstallUI(JComponent c) {

  155.         uninstallDefaults();

  156.         uninstallComponents();

  157.         uninstallListeners();

  158.         uninstallKeyboardActions();

  159. 

  160.         menuItem = null;

  161.     }

  162. 

  163. 

  164.     protected void uninstallDefaults() {

  165.         LookAndFeel.uninstallBorder(menuItem);

  166.         menuItem.setBorderPainted( oldBorderPainted );

  167.         if (arrowIcon instanceof UIResource)

  168.             arrowIcon = null;

  169.         if (checkIcon instanceof UIResource)

  170.             checkIcon = null;

  171.     }

  172. 

  173.     /* Unfortunately this has to remain private until we can make API additions.

  174.      */

  175.     private void uninstallComponents(){

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

  177.     }

  178. 

  179.     protected void uninstallListeners() {

  180.         menuItem.removeMouseListener(mouseInputListener);

  181.         menuItem.removeMouseMotionListener(mouseInputListener);

  182.         menuItem.removeMenuDragMouseListener(menuDragMouseListener);

  183.         menuItem.removeMenuKeyListener(menuKeyListener);

  184.         menuItem.removePropertyChangeListener(propertyChangeListener);

  185. 

  186.         mouseInputListener = null;

  187.         menuDragMouseListener = null;

  188.         menuKeyListener = null;

  189. 	propertyChangeListener = null;

  190.     }

  191. 

  192.     protected void uninstallKeyboardActions() {}

  193. 

  194.     protected MouseInputListener createMouseInputListener(JComponent c) {

  195.         return new MouseInputHandler();

  196.     }

  197. 

  198.     protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {

  199.         return new MenuDragMouseHandler();

  200.     }

  201. 

  202.     protected MenuKeyListener createMenuKeyListener(JComponent c) {

  203.         return new MenuKeyHandler();

  204.     }

  205. 

  206.     private PropertyChangeListener createPropertyChangeListener(JComponent c) {

  207.         return new PropertyChangeHandler();

  208.     }

  209. 

  210.     public Dimension getMinimumSize(JComponent c) {

  211. 	Dimension d = null;

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

  213.  	if (v != null) {

  214. 	    d = getPreferredSize(c);

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

  216.  	}

  217.  	return d;	

  218.     }

  219. 

  220.     public Dimension getPreferredSize(JComponent c) {

  221.         return getPreferredMenuItemSize(c,

  222.                                         checkIcon, 

  223.                                         arrowIcon, 

  224.                                         defaultTextIconGap);

  225.     }

  226. 

  227.     public Dimension getMaximumSize(JComponent c) {

  228. 	Dimension d = null;

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

  230.  	if (v != null) {

  231. 	    d = getPreferredSize(c);

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

  233.  	}

  234.  	return d;

  235.     }

  236. 

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

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

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

  240.     static Rectangle iconRect = new Rectangle();

  241.     static Rectangle textRect = new Rectangle();

  242.     static Rectangle acceleratorRect = new Rectangle();

  243.     static Rectangle checkIconRect = new Rectangle();

  244.     static Rectangle arrowIconRect = new Rectangle();

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

  246.     static Rectangle r = new Rectangle();

  247. 

  248.     private void resetRects() {

  249.         iconRect.setBounds(zeroRect);

  250.         textRect.setBounds(zeroRect);

  251.         acceleratorRect.setBounds(zeroRect);

  252.         checkIconRect.setBounds(zeroRect);

  253.         arrowIconRect.setBounds(zeroRect);

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

  255.         r.setBounds(zeroRect);

  256.     }

  257. 

  258.     protected Dimension getPreferredMenuItemSize(JComponent c,

  259.                                                      Icon checkIcon,

  260.                                                      Icon arrowIcon,

  261.                                                      int defaultTextIconGap) {

  262.         JMenuItem b = (JMenuItem) c;

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

  264.         String text = b.getText();

  265.         KeyStroke accelerator =  b.getAccelerator();

  266.         String acceleratorText = "";

  267. 

  268.         if (accelerator != null) {

  269.             int modifiers = accelerator.getModifiers();

  270.             if (modifiers > 0) {

  271.                 acceleratorText = KeyEvent.getKeyModifiersText(modifiers);

  272.                 //acceleratorText += "-";

  273.                 acceleratorText += acceleratorDelimiter;

  274.           }

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

  276.         }

  277. 

  278.         Font font = b.getFont();

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

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

  281. 

  282.         resetRects();

  283.         

  284.         layoutMenuItem(

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

  286.                   b.getVerticalAlignment(), b.getHorizontalAlignment(),

  287.                   b.getVerticalTextPosition(), b.getHorizontalTextPosition(),

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

  289.                   text == null ? 0 : defaultTextIconGap,

  290.                   defaultTextIconGap

  291.                   );

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

  293.         r.setBounds(textRect);

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

  295.                                         iconRect.y,

  296.                                         iconRect.width,

  297.                                         iconRect.height,

  298.                                         r);

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

  300. 

  301.         // Add in the accelerator

  302.         boolean acceleratorTextIsEmpty = (acceleratorText == null) || 

  303.             acceleratorText.equals("");

  304. 

  305.         if (!acceleratorTextIsEmpty) {

  306.             r.width += acceleratorRect.width;

  307.             r.width += 7*defaultTextIconGap;

  308.         }

  309. 

  310. 	if( useCheckAndArrow() ) {

  311. 	    // Add in the checkIcon

  312. 	    r.width += checkIconRect.width;

  313. 	    r.width += defaultTextIconGap;

  314. 

  315. 	    // Add in the arrowIcon

  316. 	    r.width += defaultTextIconGap;

  317. 	    r.width += arrowIconRect.width;

  318.         }	

  319. 

  320. 	r.width += 2*defaultTextIconGap;

  321. 

  322.         Insets insets = b.getInsets();

  323.         if(insets != null) {

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

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

  326.         }

  327. 

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

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

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

  331.             r.width++;

  332.         }

  333. 

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

  335.         // for the text to center properly

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

  337.             r.height++;

  338.         }

  339.          

  340.         return r.getSize();

  341.     }

  342. 

  343.     /**

  344.      * We draw the background in paintMenuItem()

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

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

  347.      *

  348.      */

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

  350.         paint(g, c);

  351.     }

  352. 

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

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

  355.                       selectionBackground, selectionForeground,

  356.                       defaultTextIconGap);

  357.     }

  358. 

  359. 

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

  361.                                      Icon checkIcon, Icon arrowIcon,

  362.                                      Color background, Color foreground,

  363.                                      int defaultTextIconGap) {

  364.         JMenuItem b = (JMenuItem) c;

  365.         ButtonModel model = b.getModel();

  366. 

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

  368.         int menuWidth = b.getWidth();

  369.         int menuHeight = b.getHeight();

  370.         Insets i = c.getInsets();

  371. 

  372.         resetRects();

  373. 

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

  375. 

  376.         viewRect.x += i.left;

  377.         viewRect.y += i.top;

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

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

  380. 

  381. 

  382.         Font holdf = g.getFont();

  383.         Font f = c.getFont();

  384.         g.setFont( f );

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

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

  387. 

  388.         // Paint background

  389.         Color holdc = g.getColor();

  390.         if(c.isOpaque()) {

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

  392.                 g.setColor(background);

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

  394.             } else {

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

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

  397.             }

  398.             g.setColor(holdc);

  399.         }

  400. 

  401.         // get Accelerator text

  402.         KeyStroke accelerator =  b.getAccelerator();

  403.         String acceleratorText = "";

  404.         if (accelerator != null) {

  405.             int modifiers = accelerator.getModifiers();

  406.             if (modifiers > 0) {

  407.                 acceleratorText = KeyEvent.getKeyModifiersText(modifiers);

  408.                 //acceleratorText += "-";

  409.                 acceleratorText += acceleratorDelimiter;

  410.           }

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

  412.         }

  413.         

  414.         // layout the text and icon

  415.         String text = layoutMenuItem(

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

  417.             checkIcon, arrowIcon,

  418.             b.getVerticalAlignment(), b.getHorizontalAlignment(),

  419.             b.getVerticalTextPosition(), b.getHorizontalTextPosition(),

  420.             viewRect, iconRect, textRect, acceleratorRect, 

  421.             checkIconRect, arrowIconRect,

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

  423.             defaultTextIconGap

  424.         );

  425.           

  426.         // Paint the Check

  427.         if (checkIcon != null) {

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

  429.                 g.setColor(foreground);

  430.             } else {

  431.                 g.setColor(b.getForeground());

  432.             }

  433.             if( useCheckAndArrow() )

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

  435.             g.setColor(holdc);

  436.         }

  437. 

  438.         // Paint the Icon

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

  440.             Icon icon;

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

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

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

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

  445.                 if(icon == null) {

  446.                     // Use default icon

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

  448.                 } 

  449.             } else {

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

  451.             }

  452.               

  453.             if (icon!=null)   

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

  455.         }

  456. 

  457.         // Draw the Text

  458.         if(text != null) {

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

  460.  	    if (v != null) {

  461.  		v.paint(g, textRect);

  462.  	    } else {

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

  464. 		    // *** paint the text disabled

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

  466. 			{

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

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

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

  470. 			}

  471. 		    else

  472. 			{

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

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

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

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

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

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

  479. 			}

  480. 		} else {

  481. 		    // *** paint the text normally

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

  483. 			g.setColor(foreground);

  484. 		    } else {

  485. 			g.setColor(b.getForeground());

  486. 		    }

  487. 		    BasicGraphicsUtils.drawString(g,text, 

  488. 						  model.getMnemonic(),

  489. 						  textRect.x,

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

  491. 		}

  492. 	    }

  493. 	}

  494. 

  495.         // Draw the Accelerator Text

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

  497.             g.setFont( acceleratorFont );

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

  499.                 // *** paint the acceleratorText disabled

  500.                 if ( disabledForeground != null )

  501.                 {

  502.                   g.setColor( disabledForeground );

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

  504.                                                 acceleratorRect.x, 

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

  506.                 }

  507.                 else

  508.                 {

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

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

  511.                                                 acceleratorRect.x, acceleratorRect.y + fmAccel.getAscent());

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

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

  514.                                                 acceleratorRect.x - 1, acceleratorRect.y + fmAccel.getAscent() - 1);

  515.                 }

  516.             } else {

  517.                 // *** paint the acceleratorText normally

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

  519.                     g.setColor( acceleratorSelectionForeground );

  520.                 } else {

  521.                     g.setColor( acceleratorForeground );

  522.                 }

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

  524.                                               acceleratorRect.x,

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

  526.             }

  527.         }

  528. 

  529.         // Paint the Arrow

  530.         if (arrowIcon != null) {

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

  532.                 g.setColor(foreground);

  533.             if(useCheckAndArrow())

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

  535.         }

  536.         g.setColor(holdc);

  537.         g.setFont(holdf);

  538.     }

  539. 

  540. 

  541.     /** 

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

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

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

  545.      * relative to the viewRect rectangle. 

  546.      */

  547. 

  548.     private String layoutMenuItem(

  549.         FontMetrics fm,

  550.         String text,

  551.         FontMetrics fmAccel,

  552.         String acceleratorText,

  553.         Icon icon,

  554.         Icon checkIcon,

  555.         Icon arrowIcon,

  556.         int verticalAlignment,

  557.         int horizontalAlignment,

  558.         int verticalTextPosition,

  559.         int horizontalTextPosition,

  560.         Rectangle viewRect, 

  561.         Rectangle iconRect, 

  562.         Rectangle textRect,

  563.         Rectangle acceleratorRect,

  564.         Rectangle checkIconRect, 

  565.         Rectangle arrowIconRect, 

  566.         int textIconGap,

  567.         int menuItemGap

  568.         )

  569.     {

  570. 

  571.         SwingUtilities.layoutCompoundLabel(

  572.                             menuItem, fm, text, icon, verticalAlignment, 

  573.                             horizontalAlignment, verticalTextPosition, 

  574.                             horizontalTextPosition, viewRect, iconRect, textRect, 

  575.                             textIconGap);

  576. 

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

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

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

  580.          */

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

  582.             acceleratorRect.width = acceleratorRect.height = 0;

  583.             acceleratorText = "";

  584.         }

  585.         else {

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

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

  588.         }

  589. 

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

  591.          */

  592. 

  593. 	if( useCheckAndArrow()) {

  594. 	    if (checkIcon != null) {

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

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

  597. 	    } 

  598. 	    else {

  599. 		checkIconRect.width = checkIconRect.height = 0;

  600. 	    }

  601. 	    

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

  603. 	     */

  604. 	    

  605. 	    if (arrowIcon != null) {

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

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

  608. 	    } else {

  609. 		arrowIconRect.width = arrowIconRect.height = 0;

  610. 	    }

  611.         }

  612. 

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

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

  615.             textRect.x += menuItemGap;

  616.             iconRect.x += menuItemGap;

  617. 

  618.             // Position the Accelerator text rect

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

  620.                              - menuItemGap - acceleratorRect.width;

  621.             

  622.             // Position the Check and Arrow Icons 

  623.             if (useCheckAndArrow()) {

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

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

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

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

  628.                                   - arrowIconRect.width;

  629.             }

  630.         } else {

  631.             textRect.x -= menuItemGap;

  632.             iconRect.x -= menuItemGap;

  633. 

  634.             // Position the Accelerator text rect

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

  636. 

  637.             // Position the Check and Arrow Icons 

  638.             if (useCheckAndArrow()) {

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

  640.                                   - checkIconRect.width;

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

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

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

  644.             }

  645.         }

  646. 

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

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

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

  650.         if( useCheckAndArrow() ) {

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

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

  653.         }

  654. 

  655.         /*

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

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

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

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

  660.         */

  661.         

  662.         return text;

  663.     }

  664. 

  665.     /*

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

  667.      * level menu (on the menubar).

  668.      */

  669.     private boolean useCheckAndArrow(){

  670. 	boolean b = true;

  671. 	if((menuItem instanceof JMenu) &&

  672. 	   (((JMenu)menuItem).isTopLevelMenu())) {

  673. 	    b = false;

  674. 	}

  675. 	return b;

  676.     }

  677. 

  678.     public MenuElement[] getPath() {

  679.         MenuSelectionManager m = MenuSelectionManager.defaultManager();

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

  681.         MenuElement newPath[];

  682.         int i = oldPath.length;

  683.         if (i == 0)

  684.             return new MenuElement[0];

  685.         Component parent = menuItem.getParent();

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

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

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

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

  690.             newPath[i] = menuItem;

  691.         } else {

  692.             // A sibling menuitem is the current selection

  693.             // 

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

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

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

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

  698.             int j;

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

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

  701.                     break;

  702.             }

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

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

  705.             newPath[j+1] = menuItem;

  706.             /*

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

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

  709.             printMenuElementArray(oldPath, false);

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

  711.             printMenuElementArray(newPath, false);

  712.             */

  713.         }

  714.         return newPath;

  715.     }

  716. 

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

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

  719.         int i, j;

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

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

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

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

  724.             if(me instanceof JMenuItem) 

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

  726.             else if (me == null)

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

  728.             else

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

  730.         }

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

  732. 

  733.         if (dumpStack == true)

  734.             Thread.dumpStack();

  735.     }

  736.     protected class MouseInputHandler implements MouseInputListener {

  737.         public void mouseClicked(MouseEvent e) {}

  738.         public void mousePressed(MouseEvent e) {

  739.         }

  740.         public void mouseReleased(MouseEvent e) {

  741.             MenuSelectionManager manager = 

  742.                 MenuSelectionManager.defaultManager();

  743.             Point p = e.getPoint();

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

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

  746.                 manager.clearSelectedPath();

  747.                 menuItem.doClick(0);

  748.             } else {

  749.                 manager.processMouseEvent(e);

  750.             }

  751.         }

  752.         public void mouseEntered(MouseEvent e) {

  753.             // System.out.println("menu item entered: " + menuItem.getText());

  754.             MenuSelectionManager manager = MenuSelectionManager.defaultManager();

  755. 	    int modifiers = e.getModifiers();

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

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

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

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

  760. 	    } else {

  761. 	    manager.setSelectedPath(getPath());

  762. 	     }

  763.         }

  764.         public void mouseExited(MouseEvent e) {

  765.             MenuSelectionManager manager = MenuSelectionManager.defaultManager();

  766. 

  767. 	    int modifiers = e.getModifiers();

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

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

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

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

  772. 	    } else {

  773. 

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

  775. 		if (path.length > 1) {

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

  777. 		    int i,c;

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

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

  780. 		    manager.setSelectedPath(newPath);

  781. 		}

  782. 		}

  783.         }

  784. 

  785.         public void mouseDragged(MouseEvent e) {

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

  787.         }

  788.         public void mouseMoved(MouseEvent e) {

  789.         }

  790.     }

  791. 

  792. 

  793.     private class MenuDragMouseHandler implements MenuDragMouseListener {

  794.         public void menuDragMouseEntered(MenuDragMouseEvent e) {}

  795.         public void menuDragMouseDragged(MenuDragMouseEvent e) {

  796.             MenuSelectionManager manager = e.getMenuSelectionManager();

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

  798.             manager.setSelectedPath(path);

  799.         }

  800.         public void menuDragMouseExited(MenuDragMouseEvent e) {}

  801.         public void menuDragMouseReleased(MenuDragMouseEvent e) {

  802.             MenuSelectionManager manager = e.getMenuSelectionManager();

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

  804.             Point p = e.getPoint();

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

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

  807.                 manager.clearSelectedPath();

  808.                 menuItem.doClick(0);

  809.             } else {

  810.                 manager.clearSelectedPath();

  811.             }

  812.         }

  813.     }

  814. 

  815.     private class MenuKeyHandler implements MenuKeyListener {

  816.         public void menuKeyTyped(MenuKeyEvent e) {

  817.             int key = menuItem.getMnemonic();

  818.             if(key == 0)

  819.                 return;

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

  821.                 MenuSelectionManager manager = 

  822.                     e.getMenuSelectionManager();

  823.                 manager.clearSelectedPath();

  824.                 menuItem.doClick(0);

  825.                 e.consume();

  826.             }

  827.         }

  828.         public void menuKeyPressed(MenuKeyEvent e) {}

  829.         public void menuKeyReleased(MenuKeyEvent e) {}

  830. 

  831.         private int lower(int ascii) {

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

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

  834.             else

  835.                 return ascii;

  836.         }

  837. 

  838.     }

  839. 

  840.     private class PropertyChangeHandler implements PropertyChangeListener {

  841. 	public void propertyChange(PropertyChangeEvent e) {

  842. 	    String name = e.getPropertyName();

  843. 

  844. 	    // System.out.println("Change prop " + name + " on " + menuItem.getText());

  845. 

  846. 	    if (e.getPropertyName().equals("labelFor") ||

  847. 		e.getPropertyName().equals("displayedMnemonic")) {

  848. 		installKeyboardActions();

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

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

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

  852. 		// into the JLabel is html source.

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

  854. 		String text = lbl.getText();

  855. 		BasicHTML.updateRenderer(lbl, text);

  856. 	    }

  857. 	}

  858. }  

  859. 

  860. }