Adding menu-like buttons to JToolBar (such as Back button in Netscape)

Question

Hi,
I wonder wether it is possible to add a menu-like button to a JToolBar. I tried adding a JMenu but didn't succed, since the menu's visual appearance was completely messed up and, furthermore, it didn't respond to mouse clicks.
Any hints appreciated.
Janek.

Answer 1

To do that, I wrote 3 classes.
At the end, the new menu reacts and can be used exactly as a JMenu.
The first class is the menu class which extends JMenu :
import javax.swing.*;
* This class override the method boolean isTopLevelMenu() to
* allow a menu to be a top level menu in a JMenuBar and a JTollBar also !
public class MyMenu extends JMenu {
    public MyMenu() {
        super("");
    public MyMenu(String s) {
          super(s);
    public MyMenu(Action a) {
          super(a);
    public MyMenu(String s, boolean b) {
        super(s,b);
     * Returns true if the menu is a 'top-level menu', that is, if it is
     * the direct child of a menubar.
     * @return true if the menu is activated from the menu bar;
     *         false if the menu is activated from a menu item
     *         on another menu
    public boolean isTopLevelMenu() {
        if (getParent() instanceof JMenuBar  || (getParent() instanceof JToolBar))
            return true;       
        return false;
}The second class extends JToolBar. It is necessary to redefine the MenuBar behavior : When a menu is pressed, you can move the mouse over the other menus and they will open themselves, etc... So the toolbar must implements the interface MenuElement
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.util.*;
* This class implements MenuElement to obtain the same behavior
* as a JMenuBar.
public class MyToolBar extends JToolBar implements MenuElement {
     public MyToolBar() {
          super();
     * Implemented to be a <code>MenuElement</code> -- does nothing.
     * @see #getSubElements
    public void processMouseEvent(MouseEvent event,MenuElement path[],MenuSelectionManager manager) {
     * Implemented to be a <code>MenuElement</code> -- does nothing.
     * @see #getSubElements
    public void processKeyEvent(KeyEvent e,MenuElement path[],MenuSelectionManager manager) {
     * Implemented to be a <code>MenuElemen<code>t -- does nothing.
     * @see #getSubElements
    public void menuSelectionChanged(boolean isIncluded) {
     * Implemented to be a <code>MenuElement</code> -- returns the
     * menus in this tool bar.
     * This is the reason for implementing the <code>MenuElement</code>
     * interface -- so that the menu bar can be treated the same as
     * other menu elements.
     * @return an array of menu items in the menu bar.
    public MenuElement[] getSubElements() {
        MenuElement result[];
        Vector tmp = new Vector();
        int c = getComponentCount();
        int i;
        Component m;
        for(i=0 ; i < c ; i++) {
            m = getComponent(i);
            if(m instanceof MenuElement)
                tmp.addElement(m);
        result = new MenuElement[tmp.size()];
        for(i=0,c=tmp.size() ; i < c ; i++)
            result[i] = (MenuElement) tmp.elementAt(i);
        return result;
     * Implemented to be a <code>MenuElement</code>. Returns this object.
     * @return the current <code>Component</code> (this)
     * @see #getSubElements
    public Component getComponent() {
        return this;
}The last class and morer difficult is the MenuUI. In my implementation, I use the WindowsLookAndFeel, so I redefine the WindowsMenuUI to look like Windows.
I give you my code also (please, imagine how difficult it was to write!) :
import com.sun.java.swing.plaf.windows.*;
import java.awt.*;
import java.awt.event.MouseEvent;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.basic.BasicMenuUI;
import javax.swing.plaf.basic.BasicGraphicsUtils;
import javax.swing.event.MouseInputListener;
import javax.swing.*;
* Windows rendition of the component.
* <p>
* <strong>Warning:</strong>
* Serialized objects of this class will not be compatible with
* future Swing releases.  The current serialization support is appropriate
* for short term storage or RMI between applications running the same
* version of Swing.  A future release of Swing will provide support for
* long term persistence.
public class MyWindowsMenuUI extends WindowsMenuUI {
    private boolean isMouseOver = false;
     private int shiftOffset = 0;
     private int defaultTextShiftOffset = 1;
    public static ComponentUI createUI(JComponent x) {
          return new MyWindowsMenuUI();
     * Draws the background of the menu.
     * @since 1.4
    protected void paintBackground(Graphics g, JMenuItem menuItem, Color bgColor) {
          ButtonModel model = menuItem.getModel();
          Color oldColor = g.getColor();
        int menuWidth = menuItem.getWidth();
        int menuHeight = menuItem.getHeight();
          UIDefaults table = UIManager.getLookAndFeelDefaults();
          Color highlight = table.getColor("controlLtHighlight");
          Color shadow = table.getColor("controlShadow");
          g.setColor(menuItem.getBackground());
          g.fillRect(0,0, menuWidth, menuHeight);
          clearTextShiftOffset();
        if(menuItem.isOpaque()) {
            if (model.isArmed()|| (menuItem instanceof JMenu && model.isSelected())) {
                    // Draw a lowered bevel border
                    g.setColor(shadow);
                    g.drawLine(0,0, menuWidth - 1,0);
                    g.drawLine(0,0, 0,menuHeight - 2);
                    g.setColor(highlight);
                    g.drawLine(menuWidth - 1,0, menuWidth - 1,menuHeight - 2);
                    g.drawLine(0,menuHeight - 2, menuWidth - 1,menuHeight - 2);
                    setTextShiftOffset();
               else
               if (isMouseOver() && model.isEnabled()) {
                    // Draw a raised bevel border
                    g.setColor(highlight);
                    g.drawLine(0,0, menuWidth - 1,0);
                    g.drawLine(0,0, 0,menuHeight - 2);
                    g.setColor(shadow);
                    g.drawLine(menuWidth - 1,0, menuWidth - 1,menuHeight - 2);
                    g.drawLine(0,menuHeight - 2, menuWidth - 1,menuHeight - 2);
               else {
                    g.setColor(menuItem.getBackground());
                    g.fillRect(0,0, menuWidth, menuHeight);
          g.setColor(oldColor);
     * Method which renders the text of the current menu item.
     * <p>
     * @param g Graphics context
     * @param menuItem Current menu item to render
     * @param textRect Bounding rectangle to render the text.
     * @param text String to render
     * @since 1.4
    protected void paintText(Graphics g, JMenuItem menuItem, Rectangle textRect, String text) {
          ButtonModel model = menuItem.getModel();
          FontMetrics fm = g.getFontMetrics();
          int mnemonicIndex = menuItem.getDisplayedMnemonicIndex();
          // W2K Feature: Check to see if the Underscore should be rendered.
          if (WindowsLookAndFeel.isMnemonicHidden()) {
               mnemonicIndex = -1;
          Color oldColor = g.getColor();
          if(!model.isEnabled()) {
               // *** paint the text disabled
               if ( UIManager.get("MenuItem.disabledForeground") instanceof Color ) {
                    g.setColor( UIManager.getColor("MenuItem.disabledForeground") );
                    BasicGraphicsUtils.drawStringUnderlineCharAt(g,text, mnemonicIndex, textRect.x, textRect.y + fm.getAscent());
               else {
                    g.setColor(menuItem.getBackground().brighter());
                    BasicGraphicsUtils.drawStringUnderlineCharAt(g,text, mnemonicIndex, textRect.x, textRect.y + fm.getAscent());
                    g.setColor(menuItem.getBackground().darker());
                    BasicGraphicsUtils.drawStringUnderlineCharAt(g,text, mnemonicIndex, textRect.x - 1, textRect.y + fm.getAscent() - 1);
          else {
               // For Win95, the selected text color is the selection forground color
               if (WindowsLookAndFeel.isClassicWindows() && model.isSelected()) {
                    g.setColor(selectionForeground); // Uses protected field.
               BasicGraphicsUtils.drawStringUnderlineCharAt(g,text, mnemonicIndex,  textRect.x+getTextShiftOffset(), textRect.y + fm.getAscent()+getTextShiftOffset());
          g.setColor(oldColor);
     * Set the temporary flag to indicate if the mouse has entered the menu.
    private void setMouseOver(boolean over) {
          isMouseOver = over;
     * Get the temporary flag to indicate if the mouse has entered the menu.
    private boolean isMouseOver() {
          return isMouseOver;
    protected MouseInputListener createMouseInputListener(JComponent c) {
        return new WindowsMouseInputHandler();
    protected void clearTextShiftOffset(){
        shiftOffset = 0;
    protected void setTextShiftOffset(){
        shiftOffset = defaultTextShiftOffset;
    protected int getTextShiftOffset() {
        return shiftOffset;
     * This class implements a mouse handler that sets the rollover flag to
     * true when the mouse enters the menu and false when it exits.
     * @since 1.4
    protected class WindowsMouseInputHandler extends BasicMenuUI.MouseInputHandler {
          public void mousePressed(MouseEvent e) {
               JMenu menu = (JMenu)menuItem;
               if (!menu.isEnabled())
                    return;
               MenuSelectionManager manager = MenuSelectionManager.defaultManager();
               if (menu.isTopLevelMenu()) {
                    if (menu.isSelected()) {
                         manager.clearSelectedPath();
                    else {
                         Container cnt = menu.getParent();
                         if(cnt != null && (cnt instanceof JMenuBar || (cnt instanceof JToolBar))) {
                              MenuElement me[] = new MenuElement[2];
                              me[0]=(MenuElement)cnt;
                              me[1]=menu;
                              manager.setSelectedPath(me);
            MenuElement selectedPath[] = manager.getSelectedPath();
            if (!(selectedPath.length > 0 && selectedPath[selectedPath.length-1] == menu.getPopupMenu())) {
                    if (menu.isTopLevelMenu() || menu.getDelay() == 0) {
                         MenuElement newPath[] = new MenuElement[selectedPath.length+1];
                         System.arraycopy(selectedPath,0,newPath,0,selectedPath.length);
                         newPath[selectedPath.length] = menu.getPopupMenu();
                         manager.setSelectedPath(newPath);
                    else {
                        setupPostTimer(menu);
          public void mouseEntered(MouseEvent evt) {
               super.mouseEntered(evt);
               if (!WindowsLookAndFeel.isClassicWindows()) {
                    setMouseOver(true);
                    menuItem.repaint();
          public void mouseExited(MouseEvent evt) {
               super.mouseExited(evt);
               if (!WindowsLookAndFeel.isClassicWindows()) {
                    setMouseOver(false);
                    menuItem.repaint();
}This UI simulate also the rollover effect.
And now here is a class to test this code (under 1.4 and Windows L&F):
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.plaf.basic.*;
public class MenuToolBar extends JFrame {
     public static String windowsUI = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
     public MenuToolBar() {
          super("Menu toolbar");
          setWindowsLF();
          addWindowListener(new WindowAdapter() {
               public void windowClosing(WindowEvent e) {
                    System.exit(0);
          setBounds(312,250,412,200);
          MyMenu menu = new MyMenu("File");
          MyMenu menu2 = new MyMenu("Help");
          menu.add(new JMenuItem("Try"));
          MyToolBar tb = new MyToolBar();
          tb.firePropertyChange("JToolBar.isRollover", false, true); 
          tb.add(menu);
          tb.add(menu2);
          JToggleButton jt = new JToggleButton("Toggle button", new ImageIcon("tog.gif"));
          jt.setFocusPainted(false);
          tb.add(jt);
          tb.addSeparator();
          JButton jb = new JButton("Button", new ImageIcon("but.gif"));
          jb.setFocusPainted(false);
          tb.add(jb);
          getContentPane().add(tb, BorderLayout.NORTH);     
          setVisible(true);
     public static final void setWindowsLF() {
          try {
               UIManager.setLookAndFeel(windowsUI);
               UIManager.put("MenuUI", "MyWindowsMenuUI");
          catch (Exception exc) {
               System.err.println("Error loading L&F: " + exc);
     public static void main(String[] args) {
          new MenuToolBar();
}Execute that, to see if the result is OK for you!
Another thing : could you please report my name if you use and distribute the code ?
Tell me if this helps you!
Denis
[