/*

 * Copyright 2005-2008 Sun Microsystems, Inc.  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.  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 sun.awt.X11;

import java.awt.*;

import java.awt.peer.*;

import java.awt.event.*;

import java.awt.image.ColorModel;

import sun.awt.*;

import java.util.ArrayList;

import java.util.Vector;

import java.util.logging.*;

import sun.java2d.SurfaceData;

import sun.java2d.SunGraphics2D;

/**

 * The abstract class XBaseMenuWindow is the superclass

 * of all menu windows.

 */

abstract public class XBaseMenuWindow extends XWindow {

    /************************************************

     *

     * Data members

     *

     ************************************************/

    private static Logger log = Logger.getLogger("sun.awt.X11.XBaseMenuWindow");

    /*

     * Colors are calculated using MotifColorUtilities class

     * from backgroundColor and are contained in these vars.

     */

    private Color backgroundColor;

    private Color foregroundColor;

    private Color lightShadowColor;

    private Color darkShadowColor;

    private Color selectedColor;

    private Color disabledColor;

    /**

     * Array of items.

     */

    private ArrayList<XMenuItemPeer> items;

    /**

     * Index of selected item in array of items

     */

    private int selectedIndex = -1;

    /**

     * Specifies currently showing submenu.

     */

    private XMenuPeer showingSubmenu = null;

    /**

     * Static synchronizational object.

     * Following operations should be synchronized

     * using this object:

     * 1. Access to items vector

     * 2. Access to selection

     * 3. Access to showing menu window member

     *

     * This is lowest level lock,

     * no other locks should be taken when

     * thread own this lock.

     */

    static private Object menuTreeLock = new Object();

    /************************************************

     *

     * Event processing

     *

     ************************************************/

    /**

     * If mouse button is clicked on item showing submenu

     * we have to hide its submenu.

     * And if mouse button is pressed on such item and

     * dragged to another, getShowingSubmenu() is changed.

     * So this member saves the item that the user

     * presses mouse button on _only_ if it's showing submenu.

     */

    private XMenuPeer showingMousePressedSubmenu = null;

    /**

     * If the PopupMenu is invoked as a result of right button click

     * first mouse event after grabInput would be MouseReleased.

     * We need to check if the user has moved mouse after input grab.

     * If yes - hide the PopupMenu. If no - do nothing

     */

    protected Point grabInputPoint = null;

    protected boolean hasPointerMoved = false;

    /************************************************

     *

     * Mapping data

     *

     ************************************************/

    /**

     * Mapping data that is filled in getMappedItems function

     * and reset in resetSize function. It contains array of

     * items in order that they appear on screen and may contain

     * additional data defined by descendants.

     */

    private MappingData mappingData;

    static class MappingData implements Cloneable {

        /**

         * Array of item in order that they appear on screen

         */

        private XMenuItemPeer[] items;

        /**

         * Constructs MappingData object with list

         * of menu items

         */

        MappingData(XMenuItemPeer[] items) {

            this.items = items;

        }

        /**

         * Constructs MappingData without items

         * This constructor should be used in case of errors

         */

        MappingData() {

            this.items = new XMenuItemPeer[0];

        }

        public Object clone() {

            try {

                return super.clone();

            } catch (CloneNotSupportedException ex) {

                throw new InternalError();

            }

        }

        public XMenuItemPeer[] getItems() {

            return this.items;

        }

    }

    /************************************************

     *

     * Construction

     *

     ************************************************/

    XBaseMenuWindow() {

        super(new XCreateWindowParams(new Object[] {

            DELAYED, Boolean.TRUE}));

    }

    /************************************************

     *

     * Abstract methods

     *

     ************************************************/

    /**

     * Returns parent menu window (not the X-heirarchy parent window)

     */

    protected abstract XBaseMenuWindow getParentMenuWindow();

    /**

     * Performs mapping of items in window.

     * This function creates and fills specific

     * descendant of MappingData

     * and sets mapping coordinates of items

     * This function should return default menu data

     * if errors occur

     */

    protected abstract MappingData map();

    /**

     * Calculates placement of submenu window

     * given bounds of item with submenu and

     * size of submenu window. Returns suggested

     * rectangle for submenu window in global coordinates

     * @param itemBounds the bounding rectangle of item

     * in local coordinates

     * @param windowSize the desired size of submenu's window

     */

    protected abstract Rectangle getSubmenuBounds(Rectangle itemBounds, Dimension windowSize);

    /**

     * This function is to be called if it's likely that size

     * of items was changed. It can be called from any thread

     * in any locked state, so it should not take locks

     */

