/*

 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

 * 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.swing.plaf.basic;

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.plaf.*;

import javax.swing.text.View;

import sun.swing.*;

/**

 * BasicMenuItem implementation

 *

 * @author Georges Saab

 * @author David Karlton

 * @author Arnaud Weber

 * @author Fredrik Lagerblad

 */

public class BasicMenuItemUI extends MenuItemUI

{

    /**

     * The instance of {@code JMenuItem}.

     */

    protected JMenuItem menuItem = null;

    /**

     * The color of the selection background.

     */

    protected Color selectionBackground;

    /**

     * The color of the selection foreground.

     */

    protected Color selectionForeground;

    /**

     * The color of the disabled foreground.

     */

    protected Color disabledForeground;

    /**

     * The color of the accelerator foreground.

     */

    protected Color acceleratorForeground;

    /**

     * The color of the accelerator selection.

     */

    protected Color acceleratorSelectionForeground;

    /**

     * Accelerator delimiter string, such as {@code '+'} in {@code 'Ctrl+C'}.

     * @since 1.7

     */

    protected String acceleratorDelimiter;

    /**

     * The gap between the text and the icon.

     */

    protected int defaultTextIconGap;

    /**

     * The accelerator font.

     */

    protected Font acceleratorFont;

    /**

     * The instance of {@code MouseInputListener}.

     */

    protected MouseInputListener mouseInputListener;

    /**

     * The instance of {@code MenuDragMouseListener}.

     */

    protected MenuDragMouseListener menuDragMouseListener;

    /**

     * The instance of {@code MenuKeyListener}.

     */

    protected MenuKeyListener menuKeyListener;

    /**

     * {@code PropertyChangeListener} returned from

     * {@code createPropertyChangeListener}. You should not

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

     * {@code PropertyChangeListener} override

     * {@code createPropertyChangeListener}.

     *

     * @since 1.6

     * @see #createPropertyChangeListener

     */

    protected PropertyChangeListener propertyChangeListener;

    // BasicMenuUI also uses this.

    Handler handler;

    /**

     * The arrow icon.

     */

    protected Icon arrowIcon = null;

    /**

     * The check icon.

     */

    protected Icon checkIcon = null;

    /**

     * The value represents if the old border is painted.

     */

    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.

    static void loadActionMap(LazyActionMap map) {

        // NOTE: BasicMenuUI also calls into this method.

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

        BasicLookAndFeel.installAudioActionMap(map);

    }

    /**

     * Returns a new instance of {@code BasicMenuItemUI}.

     *

     * @param c a component

     * @return a new instance of {@code BasicMenuItemUI}

     */

    public static ComponentUI createUI(JComponent c) {

        return new BasicMenuItemUI();

    }

    public void installUI(JComponent c) {

        menuItem = (JMenuItem) c;

        installDefaults();

        installComponents(menuItem);

        installListeners();

        installKeyboardActions();

    }

    /**

     * Installs default properties.

     */

    protected void installDefaults() {

        String prefix = getPropertyPrefix();

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

        // use default if missing so that BasicMenuItemUI can be used in other

        // LAFs like Nimbus

        if (acceleratorFont == null) {

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

        }

        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.getBoolean(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 = MenuItemLayoutHelper.isColumnLayout(

                    BasicGraphicsUtils.isLeftToRight(menuItem), menuItem);

            if (isColumnLayout) {

                MenuItemCheckIconFactory iconFactory =

                    (MenuItemCheckIconFactory) UIManager.get(prefix

                        + ".checkIconFactory");

                if (iconFactory != null

                        && MenuItemLayoutHelper.useCheckAndArrow(menuItem)

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

                    checkIcon = iconFactory.getIcon(menuItem);

                }

            }

        }

    }

    /**

     *

     * @param menuItem a menu item

     * @since 1.3

     */

    protected void installComponents(JMenuItem menuItem){

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

    }

    /**

     * Returns a property prefix.

     *

     * @return a property prefix

     */

    protected String getPropertyPrefix() {

        return "MenuItem";

    }

    /**

     * Registers listeners.

     */

    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);

        }

    }

    /**

     * Registers keyboard action.

     */

    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();

        MenuItemLayoutHelper.clearUsedParentClientProperties(menuItem);

        menuItem = null;

    }

    /**

     * Uninstalls default properties.

     */

    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;

    }

    /**

     * Unregisters components.

     *

     * @param menuItem a menu item

     * @since 1.3

     */

    protected void uninstallComponents(JMenuItem menuItem){

        BasicHTML.updateRenderer(menuItem, "");

    }

    /**

     * Unregisters listeners.

     */

    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;

    }

    /**

     * Unregisters keyboard actions.

     */

    protected void uninstallKeyboardActions() {

        SwingUtilities.replaceUIActionMap(menuItem, null);

        SwingUtilities.replaceUIInputMap(menuItem, JComponent.

                                         WHEN_IN_FOCUSED_WINDOW, null);

    }

    /**

     * Returns an instance of {@code MouseInputListener}.

     *

     * @param c a component

     * @return an instance of {@code MouseInputListener}

     */

    protected MouseInputListener createMouseInputListener(JComponent c) {

        return getHandler();

    }

    /**

     * Returns an instance of {@code MenuDragMouseListener}.

     *

     * @param c a component

     * @return an instance of {@code MenuDragMouseListener}

     */

    protected MenuDragMouseListener createMenuDragMouseListener(JComponent c) {

        return getHandler();

    }

    /**

     * Returns an instance of {@code MenuKeyListener}.

     *

     * @param c a component

     * @return an instance of {@code MenuKeyListener}

     */

    protected MenuKeyListener createMenuKeyListener(JComponent c) {

        return null;

    }

    /**

     * Creates a {@code PropertyChangeListener} which will be added to

     * the menu item.

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

     *

     * @param c a component

     * @return an instance of a {@code PropertyChangeListener} 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 the preferred size of a menu item.

     *

     * @param c a component

     * @param checkIcon a check icon

     * @param arrowIcon an arrow icon

     * @param defaultTextIconGap a gap between a text and an icon

     * @return the preferred size of a menu item

     */

    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;

        MenuItemLayoutHelper lh = new MenuItemLayoutHelper(mi, checkIcon,

                arrowIcon, MenuItemLayoutHelper.createMaxRect(), defaultTextIconGap,