/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package javax.swing.plaf.basic;

import sun.swing.MenuItemCheckIconFactory;

import sun.swing.SwingUtilities2;

import static sun.swing.SwingUtilities2.BASICMENUITEMUI_MAX_TEXT_OFFSET;

import java.awt.*;

import java.awt.event.*;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.border.*;

import javax.swing.plaf.*;

import javax.swing.text.View;

import sun.swing.UIAction;

import sun.swing.StringUIClientPropertyKey;

/**

 * BasicMenuItem implementation

 *

 * @author Georges Saab

 * @author David Karlton

 * @author Arnaud Weber

 * @author Fredrik Lagerblad

 */

public class BasicMenuItemUI extends MenuItemUI

{

    protected JMenuItem menuItem = null;

    protected Color selectionBackground;

    protected Color selectionForeground;

    protected Color disabledForeground;

    protected Color acceleratorForeground;

    protected Color acceleratorSelectionForeground;

    private   String acceleratorDelimiter;

    protected int defaultTextIconGap;

    protected Font acceleratorFont;

    protected MouseInputListener mouseInputListener;

    protected MenuDragMouseListener menuDragMouseListener;

    protected MenuKeyListener menuKeyListener;

    /**

     * <code>PropertyChangeListener</code> returned from

     * <code>createPropertyChangeListener</code>. You should not

     * need to access this field, rather if you want to customize the

     * <code>PropertyChangeListener</code> override

     * <code>createPropertyChangeListener</code>.

     *

     * @since 1.6

     * @see #createPropertyChangeListener

     */

    protected PropertyChangeListener propertyChangeListener;

    // BasicMenuUI also uses this.

    Handler handler;

    protected Icon arrowIcon = null;

    protected Icon checkIcon = null;

    protected boolean oldBorderPainted;

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

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

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

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

    // Allows to reuse layoutInfo object.

    // Shouldn't be used directly. Use getLayoutInfo() instead.

    private final transient LayoutInfo layoutInfo = new LayoutInfo();

    /* Client Property keys for calculation of maximal widths */

    static final StringUIClientPropertyKey MAX_ARROW_WIDTH =

                        new StringUIClientPropertyKey("maxArrowWidth");

    static final StringUIClientPropertyKey MAX_CHECK_WIDTH =

                        new StringUIClientPropertyKey("maxCheckWidth");

    static final StringUIClientPropertyKey MAX_ICON_WIDTH =

                        new StringUIClientPropertyKey("maxIconWidth");

    static final StringUIClientPropertyKey MAX_TEXT_WIDTH =

                        new StringUIClientPropertyKey("maxTextWidth");

    static final StringUIClientPropertyKey MAX_ACC_WIDTH =

                        new StringUIClientPropertyKey("maxAccWidth");

    static final StringUIClientPropertyKey MAX_LABEL_WIDTH =

                        new StringUIClientPropertyKey("maxLabelWidth");

    static void loadActionMap(LazyActionMap map) {

        // NOTE: BasicMenuUI also calls into this method.

        map.put(new Actions(Actions.CLICK));

        BasicLookAndFeel.installAudioActionMap(map);

    }

    public static ComponentUI createUI(JComponent c) {

        return new BasicMenuItemUI();

    }

    public void installUI(JComponent c) {

        menuItem = (JMenuItem) c;

        installDefaults();

        installComponents(menuItem);

        installListeners();

        installKeyboardActions();

    }

    protected void installDefaults() {

        String prefix = getPropertyPrefix();

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

        Object opaque = UIManager.get(getPropertyPrefix() + ".opaque");

        if (opaque != null) {

            LookAndFeel.installProperty(menuItem, "opaque", opaque);

        }

        else {

            LookAndFeel.installProperty(menuItem, "opaque", Boolean.TRUE);

        }

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

           (menuItem.getMargin() instanceof UIResource)) {

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

        }

        LookAndFeel.installProperty(menuItem, "iconTextGap", Integer.valueOf(4));

        defaultTextIconGap = menuItem.getIconTextGap();

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

