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

 * Copyright (c) 2000, 2007 IBM Corporation and others.

 * Portion Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *     Nokia Corporation - Qt implementation

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

package org.eclipse.swt.widgets;

import org.eclipse.swt.internal.qt.OS;

import org.eclipse.swt.internal.qt.WidgetState;

import org.eclipse.swt.*;

import org.eclipse.swt.events.*;

import org.eclipse.swt.graphics.*;

/**

 * Instances of this class are user interface objects that contain

 * menu items.

 * <dl>

 * <dt><b>Styles:</b></dt>

 * <dd>BAR, DROP_DOWN, POP_UP, NO_RADIO_GROUP</dd>

 * <dd>LEFT_TO_RIGHT, RIGHT_TO_LEFT</dd>

 * <dt><b>Events:</b></dt>

 * <dd>Hide, Show </dd>

 * </dl>

 * <p>

 * Note: Only one of BAR, DROP_DOWN and POP_UP may be specified.

 * Only one of LEFT_TO_RIGHT or RIGHT_TO_LEFT may be specified.

 * </p><p>

 * IMPORTANT: This class is <em>not</em> intended to be subclassed.

 * </p>

 */

public class Menu extends Widget {

    //Handle for the QActionGroup used for SWT.RADIO style menus.

    int actionGroupHandle;

    int x, y;

    int itemCount;

    boolean hasLocation;

    MenuItem cascade;

