JPopupButton

[Pavan Kumar]

Hi,
I am trying to develop a button in Swing, like the one in the Windows File explorer's "Back button". This might be helpful in making toolbar buttons.

JPopupButton.java

package javaswing.button.jpopupbutton;
 
 
import java.awt.*;
import java.awt.event.*;
 
import javax.swing.*;
 
 
public class JPopupButton extends JButton
{
    static
    {
        UIManager.put("JPopupButtonUI", "javaswing.button.jpopupbutton.JPopupButtonUI");
    }
 
    public JPopupButton(Icon imageIcon, Action[] actionList)
    {
        super(null, imageIcon);
        setModel(new JPopupButtonModel(imageIcon, actionList));
    }
 
    @Override public String getUIClassID()
    {
        return "JPopupButtonUI";
    }
 
    Insets insets = new Insets(5, 5, 5, 5);
 
    @Override public Insets getInsets()
    {
        return insets;
    }
 
    @Override public Icon getIcon()
    {
        return ((JPopupButtonModel) getModel()).getIcon();
    }
 
    @Override public boolean isRolloverEnabled()
    {
        return true;
    }
 
    public static void main(String[] args)
    {
        JFrame   frame   = new JFrame();
 
        Action[] actions = new Action[5];
 
        actions[0] = new ThisAction(0);
        actions[1] = new ThisAction(1);
        actions[2] = new ThisAction(2);
        actions[3] = new ThisAction(3);
        actions[4] = new ThisAction(4);
 
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().setLayout(new FlowLayout());
        frame.add(new JPopupButton(new ImageIcon(JPopupButton.class.getResource("resources/down.png")),
                                   actions));
        frame.add(new JPopupButton(new ImageIcon(JPopupButton.class.getResource("resources/up.png")),
                                   actions));
        frame.add(
            new JPopupButton(
                new ImageIcon(JPopupButton.class.getResource("resources/forward.png")), actions));
        frame.add(new JPopupButton(new ImageIcon(JPopupButton.class.getResource("resources/back.png")),
                                   actions));
        frame.add(new JPopupButton(new ImageIcon(JPopupButton.class.getResource("resources/reload.png")),
                                   actions));
        frame.add(new JPopupButton(new ImageIcon(JPopupButton.class.getResource("resources/stop.png")),
                                   actions));
 
        frame.pack();
        frame.setVisible(true);
 
    }
 
    static class ThisAction extends AbstractAction
    {
        public ThisAction(int i)
        {
            putValue(Action.NAME, "This Action - " + i);
        }
 
        private static final long serialVersionUID = 6215554513885435067L;
 
        public void actionPerformed(ActionEvent e)
        {
            System.out.println(getValue(Action.NAME));;
        }
    }
}

JPopupButtonModel.java

package javaswing.button.jpopupbutton;
 
 
import javax.swing.*;
 
 
public class JPopupButtonModel extends DefaultButtonModel
{
    public static final int   ROLLOVER_ON_DOWNARROW = 1 << 5;
 
    private Action[]          actions               = null;
    private Icon              icon                  = null;
    private int               iconToDividerSpace    = 5;
 
    public JPopupButtonModel(Icon icon, Action[] action)
    {
        super();
        this.actions = action;
        this.icon    = icon;
    }
 
    public Icon getIcon()
    {
        return icon;
    }
 
    public void setIcon(ImageIcon icon)
    {
        this.icon = icon;
    }
 
    public int getIconToDividerSpace()
    {
        return iconToDividerSpace;
    }
 
    public void setIconToDividerSpace(int iconToDividerSpace)
    {
        this.iconToDividerSpace = iconToDividerSpace;
    }
 
    public void setActions(Action[] actions)
    {
        this.actions = actions;
    }
 
    public Action[] getActions()
    {
        return actions;
    }
 
    public boolean isRolloverOnDownArrow()
    {
        return (stateMask & ROLLOVER_ON_DOWNARROW) != 0;
    }
 
    public void setRolloverOnDownArrow(boolean b)
    {
        if ((isRolloverOnDownArrow() == b) || !isEnabled())
        {
            return;
        }
 
        if (b)
        {
            stateMask |= ROLLOVER_ON_DOWNARROW;
        }
        else
        {
            stateMask &= ~ROLLOVER_ON_DOWNARROW;
        }
 
        fireStateChanged();
    }
}

JPopupButtonUI.java

package javaswing.button.jpopupbutton;
 
 
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
 
