/*

 * Copyright (c) 1997, 2008, 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;

import java.awt.*;

import java.util.*;

import java.awt.event.*;

import javax.swing.event.*;

import sun.awt.AppContext;

/**

 * A MenuSelectionManager owns the selection in menu hierarchy.

 *

 * @author Arnaud Weber

 */

public class MenuSelectionManager {

    private Vector<MenuElement> selection = new Vector<MenuElement>();

    /* 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.

    private static final StringBuilder MENU_SELECTION_MANAGER_KEY =

                       new StringBuilder("javax.swing.MenuSelectionManager");

    /**

     * Returns the default menu selection manager.

     *

     * @return a MenuSelectionManager object

     */

    public static MenuSelectionManager defaultManager() {

        synchronized (MENU_SELECTION_MANAGER_KEY) {

            AppContext context = AppContext.getAppContext();

            MenuSelectionManager msm = (MenuSelectionManager)context.get(

                                                 MENU_SELECTION_MANAGER_KEY);

            if (msm == null) {

                msm = new MenuSelectionManager();

                context.put(MENU_SELECTION_MANAGER_KEY, msm);

            }

            return msm;

        }

    }

    /**

     * Only one ChangeEvent is needed per button model instance since the

     * event's only state is the source property.  The source of events

     * generated is always "this".

     */

    protected transient ChangeEvent changeEvent = null;

    protected EventListenerList listenerList = new EventListenerList();

    /**

     * Changes the selection in the menu hierarchy.  The elements

     * in the array are sorted in order from the root menu

     * element to the currently selected menu element.

     * <p>

     * Note that this method is public but is used by the look and

     * feel engine and should not be called by client applications.

     *

     * @param path  an array of <code>MenuElement</code> objects specifying

     *        the selected path

     */

    public void setSelectedPath(MenuElement[] path) {

        int i,c;

        int currentSelectionCount = selection.size();

        int firstDifference = 0;

        if(path == null) {

            path = new MenuElement[0];

        }

        if (DEBUG) {

            System.out.print("Previous:  "); printMenuElementArray(getSelectedPath());

            System.out.print("New:  "); printMenuElementArray(path);

        }

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

            if (i < currentSelectionCount && selection.elementAt(i) == path[i])

                firstDifference++;

            else

                break;

        }

        for(i=currentSelectionCount - 1 ; i >= firstDifference ; i--) {

            MenuElement me = selection.elementAt(i);

            selection.removeElementAt(i);

            me.menuSelectionChanged(false);

        }

        for(i = firstDifference, c = path.length ; i < c ; i++) {

            if (path[i] != null) {

                selection.addElement(path[i]);

                path[i].menuSelectionChanged(true);

            }

        }