    protected abstract void updateSize();

    /************************************************

     *

     * Initialization

     *

     ************************************************/

    /**

     * Overrides XBaseWindow.instantPreInit

     */

    void instantPreInit(XCreateWindowParams params) {

        super.instantPreInit(params);

        items = new ArrayList();

    }

    /************************************************

     *

     * General-purpose functions

     *

     ************************************************/

    /**

     * Returns static lock used for menus

     */

    static Object getMenuTreeLock() {

        return menuTreeLock;

    }

    /**

     * This function is called to clear all saved

     * size data.

     */

    protected void resetMapping() {

        mappingData = null;

    }

    /**

     * Invokes repaint procedure on eventHandlerThread

     */

    void postPaintEvent() {

        if (isShowing()) {

            PaintEvent pe = new PaintEvent(target, PaintEvent.PAINT,

                                           new Rectangle(0, 0, width, height));

            postEvent(pe);

        }

    }

    /************************************************

     *

     * Utility functions for manipulating items

     *

     ************************************************/

    /**

     * Thread-safely returns item at specified index

     * @param index the position of the item to be returned.

     */

    XMenuItemPeer getItem(int index) {

        if (index >= 0) {

            synchronized(getMenuTreeLock()) {

                if (items.size() > index) {

                    return items.get(index);

                }

            }

        }

        return null;

    }

    /**

     * Thread-safely creates a copy of the items vector

     */

    XMenuItemPeer[] copyItems() {

        synchronized(getMenuTreeLock()) {

            return (XMenuItemPeer[])items.toArray(new XMenuItemPeer[] {});

        }

    }

    /**

     * Thread-safely returns selected item

     */

    XMenuItemPeer getSelectedItem() {

        synchronized(getMenuTreeLock()) {

            if (selectedIndex >= 0) {

                if (items.size() > selectedIndex) {

                    return items.get(selectedIndex);

                }

            }

            return null;

        }

    }

    /**

     * Returns showing submenu, if any

     */

    XMenuPeer getShowingSubmenu() {

        synchronized(getMenuTreeLock()) {

            return showingSubmenu;

        }

    }

    /**

     * Adds item to end of items vector.

     * Note that this function does not perform

     * check for adding duplicate items

     * @param item item to add

     */

    public void addItem(MenuItem item) {

        XMenuItemPeer mp = (XMenuItemPeer)item.getPeer();

        if (mp != null) {

            mp.setContainer(this);

            synchronized(getMenuTreeLock()) {

                items.add(mp);

            }

        } else {

            if (log.isLoggable(Level.FINE)) {

                log.fine("WARNING: Attempt to add menu item without a peer");

            }

        }

        updateSize();

    }

    /**

     * Removes item at the specified index from items vector.

     * @param index the position of the item to be removed

     */

    public void delItem(int index) {

        synchronized(getMenuTreeLock()) {

            if (selectedIndex == index) {

                selectItem(null, false);

            } else if (selectedIndex > index) {

                selectedIndex--;

            }

            if (index < items.size()) {

                items.remove(index);

            } else {

                if (log.isLoggable(Level.FINE)) {

                    log.fine("WARNING: Attempt to remove non-existing menu item, index : " + index + ", item count : " + items.size());

                }

            }

        }

        updateSize();

    }

    /**

     * Clears items vector and loads specified vector

     * @param items vector to be loaded

     */

    public void reloadItems(Vector items) {

        synchronized(getMenuTreeLock()) {

            this.items.clear();

            MenuItem[] itemArray = (MenuItem[])items.toArray(new MenuItem[] {});

            int itemCnt = itemArray.length;

            for(int i = 0; i < itemCnt; i++) {

                addItem(itemArray[i]);

            }

        }

    }

    /**

     * Select specified item and shows/hides submenus if necessary

     * We can not select by index, so we need to select by ref.

     * @param item the item to be selected, null to clear selection

     * @param showWindowIfMenu if the item is XMenuPeer then its

     * window is shown/hidden according to this param.

     */

    void selectItem(XMenuItemPeer item, boolean showWindowIfMenu) {

        synchronized(getMenuTreeLock()) {

            XMenuPeer showingSubmenu = getShowingSubmenu();

            int newSelectedIndex = (item != null) ? items.indexOf(item) : -1;

            if (this.selectedIndex != newSelectedIndex) {

                if (log.isLoggable(Level.FINEST)) {

                    log.finest("Selected index changed, was : " + this.selectedIndex + ", new : " + newSelectedIndex);

                }

                this.selectedIndex = newSelectedIndex;

                postPaintEvent();

            }

            final XMenuPeer submenuToShow = (showWindowIfMenu && (item instanceof XMenuPeer)) ? (XMenuPeer)item : null;

            if (submenuToShow != showingSubmenu) {

                XToolkit.executeOnEventHandlerThread(target, new Runnable() {

                        public void run() {

                            doShowSubmenu(submenuToShow);

                        }

                    });

            }

        }

    }