import javax.swing.*;
import javax.swing.plaf.*;
import javax.swing.plaf.basic.*;
 
 
public class JPopupButtonUI extends BasicButtonUI
{
    static int           size = 6;
    static BufferedImage downArrowImage = new BufferedImage(size, size,
                                                            BufferedImage.TYPE_4BYTE_ABGR_PRE);
    static BufferedImage disabledDownArrowImage = new BufferedImage(size, size,
        BufferedImage.TYPE_4BYTE_ABGR_PRE);
 
    static
    {
        Graphics2D g2d = (Graphics2D) downArrowImage.getGraphics();
 
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setColor(Color.black);
        g2d.fillPolygon(new Polygon(new int[] { 0, size / 2, size }, new int[] { 0, size, 0 }, 3));
 
        g2d = disabledDownArrowImage.createGraphics();
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setColor(Color.black.brighter());
        g2d.fillPolygon(new Polygon(new int[] { 0, size / 2, size }, new int[] { 0, size, 0 }, 3));
    }
 
    private static final JPopupButtonUI buttonUI = new JPopupButtonUI();
 
    public static ComponentUI createUI(JComponent c)
    {
        return buttonUI;
    }
 
    @Override public Dimension getPreferredSize(JComponent c)
    {
        JPopupButton butt   = (JPopupButton) c;
        Icon         icon   = ((JPopupButtonModel) butt.getModel()).getIcon();
        Insets       insets = c.getInsets();
        int width = insets.left + icon.getIconWidth() +
                    2 * ((JPopupButtonModel) butt.getModel()).getIconToDividerSpace() + 2 + size +
                    insets.right;
        int          height = insets.top + insets.bottom + icon.getIconHeight();
 
        return new Dimension(width, height);
    }
 
    @Override protected BasicButtonListener createButtonListener(AbstractButton b)
    {
        return new JPopupButtonUIButtonListener((JPopupButton) b);
    }
 
    @Override public Dimension getMinimumSize(JComponent c)
    {
        return getPreferredSize(c);
    }
 
    @Override public Dimension getMaximumSize(JComponent c)
    {
        return getPreferredSize(c);
    }
 
    private static Rectangle iconRect = new Rectangle();
 
    @Override public void paint(Graphics graphics, JComponent c)
    {
        Graphics2D        g      = (Graphics2D) graphics;
        JPopupButton      b      = (JPopupButton) c;
        JPopupButtonModel model  = (JPopupButtonModel) b.getModel();
        Dimension         dim    = getPreferredSize(b);
        Insets            insets = b.getInsets();
 
        putGradientPaint(g, b, dim);
 
        if (b.getModel().isPressed() && !model.isRolloverOnDownArrow())
        {
            g.translate(1, 1);
        }
 
        iconRect.x      = insets.left;
        iconRect.y      = insets.top;
        iconRect.width  = model.getIcon().getIconWidth();
        iconRect.height = model.getIcon().getIconHeight();
 
        paintIcon(g, c, iconRect);
 
        g.translate(insets.left + iconRect.width + model.getIconToDividerSpace(), 0);
 
        Color backGround = c.getBackground(),
              foreGround = c.getForeground();
 
        g.setColor(foreGround);
 
        if (model.isRollover() || b.hasFocus())
        {
            int x = model.isPressed() ? 0 : 0;
 
            g.drawLine(0 - x, insets.top - x, 0 - x, dim.height - insets.bottom - x);
            g.setColor(backGround.brighter());
            g.drawLine(1 - x, insets.top - x, 1 - x, dim.height - insets.bottom - x);
 
            g.setColor(foreGround);
        }
 
        g.translate(-(insets.left + iconRect.width + model.getIconToDividerSpace()), 0);
        int downArrowX = dim.width - size - insets.right,
            downArrowY = (dim.height - size) / 2;
 
        if (b.getModel().isPressed() && model.isRolloverOnDownArrow())
        {
            g.translate(1, 1);
        }
 
        g.drawImage(downArrowImage.getScaledInstance(-1, -1, 0), downArrowX, downArrowY, null);
 
        if (model.isRollover())
        {
            g.setStroke(new BasicStroke(2));
            g.drawRect(1, 1, dim.width-2, dim.height-2);
        }
    }
 
    static Color centralColor = new Color(228, 225, 211);
    static Color endColor     = new Color(100, 100, 100);
 