    Decorations parent;

/**

 * Constructs a new instance of this class given its parent,

 * and sets the style for the instance so that the instance

 * will be a popup menu on the given parent's shell.

 *

 * @param parent a control which will be the parent of the new instance (cannot be null)

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>

 *    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>

 * </ul>

 *

 * @see SWT#POP_UP

 * @see Widget#checkSubclass

 * @see Widget#getStyle

 */

public Menu (Control parent) {

    this (checkNull (parent).menuShell (), SWT.POP_UP);

}

/**

 * Constructs a new instance of this class given its parent

 * (which must be a <code>Decorations</code>) and a style value

 * describing its behavior and appearance.

 * <p>

 * The style value is either one of the style constants defined in

 * class <code>SWT</code> which is applicable to instances of this

 * class, or must be built by <em>bitwise OR</em>'ing together

 * (that is, using the <code>int</code> "|" operator) two or more

 * of those <code>SWT</code> style constants. The class description

 * lists the style constants that are applicable to the class.

 * Style bits are also inherited from superclasses.

 * </p>

 *

 * @param parent a decorations control which will be the parent of the new instance (cannot be null)

 * @param style the style of menu to construct

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>

 *    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>

 * </ul>

 *

 * @see SWT#BAR

 * @see SWT#DROP_DOWN

 * @see SWT#POP_UP

 * @see Widget#checkSubclass

 * @see Widget#getStyle

 */

public Menu (Decorations parent, int style) {

    super (parent, checkStyle (style));

    this.parent = parent;

    createWidget (0);

}

/**

 * Constructs a new instance of this class given its parent

 * (which must be a <code>Menu</code>) and sets the style

 * for the instance so that the instance will be a drop-down

 * menu on the given parent's parent.

 *

 * @param parentMenu a menu which will be the parent of the new instance (cannot be null)

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>

 *    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>

 * </ul>

 *

 * @see SWT#DROP_DOWN

 * @see Widget#checkSubclass

 * @see Widget#getStyle

 */

public Menu (Menu parentMenu) {

    this (checkNull (parentMenu).parent, SWT.DROP_DOWN);

}

/**

 * Constructs a new instance of this class given its parent

 * (which must be a <code>MenuItem</code>) and sets the style

 * for the instance so that the instance will be a drop-down

 * menu on the given parent's parent menu.

 *

 * @param parentItem a menu item which will be the parent of the new instance (cannot be null)

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>

 *    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>

 * </ul>

 *

 * @see SWT#DROP_DOWN

 * @see Widget#checkSubclass

 * @see Widget#getStyle

 */

public Menu (MenuItem parentItem) {

    this (checkNull (parentItem).parent);

}

static Control checkNull (Control control) {

    if (control == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);

    return control;

}

static Menu checkNull (Menu menu) {

    if (menu == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);

    return menu;

}

static MenuItem checkNull (MenuItem item) {

    if (item == null) SWT.error (SWT.ERROR_NULL_ARGUMENT);

    return item;

}

static int checkStyle (int style) {

    return checkBits (style, SWT.POP_UP, SWT.BAR, SWT.DROP_DOWN, 0, 0, 0);

}

/**

 * Adds the listener to the collection of listeners who will

 * be notified when menus are hidden or shown, by sending it

 * one of the messages defined in the <code>MenuListener</code>

 * interface.

 *

 * @param listener the listener which should be notified

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 *

 * @see MenuListener

 * @see #removeMenuListener

 */

public void addMenuListener (MenuListener listener) {

    checkWidget();

    if (listener == null) error (SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener (listener);

    addListener (SWT.Hide,typedListener);

    addListener (SWT.Show,typedListener);

}

void createHandle_pp (int index) {

    if ((style & SWT.BAR) != 0) {

        handle = OS.QMenuBar_new( parent.topHandle );

    } else {

        handle = OS.QMenu_new( parent.handle );

    }

    if((style & SWT.RIGHT_TO_LEFT) != 0) {

        OS.QWidget_setLayoutDirection(handle, OS.QT_RIGHTTOLEFT);

    } else {

        OS.QWidget_setLayoutDirection(handle, OS.QT_LEFTTORIGHT);

    }

    topHandle = handle;

    state |= WidgetState.HANDLE;

}

void createWidget (int index) {

    checkOrientation (parent);

    super.createWidget (index);

    parent.addMenu (this);

}

void fixMenus (Decorations newParent) {

// Commented for now, needed for the reparenting of the Controls.

//

//  MenuItem [] items = getItems ();

//  for (int i=0; i<items.length; i++) {

//      items [i].fixMenus (newParent);

//  }

//  parent.removeMenu (this);

//  newParent.addMenu (this);

//  this.parent = newParent;

}

/**

 * Returns the default menu item or null if none has

 * been previously set.

 *

 * @return the default menu item.

 *

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public MenuItem getDefaultItem () {

    checkWidget();

    int actionHandle = OS.QMenu_defaultAction( handle );

    Widget widget = Display.getWidget( actionHandle );

    if( widget != null){

        if (MenuItem.class.isInstance( widget ))

            return (MenuItem)widget;

    }

    return null;

}

/**

 * Returns <code>true</code> if the receiver is enabled, and

 * <code>false</code> otherwise. A disabled menu is typically

 * not selectable from the user interface and draws with an

 * inactive or "grayed" look.

 *

 * @return the receiver's enabled state

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 *

 * @see #isEnabled

 */

public boolean getEnabled () {

    checkWidget();

    return OS.QWidget_isEnabled( handle );

}

/**

 * Returns the item at the given, zero-relative index in the

 * receiver. Throws an exception if the index is out of range.

 *

 * @param index the index of the item to return

 * @return the item at the given index

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (inclusive)</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public MenuItem getItem (int index) {

    checkWidget();

    if(index < 0) error (SWT.ERROR_INVALID_RANGE);

    int[] actions = OS.QWidget_actions(handle);

    int indexOfLastMenuItem = -1;

    MenuItem itemAtIndex = null;

    for(int i = 0; i < actions.length; ++i) {

    	Widget widget = Display.getWidget(actions[i]);

    	if(widget != null && widget instanceof MenuItem) {

    		if(++indexOfLastMenuItem == index) {

    			itemAtIndex = (MenuItem)widget;

    			break;

    		}

    	}

    }

    if(index > indexOfLastMenuItem) {

    	error (SWT.ERROR_INVALID_RANGE);

    }

   	return itemAtIndex;

}

/**

 * Returns the number of items contained in the receiver.

 *

 * @return the number of items

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public int getItemCount () {

    checkWidget();

    return itemCount;

}

/**

 * Returns a (possibly empty) array of <code>MenuItem</code>s which

 * are the items in the receiver.

 * <p>

 * Note: This is not the actual structure used by the receiver

 * to maintain its list of items, so modifying the array will

 * not affect the receiver.

 * </p>

 *

 * @return the items in the receiver

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public MenuItem [] getItems () {

    checkWidget();

    int[] handles = OS.QWidget_actions( handle );

    int count = handles.length;

    if (count == 0) return new MenuItem [0];

    MenuItem [] children = new MenuItem [count];

    int items = 0;

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

        int handle = handles[i];

        if (handle != 0) {

            Widget widget = Display.getWidget (handle);

            if (widget != null && widget != this) {

                if (widget instanceof MenuItem) {

                    children [items++] = (MenuItem) widget;

                }

            }

        }

    }

    if (items == count) return children;

    MenuItem [] newChildren = new MenuItem [items];

    System.arraycopy (children, 0, newChildren, 0, items);

    return newChildren;

}

String getNameText () {

    String result = "";

    MenuItem [] items = getItems ();

    int length = items.length;

    if (length > 0) {

        for (int i=0; i<length-1; i++) {

            result = result + items [i].getNameText() + ", ";

        }

        result = result + items [length-1].getNameText ();

    }

    return result;

}

/**

 * Returns the receiver's parent, which must be a <code>Decorations</code>.

 *

 * @return the receiver's parent

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public Decorations getParent () {

    checkWidget();

    return parent;

}

/**

 * Returns the receiver's parent item, which must be a

 * <code>MenuItem</code> or null when the receiver is a

 * root.

 *

 * @return the receiver's parent item

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public MenuItem getParentItem () {

    checkWidget();

    return cascade;

}

/**

 * Returns the receiver's parent item, which must be a

 * <code>Menu</code> or null when the receiver is a

 * root.

 *

 * @return the receiver's parent item

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public Menu getParentMenu () {

    checkWidget();

    if (cascade == null) return null;

    return cascade.getParent ();

}

/**

 * Returns the receiver's shell. For all controls other than

 * shells, this simply returns the control's nearest ancestor

 * shell. Shells return themselves, even if they are children

 * of other shells.

 *

 * @return the receiver's shell

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 *

 * @see #getParent

 */

public Shell getShell () {

    checkWidget();

    return parent.getShell ();

}

/**

 * Returns <code>true</code> if the receiver is visible, and

 * <code>false</code> otherwise.

 * <p>

 * If one of the receiver's ancestors is not visible or some

 * other condition makes the receiver not visible, this method

 * may still indicate that it is considered visible even though

 * it may not actually be showing.

 * </p>

 *

 * @return the receiver's visibility state

 *

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public boolean getVisible () {

    checkWidget();

    return (!OS.QWidget_isHidden( handle ));

}

void qt_signal_aboutToHide() {

    sendEvent (SWT.Hide);

}

void qt_signal_aboutToShow() {

    sendEvent (SWT.Show);

}

void hookEvents_pp () {

    super.hookEvents_pp ();

    if ((style & SWT.BAR) == 0) {

        int aboutToHideProxy = OS.SignalHandler_new(handle, OS.QSIGNAL_ABOUTTOHIDE);

        OS.QObject_connectOrThrow(handle, "aboutToHide()", aboutToHideProxy, "widgetSignal()", OS.QT_AUTOCONNECTION);

        int aboutToShowProxy = OS.SignalHandler_new(handle, OS.QSIGNAL_ABOUTTOSHOW);

        OS.QObject_connectOrThrow(handle, "aboutToShow()", aboutToShowProxy, "widgetSignal()", OS.QT_AUTOCONNECTION);

    }

}

/**

 * Searches the receiver's list starting at the first item

 * (index 0) until an item is found that is equal to the

 * argument, and returns the index of that item. If no item

 * is found, returns -1.

 *

 * @param item the search item

 * @return the index of the item

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the item is null</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>

 * </ul>

 */

public int indexOf (MenuItem item) {

    checkWidget();

    if (item == null) error (SWT.ERROR_NULL_ARGUMENT);

    MenuItem [] items = getItems ();

    for (int i=0; i<items.length; i++) {

        if (items [i] == item) return i;

    }

    return -1;

}

/**

 * Returns <code>true</code> if the receiver is enabled and all

 * of the receiver's ancestors are enabled, and <code>false</code>

 * otherwise. A disabled menu is typically not selectable from the