    /**

     * Performs hiding of currently showing submenu

     * and showing of submenuToShow.

     * This function should be executed on eventHandlerThread

     * @param submenuToShow submenu to be shown or null

     * to hide currently showing submenu

     */

    private void doShowSubmenu(XMenuPeer submenuToShow) {

        XMenuWindow menuWindowToShow = (submenuToShow != null) ? submenuToShow.getMenuWindow() : null;

        Dimension dim = null;

        Rectangle bounds = null;

        //ensureCreated can invoke XWindowPeer.init() ->

        //XWindowPeer.initGraphicsConfiguration() ->

        //Window.getGraphicsConfiguration()

        //that tries to obtain Component.AWTTreeLock.

        //So it should be called outside awtLock()

        if (menuWindowToShow != null) {

            menuWindowToShow.ensureCreated();

        }

        XToolkit.awtLock();

        try {

            synchronized(getMenuTreeLock()) {

                if (showingSubmenu != submenuToShow) {

                    if (log.isLoggable(Level.FINER)) {

                        log.finest("Changing showing submenu");

                    }

                    if (showingSubmenu != null) {

                        XMenuWindow showingSubmenuWindow = showingSubmenu.getMenuWindow();

                        if (showingSubmenuWindow != null) {

                            showingSubmenuWindow.hide();

                        }

                    }

                    if (submenuToShow != null) {

                        dim = menuWindowToShow.getDesiredSize();

                        bounds = menuWindowToShow.getParentMenuWindow().getSubmenuBounds(submenuToShow.getBounds(), dim);

                        menuWindowToShow.show(bounds);

                    }

                    showingSubmenu = submenuToShow;

                }

            }

        } finally {

            XToolkit.awtUnlock();

        }

    }

    final void setItemsFont( Font font ) {

        XMenuItemPeer[] items = copyItems();

        int itemCnt = items.length;

        for (int i = 0; i < itemCnt; i++) {

            items[i].setFont(font);

        }

    }

    /************************************************

     *

     * Utility functions for manipulating mapped items

     *

     ************************************************/

    /**

     * Returns array of mapped items, null if error

     * This function has to be not synchronized

     * and we have to guarantee that we return

     * some MappingData to user. It's OK if

     * this.mappingData is replaced meanwhile

     */

    MappingData getMappingData() {

        MappingData mappingData = this.mappingData;

        if (mappingData == null) {

            mappingData = map();

            this.mappingData = mappingData;

        }

        return (MappingData)mappingData.clone();

    }

    /**

     * returns item thats mapped coordinates contain

     * specified point, null of none.

     * @param pt the point in this window's coordinate system

     */

    XMenuItemPeer getItemFromPoint(Point pt) {

        XMenuItemPeer[] items = getMappingData().getItems();

        int cnt = items.length;

        for (int i = 0; i < cnt; i++) {

            if (items[i].getBounds().contains(pt)) {

                return items[i];

            }

        }

        return null;

    }

    /**

     * Returns first item after currently selected

     * item that can be selected according to mapping array.

     * (no separators and no disabled items).

     * Currently selected item if it's only selectable,

     * null if no item can be selected

     */

    XMenuItemPeer getNextSelectableItem() {

        XMenuItemPeer[] mappedItems = getMappingData().getItems();

        XMenuItemPeer selectedItem = getSelectedItem();

        int cnt = mappedItems.length;

        //Find index of selected item

        int selIdx = -1;

        for (int i = 0; i < cnt; i++) {

            if (mappedItems[i] == selectedItem) {

                selIdx = i;

                break;

            }

        }

        int idx = (selIdx == cnt - 1) ? 0 : selIdx + 1;

        //cycle through mappedItems to find selectable item

        //beginning from the next item and moving to the

        //beginning of array when end is reached.

        //Cycle is finished on selected item itself

        for (int i = 0; i < cnt; i++) {

            XMenuItemPeer item = mappedItems[idx];

            if (!item.isSeparator() && item.isTargetItemEnabled()) {

                return item;

            }

            idx++;

            if (idx >= cnt) {

                idx = 0;