        fireStateChanged();

    }

    /**

     * Returns the path to the currently selected menu item

     *

     * @return an array of MenuElement objects representing the selected path

     */

    public MenuElement[] getSelectedPath() {

        MenuElement res[] = new MenuElement[selection.size()];

        int i,c;

        for(i=0,c=selection.size();i<c;i++)

            res[i] = selection.elementAt(i);

        return res;

    }

    /**

     * Tell the menu selection to close and unselect all the menu components. Call this method

     * when a choice has been made

     */

    public void clearSelectedPath() {

        if (selection.size() > 0) {

            setSelectedPath(null);

        }

    }

    /**

     * Adds a ChangeListener to the button.

     *

     * @param l the listener to add

     */

    public void addChangeListener(ChangeListener l) {

        listenerList.add(ChangeListener.class, l);

    }

    /**

     * Removes a ChangeListener from the button.

     *

     * @param l the listener to remove

     */

    public void removeChangeListener(ChangeListener l) {

        listenerList.remove(ChangeListener.class, l);

    }

    /**

     * Returns an array of all the <code>ChangeListener</code>s added

     * to this MenuSelectionManager with addChangeListener().

     *

     * @return all of the <code>ChangeListener</code>s added or an empty

     *         array if no listeners have been added

     * @since 1.4

     */

    public ChangeListener[] getChangeListeners() {

        return listenerList.getListeners(ChangeListener.class);

    }

    /**

     * Notifies all listeners that have registered interest for

     * notification on this event type.  The event instance

     * is created lazily.

     *

     * @see EventListenerList

     */

    protected void fireStateChanged() {

        // Guaranteed to return a non-null array

        Object[] listeners = listenerList.getListenerList();

        // Process the listeners last to first, notifying

        // those that are interested in this event

        for (int i = listeners.length-2; i>=0; i-=2) {

            if (listeners[i]==ChangeListener.class) {

                // Lazily create the event:

                if (changeEvent == null)

                    changeEvent = new ChangeEvent(this);

                ((ChangeListener)listeners[i+1]).stateChanged(changeEvent);

            }

        }

    }

    /**

     * When a MenuElement receives an event from a MouseListener, it should never process the event

     * directly. Instead all MenuElements should call this method with the event.

     *

     * @param event  a MouseEvent object

     */

    public void processMouseEvent(MouseEvent event) {

        int screenX,screenY;

        Point p;

        int i,c,j,d;

        Component mc;

        Rectangle r2;

        int cWidth,cHeight;

        MenuElement menuElement;

        MenuElement subElements[];

        MenuElement path[];

        Vector<MenuElement> tmp;

        int selectionSize;

        p = event.getPoint();

        Component source = event.getComponent();

        if ((source != null) && !source.isShowing()) {

            // This can happen if a mouseReleased removes the

            // containing component -- bug 4146684

            return;

        }

        int type = event.getID();

        int modifiers = event.getModifiers();

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

        if ((type==MouseEvent.MOUSE_ENTERED||

             type==MouseEvent.MOUSE_EXITED)

            && ((modifiers & (InputEvent.BUTTON1_MASK |

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

            return;

        }

        if (source != null) {

            SwingUtilities.convertPointToScreen(p, source);

        }

        screenX = p.x;

        screenY = p.y;

        tmp = (Vector<MenuElement>)selection.clone();

        selectionSize = tmp.size();

        boolean success = false;

        for (i=selectionSize - 1;i >= 0 && success == false; i--) {

            menuElement = (MenuElement) tmp.elementAt(i);

            subElements = menuElement.getSubElements();

            path = null;

            for (j = 0, d = subElements.length;j < d && success == false; j++) {

                if (subElements[j] == null)

                    continue;

                mc = subElements[j].getComponent();

                if(!mc.isShowing())

                    continue;

                if(mc instanceof JComponent) {

                    cWidth  = mc.getWidth();

                    cHeight = mc.getHeight();

                } else {

                    r2 = mc.getBounds();

                    cWidth  = r2.width;

                    cHeight = r2.height;

                }

                p.x = screenX;

                p.y = screenY;

                SwingUtilities.convertPointFromScreen(p,mc);

                /** Send the event to visible menu element if menu element currently in

                 *  the selected path or contains the event location

                 */

                if(

                   (p.x >= 0 && p.x < cWidth && p.y >= 0 && p.y < cHeight)) {

                    int k;

                    if(path == null) {

                        path = new MenuElement[i+2];

                        for(k=0;k<=i;k++)

                            path[k] = (MenuElement)tmp.elementAt(k);

                    }

                    path[i+1] = subElements[j];

                    MenuElement currentSelection[] = getSelectedPath();

                    // Enter/exit detection -- needs tuning...

                    if (currentSelection[currentSelection.length-1] !=

                        path[i+1] &&

                        (currentSelection.length < 2 ||

                         currentSelection[currentSelection.length-2] !=

                         path[i+1])) {

                        Component oldMC = currentSelection[currentSelection.length-1].getComponent();

                        MouseEvent exitEvent = new MouseEvent(oldMC, MouseEvent.MOUSE_EXITED,

                                                              event.getWhen(),

                                                              event.getModifiers(), p.x, p.y,

                                                              event.getXOnScreen(),

                                                              event.getYOnScreen(),

                                                              event.getClickCount(),

                                                              event.isPopupTrigger(),

                                                              MouseEvent.NOBUTTON);

                        currentSelection[currentSelection.length-1].

                            processMouseEvent(exitEvent, path, this);

                        MouseEvent enterEvent = new MouseEvent(mc,

                                                               MouseEvent.MOUSE_ENTERED,

                                                               event.getWhen(),

                                                               event.getModifiers(), p.x, p.y,

                                                               event.getXOnScreen(),

                                                               event.getYOnScreen(),

                                                               event.getClickCount(),

                                                               event.isPopupTrigger(),

                                                               MouseEvent.NOBUTTON);

                        subElements[j].processMouseEvent(enterEvent, path, this);

                    }

                    MouseEvent mouseEvent = new MouseEvent(mc, event.getID(),event. getWhen(),

                                                           event.getModifiers(), p.x, p.y,

                                                           event.getXOnScreen(),

                                                           event.getYOnScreen(),

                                                           event.getClickCount(),

                                                           event.isPopupTrigger(),

                                                           MouseEvent.NOBUTTON);

                    subElements[j].processMouseEvent(mouseEvent, path, this);

                    success = true;

                    event.consume();

                }

            }

        }

    }

    private void printMenuElementArray(MenuElement path[]) {

        printMenuElementArray(path, false);

    }

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

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

        int i, j;

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

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

                System.out.print("  ");

            MenuElement me = path[i];

            if(me instanceof JMenuItem) {

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

            } else if (me instanceof JMenuBar) {

                System.out.println("JMenuBar, ");

            } else if(me instanceof JPopupMenu) {

                System.out.println("JPopupMenu, ");

            } else if (me == null) {

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

            } else {

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

            }

        }

        System.out.println(")");

        if (dumpStack == true)

            Thread.dumpStack();

    }

    /**

     * Returns the component in the currently selected path

     * which contains sourcePoint.

     *

     * @param source The component in whose coordinate space sourcePoint

     *        is given

     * @param sourcePoint The point which is being tested

     * @return The component in the currently selected path which

     *         contains sourcePoint (relative to the source component's

     *         coordinate space.  If sourcePoint is not inside a component

     *         on the currently selected path, null is returned.

     */

    public Component componentForPoint(Component source, Point sourcePoint) {

        int screenX,screenY;

        Point p = sourcePoint;

        int i,c,j,d;

        Component mc;

        Rectangle r2;

        int cWidth,cHeight;

        MenuElement menuElement;

        MenuElement subElements[];

        Vector<MenuElement> tmp;

        int selectionSize;

        SwingUtilities.convertPointToScreen(p,source);

        screenX = p.x;

        screenY = p.y;

        tmp = (Vector<MenuElement>)selection.clone();

        selectionSize = tmp.size();

        for(i=selectionSize - 1 ; i >= 0 ; i--) {

            menuElement = (MenuElement) tmp.elementAt(i);

            subElements = menuElement.getSubElements();

            for(j = 0, d = subElements.length ; j < d ; j++) {

                if (subElements[j] == null)

                    continue;

                mc = subElements[j].getComponent();

                if(!mc.isShowing())

                    continue;

                if(mc instanceof JComponent) {

                    cWidth  = mc.getWidth();

                    cHeight = mc.getHeight();

                } else {

                    r2 = mc.getBounds();

                    cWidth  = r2.width;

                    cHeight = r2.height;

                }

                p.x = screenX;

                p.y = screenY;

                SwingUtilities.convertPointFromScreen(p,mc);

                /** Return the deepest component on the selection

                 *  path in whose bounds the event's point occurs

                 */

                if (p.x >= 0 && p.x < cWidth && p.y >= 0 && p.y < cHeight) {

                    return mc;

                }

            }

        }

        return null;

    }

    /**

     * When a MenuElement receives an event from a KeyListener, it should never process the event

     * directly. Instead all MenuElements should call this method with the event.

     *

     * @param e  a KeyEvent object

     */

    public void processKeyEvent(KeyEvent e) {

        MenuElement[] sel2 = new MenuElement[0];

        sel2 = selection.toArray(sel2);

        int selSize = sel2.length;

        MenuElement[] path;

        if (selSize < 1) {

            return;

        }

        for (int i=selSize-1; i>=0; i--) {

            MenuElement elem = sel2[i];

            MenuElement[] subs = elem.getSubElements();

            path = null;

            for (int j=0; j<subs.length; j++) {

                if (subs[j] == null || !subs[j].getComponent().isShowing()

                    || !subs[j].getComponent().isEnabled()) {

                    continue;

                }

                if(path == null) {

                    path = new MenuElement[i+2];

                    System.arraycopy(sel2, 0, path, 0, i+1);

                    }

                path[i+1] = subs[j];

                subs[j].processKeyEvent(e, path, this);

                if (e.isConsumed()) {

                    return;

            }

        }

    }

        // finally dispatch event to the first component in path

        path = new MenuElement[1];

        path[0] = sel2[0];

        path[0].processKeyEvent(e, path, this);

        if (e.isConsumed()) {

            return;

        }

    }

    /**

     * Return true if c is part of the currently used menu

     */

    public boolean isComponentPartOfCurrentMenu(Component c) {

        if(selection.size() > 0) {

            MenuElement me = selection.elementAt(0);

            return isComponentPartOfCurrentMenu(me,c);

        } else

            return false;

    }

    private boolean isComponentPartOfCurrentMenu(MenuElement root,Component c) {

        MenuElement children[];

        int i,d;

        if (root == null)

            return false;

        if(root.getComponent() == c)

            return true;

        else {

            children = root.getSubElements();

            for(i=0,d=children.length;i<d;i++) {

                if(isComponentPartOfCurrentMenu(children[i],c))

                    return true;

            }

        }

        return false;

    }

}