        oldBorderPainted = menuItem.isBorderPainted();

        LookAndFeel.installProperty(menuItem, "borderPainted",

                                    UIManager.get(prefix + ".borderPainted"));

        LookAndFeel.installColorsAndFont(menuItem,

                                         prefix + ".background",

                                         prefix + ".foreground",

                                         prefix + ".font");

        // MenuItem specific defaults

        if (selectionBackground == null ||

            selectionBackground instanceof UIResource) {

            selectionBackground =

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

        }

        if (selectionForeground == null ||

            selectionForeground instanceof UIResource) {

            selectionForeground =

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

        }

        if (disabledForeground == null ||

            disabledForeground instanceof UIResource) {

            disabledForeground =

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

        }

        if (acceleratorForeground == null ||

            acceleratorForeground instanceof UIResource) {

            acceleratorForeground =

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

        }

        if (acceleratorSelectionForeground == null ||

            acceleratorSelectionForeground instanceof UIResource) {

            acceleratorSelectionForeground =

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

        }

        // Get accelerator delimiter

        acceleratorDelimiter =

            UIManager.getString("MenuItem.acceleratorDelimiter");

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

        // Icons

        if (arrowIcon == null ||

            arrowIcon instanceof UIResource) {

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

        }

        if (checkIcon == null ||

            checkIcon instanceof UIResource) {

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

            //In case of column layout, .checkIconFactory is defined for this UI,

            //the icon is compatible with it and useCheckAndArrow() is true,

            //then the icon is handled by the checkIcon.

            boolean isColumnLayout = LayoutInfo.isColumnLayout(

                    BasicGraphicsUtils.isLeftToRight(menuItem), menuItem);

            if (isColumnLayout) {

                MenuItemCheckIconFactory iconFactory =

                    (MenuItemCheckIconFactory) UIManager.get(prefix

                        + ".checkIconFactory");

                if (iconFactory != null && useCheckAndArrow()

                        && iconFactory.isCompatible(checkIcon, prefix)) {

                    checkIcon = iconFactory.getIcon(menuItem);

                }

            }

        }

    }

    /**

     * @since 1.3

     */

    protected void installComponents(JMenuItem menuItem){

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

    }

    protected String getPropertyPrefix() {

        return "MenuItem";

    }

    protected void installListeners() {

        if ((mouseInputListener = createMouseInputListener(menuItem)) != null) {

            menuItem.addMouseListener(mouseInputListener);

            menuItem.addMouseMotionListener(mouseInputListener);

        }

        if ((menuDragMouseListener = createMenuDragMouseListener(menuItem)) != null) {

            menuItem.addMenuDragMouseListener(menuDragMouseListener);

        }

        if ((menuKeyListener = createMenuKeyListener(menuItem)) != null) {

            menuItem.addMenuKeyListener(menuKeyListener);

        }

        if ((propertyChangeListener = createPropertyChangeListener(menuItem)) != null) {

            menuItem.addPropertyChangeListener(propertyChangeListener);

        }

    }

    protected void installKeyboardActions() {

        installLazyActionMap();

        updateAcceleratorBinding();

    }

    void installLazyActionMap() {

        LazyActionMap.installLazyActionMap(menuItem, BasicMenuItemUI.class,

                                           getPropertyPrefix() + ".actionMap");

    }

    public void uninstallUI(JComponent c) {

        menuItem = (JMenuItem)c;

        uninstallDefaults();

        uninstallComponents(menuItem);

        uninstallListeners();

        uninstallKeyboardActions();

        // Remove values from the parent's Client Properties.

        JComponent p = getMenuItemParent(menuItem);

        if(p != null) {

            p.putClientProperty(BasicMenuItemUI.MAX_ARROW_WIDTH, null );

            p.putClientProperty(BasicMenuItemUI.MAX_CHECK_WIDTH, null );

            p.putClientProperty(BasicMenuItemUI.MAX_ACC_WIDTH, null );

            p.putClientProperty(BasicMenuItemUI.MAX_TEXT_WIDTH, null );

            p.putClientProperty(BasicMenuItemUI.MAX_ICON_WIDTH, null );

            p.putClientProperty(BasicMenuItemUI.MAX_LABEL_WIDTH, null );

            p.putClientProperty(BASICMENUITEMUI_MAX_TEXT_OFFSET, null );

        }

        menuItem = null;

    }

    protected void uninstallDefaults() {

        LookAndFeel.uninstallBorder(menuItem);

        LookAndFeel.installProperty(menuItem, "borderPainted", oldBorderPainted);

        if (menuItem.getMargin() instanceof UIResource)

            menuItem.setMargin(null);

        if (arrowIcon instanceof UIResource)

            arrowIcon = null;

        if (checkIcon instanceof UIResource)

            checkIcon = null;

    }

    /**

     * @since 1.3

     */

    protected void uninstallComponents(JMenuItem menuItem){

        BasicHTML.updateRenderer(menuItem, "");

    }

    protected void uninstallListeners() {

        if (mouseInputListener != null) {

            menuItem.removeMouseListener(mouseInputListener);

            menuItem.removeMouseMotionListener(mouseInputListener);

        }

        if (menuDragMouseListener != null) {

            menuItem.removeMenuDragMouseListener(menuDragMouseListener);

        }

        if (menuKeyListener != null) {

            menuItem.removeMenuKeyListener(menuKeyListener);

        }

        if (propertyChangeListener != null) {

            menuItem.removePropertyChangeListener(propertyChangeListener);

        }

        mouseInputListener = null;

        menuDragMouseListener = null;

        menuKeyListener = null;

        propertyChangeListener = null;

        handler = null;

    }

    protected void uninstallKeyboardActions() {

        SwingUtilities.replaceUIActionMap(menuItem, null);

        SwingUtilities.replaceUIInputMap(menuItem, JComponent.

                                         WHEN_IN_FOCUSED_WINDOW, null);

    }

    protected MouseInputListener createMouseInputListener(JComponent c) {

        return getHandler();

    }

    protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {

        return getHandler();

    }

    protected MenuKeyListener createMenuKeyListener(JComponent c) {

        return null;

    }

    /**

     * Creates a <code>PropertyChangeListener</code> which will be added to

     * the menu item.

     * If this method returns null then it will not be added to the menu item.

     *

     * @return an instance of a <code>PropertyChangeListener</code> or null

     * @since 1.6

     */

    protected PropertyChangeListener

                                  createPropertyChangeListener(JComponent c) {

        return getHandler();

    }

    Handler getHandler() {

        if (handler == null) {

            handler = new Handler();

        }

        return handler;

    }

    InputMap createInputMap(int condition) {

        if (condition == JComponent.WHEN_IN_FOCUSED_WINDOW) {

            return new ComponentInputMapUIResource(menuItem);

        }

        return null;

    }

    void updateAcceleratorBinding() {

        KeyStroke accelerator = menuItem.getAccelerator();

        InputMap windowInputMap = SwingUtilities.getUIInputMap(

                       menuItem, JComponent.WHEN_IN_FOCUSED_WINDOW);

        if (windowInputMap != null) {

            windowInputMap.clear();

        }

        if (accelerator != null) {

            if (windowInputMap == null) {

                windowInputMap = createInputMap(JComponent.

                                                WHEN_IN_FOCUSED_WINDOW);

                SwingUtilities.replaceUIInputMap(menuItem,

                           JComponent.WHEN_IN_FOCUSED_WINDOW, windowInputMap);

            }

            windowInputMap.put(accelerator, "doClick");

        }

    }

    public Dimension getMinimumSize(JComponent c) {

        Dimension d = null;

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

        if (v != null) {

            d = getPreferredSize(c);

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

        }

        return d;

    }

    public Dimension getPreferredSize(JComponent c) {

        return getPreferredMenuItemSize(c,

                                        checkIcon,

                                        arrowIcon,

                                        defaultTextIconGap);

    }

    public Dimension getMaximumSize(JComponent c) {

        Dimension d = null;

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

        if (v != null) {

            d = getPreferredSize(c);

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

        }

        return d;

    }

    // Returns parent of this component if it is not a top-level menu

    // Otherwise returns null

    private static JComponent getMenuItemParent(JMenuItem mi) {

        Container parent = mi.getParent();

        if ((parent instanceof JComponent) &&

             (!(mi instanceof JMenu) ||

               !((JMenu)mi).isTopLevelMenu())) {

            return (JComponent) parent;

        } else {

            return null;

        }

    }

    protected Dimension getPreferredMenuItemSize(JComponent c,

                                                 Icon checkIcon,

                                                 Icon arrowIcon,

                                                 int defaultTextIconGap) {

        // The method also determines the preferred width of the

        // parent popup menu (through DefaultMenuLayout class).

        // The menu width equals to the maximal width

        // among child menu items.

        // Menu item width will be a sum of the widest check icon, label,

        // arrow icon and accelerator text among neighbor menu items.

        // For the latest menu item we will know the maximal widths exactly.

        // It will be the widest menu item and it will determine

        // the width of the parent popup menu.

        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

        // There is a conceptual problem: if user sets preferred size manually

        // for a menu item, this method won't be called for it

        // (see JComponent.getPreferredSize()),

        // maximal widths won't be calculated, other menu items won't be able

        // to take them into account and will be layouted in such a way,

        // as there is no the item with manual preferred size.

        // But after the first paint() method call, all maximal widths

        // will be correctly calculated and layout of some menu items

        // can be changed. For example, it can cause a shift of

        // the icon and text when user points a menu item by mouse.

        JMenuItem mi = (JMenuItem) c;

        LayoutInfo li = getLayoutInfo(mi, checkIcon, arrowIcon,

                createMaxViewRect(), defaultTextIconGap, acceleratorDelimiter,

                BasicGraphicsUtils.isLeftToRight(mi), acceleratorFont,

                useCheckAndArrow(), getPropertyPrefix());

        Dimension result = new Dimension();

        // Calculate the result width

        result.width = li.leadingGap;

        addWidth(li.maxCheckWidth, li.afterCheckIconGap, result);

        // Take into account mimimal text offset.

        if ((!li.isTopLevelMenu)

                && (li.minTextOffset > 0)

                && (result.width < li.minTextOffset)) {

            result.width = li.minTextOffset;

        }

        addWidth(li.maxLabelWidth, li.gap, result);

        addWidth(li.maxAccWidth, li.gap, result);

        addWidth(li.maxArrowWidth, li.gap, result);

        // Calculate the result height

        result.height = max(li.checkRect.height, li.labelRect.height,

                            li.accRect.height, li.arrowRect.height);

        // Take into account menu item insets

        Insets insets = li.mi.getInsets();

        if(insets != null) {

            result.width += insets.left + insets.right;

            result.height += insets.top + insets.bottom;

        }

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

        // for the focus dash line to draw properly

        if(result.width%2 == 0) {

            result.width++;

        }

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

        // for the text to center properly

        if(result.height%2 == 0

                && Boolean.TRUE !=

                    UIManager.get(getPropertyPrefix() + ".evenHeight")) {

            result.height++;

        }

        li.clear();

        return result;

    }

    private Rectangle createMaxViewRect() {

        return new Rectangle(0,0,Short.MAX_VALUE, Short.MAX_VALUE);

    }

    private void addWidth(int width, int gap, Dimension result) {

        if (width > 0) {

            result.width += width + gap;

        }

    }

    private static int max(int... values) {

        int maxValue = Integer.MIN_VALUE;

        for (int i : values) {

            if (i > maxValue) {

                maxValue = i;

            }

        }

        return maxValue;

    }

    // LayoutInfo helps to calculate preferred size and to paint a menu item

    private static class LayoutInfo {

        JMenuItem mi;

        JComponent miParent;

        FontMetrics fm;

        FontMetrics accFm;

        Icon icon;

        Icon checkIcon;