    private void putGradientPaint(Graphics2D g, JPopupButton b, Dimension dim)
    {
        Insets            insets        = b.getInsets();
        JPopupButtonModel model         = (JPopupButtonModel) b.getModel();
        AffineTransform   transform     = g.getTransform();
        Color             endColor1     = endColor;
        Color             centralColor1 = centralColor;
 
        if (b.hasFocus())
        {
            endColor1     = endColor.brighter();
            centralColor1 = centralColor.brighter();
        }
 
        downArrowRect.x      = dim.width - insets.right - size - model.getIconToDividerSpace();
        downArrowRect.y      = 0;
        downArrowRect.width  = model.getIconToDividerSpace() + size + insets.right;
        downArrowRect.height = dim.height;
 
        otherRect.x          = 0;
        otherRect.y          = 0;
        otherRect.width      = downArrowRect.x - 2 - model.getIconToDividerSpace();
        otherRect.height     = downArrowRect.height;
 
        paintGradient(g, dim, endColor1, centralColor1);
 
        if (model.isRolloverOnDownArrow() && model.isPressed())
        {
            tempDim.height = downArrowRect.height;
            tempDim.width  = downArrowRect.width;
            g.translate(downArrowRect.x, 0);
            paintGradient(g, tempDim, endColor, centralColor);
            g.setTransform(transform);
        }
    }
 
    private void paintGradient(Graphics2D g, Dimension dim, Color endColor1, Color centralColor1)
    {
        GradientPaint gp = new GradientPaint(new Point(dim.width / 2, 0), endColor1,
                                             new Point(dim.width / 2, dim.height / 2), centralColor1);
 
        g.setPaint(gp);
        g.fillRect(0, 0, dim.width, dim.height / 2);
 
        gp = new GradientPaint(new Point(dim.width / 2, dim.height / 2), centralColor1,
                               new Point(dim.width / 2, dim.height), endColor1);
        g.setPaint(gp);
        g.fillRect(0, dim.height / 2, dim.width, dim.height / 2);
    }
 
    static Dimension tempDim       = new Dimension();
    static Rectangle downArrowRect = new Rectangle();
    static Rectangle otherRect     = new Rectangle();
 
    class JPopupButtonUIButtonListener extends BasicButtonListener
    {
        JPopupButton button = null;
 
        public JPopupButtonUIButtonListener(JPopupButton b)
        {
            super(b);
            button = b;
        }
 
        void evaluateRollOverOnDownArrow(MouseEvent e)
        {
            JPopupButton      button = (JPopupButton) e.getSource();
            Dimension         dim    = button.getPreferredSize();
            Insets            insets = button.getInsets();
            JPopupButtonModel model  = (JPopupButtonModel) button.getModel();
 
            downArrowRect.x      = dim.width - insets.right - size - model.getIconToDividerSpace();
            downArrowRect.y      = 0;
            downArrowRect.width  = model.getIconToDividerSpace() + size + insets.right;
            downArrowRect.height = dim.height;
 
            model.setRolloverOnDownArrow(downArrowRect.contains(e.getPoint()));
        }
 
        @Override public void mouseEntered(MouseEvent e)
        {
            evaluateRollOverOnDownArrow(e);
            super.mouseEntered(e);
        }
 
        @Override public void mouseMoved(MouseEvent e)
        {
            evaluateRollOverOnDownArrow(e);
            super.mouseMoved(e);
        }
 
        @Override public void mouseExited(MouseEvent e)
        {
            evaluateRollOverOnDownArrow(e);
            super.mouseExited(e);
        }
 
        @Override public void mouseClicked(MouseEvent e)
        {
            JPopupButton      button = (JPopupButton) e.getSource();
            JPopupButtonModel model  = (JPopupButtonModel) button.getModel();
 
            if (model.isRolloverOnDownArrow() && SwingUtilities.isLeftMouseButton(e))
            {
                popUp.removeAll();
                Action[] actions = model.getActions();
 
                for (int i = 0; i < actions.length; i++)
                {
                    popUp.add(actions[i]);
                }
 
                popUp.show(button, 0, button.getBounds().height);
            }
            else if (SwingUtilities.isLeftMouseButton(e))
            {
                model.getActions()[0].actionPerformed(new ActionEvent(e.getSource(), e.getModifiers(),
                                                                      "Action 1"));
            }
        }
 
        JPopupMenu popUp = new JPopupMenu();
    }
}

Please help me in improving this by giving some suggestions to improve the L&F and some other functionalities.

Thanks in Advance

[ July 03, 2007: Message edited by: Pavan Kumar Mankala ]
[ July 03, 2007: Message edited by: Pavan Kumar Mankala ]