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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qmenu.h"

#include "qhash.h"

#include <qdebug.h>

#include "qapplication.h"

#include <private/qt_mac_p.h>

#include "qregexp.h"

#include "qmainwindow.h"

#include "qdockwidget.h"

#include "qtoolbar.h"

#include "qevent.h"

#include "qstyle.h"

#include "qwidgetaction.h"

#include "qmacnativewidget_mac.h"

#include <private/qapplication_p.h>

#include <private/qcocoaapplication_mac_p.h>

#include <private/qmenu_p.h>

#include <private/qmenubar_p.h>

#include <private/qcocoamenuloader_mac_p.h>

#include <private/qcocoamenu_mac_p.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#include <Cocoa/Cocoa.h>

QT_BEGIN_NAMESPACE

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

  QMenu debug facilities

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

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

  QMenu globals

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

bool qt_mac_no_menubar_merge = false;

bool qt_mac_quit_menu_item_enabled = true;

int qt_mac_menus_open_count = 0;

static OSMenuRef qt_mac_create_menu(QWidget *w);

#ifndef QT_MAC_USE_COCOA

static uint qt_mac_menu_static_cmd_id = 'QT00';

const UInt32 kMenuCreatorQt = 'cute';

enum {

    kMenuPropertyQAction = 'QAcT',

    kMenuPropertyQWidget = 'QWId',

    kMenuPropertyCausedQWidget = 'QCAU',

    kMenuPropertyMergeMenu = 'QApP',

    kMenuPropertyMergeList = 'QAmL',

    kMenuPropertyWidgetActionWidget = 'QWid',

    kMenuPropertyWidgetMenu = 'QWMe',

    kHICommandAboutQt = 'AOQT',

    kHICommandCustomMerge = 'AQt0'

};

#endif

static struct {

    QPointer<QMenuBar> qmenubar;

    bool modal;

} qt_mac_current_menubar = { 0, false };

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

  Externals

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

extern OSViewRef qt_mac_hiview_for(const QWidget *w); //qwidget_mac.cpp

extern HIViewRef qt_mac_hiview_for(OSWindowRef w); //qwidget_mac.cpp

extern IconRef qt_mac_create_iconref(const QPixmap &px); //qpixmap_mac.cpp

extern QWidget * mac_keyboard_grabber; //qwidget_mac.cpp

extern bool qt_sendSpontaneousEvent(QObject*, QEvent*); //qapplication_xxx.cpp

RgnHandle qt_mac_get_rgn(); //qregion_mac.cpp

void qt_mac_dispose_rgn(RgnHandle r); //qregion_mac.cpp

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

  QMenu utility functions

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

bool qt_mac_watchingAboutToShow(QMenu *menu)

{

    return menu && menu->receivers(SIGNAL(aboutToShow()));

}

static int qt_mac_CountMenuItems(OSMenuRef menu)

{

    if (menu) {

#ifndef QT_MAC_USE_COCOA

        int ret = 0;

        const int items = CountMenuItems(menu);

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

            MenuItemAttributes attr;

            if (GetMenuItemAttributes(menu, i+1, &attr) == noErr &&

               attr & kMenuItemAttrHidden)

                continue;

            ++ret;

        }

        return ret;

#else

        return [menu numberOfItems];

#endif

    }

    return 0;

}

static quint32 constructModifierMask(quint32 accel_key)

{

    quint32 ret = 0;

    const bool dontSwap = qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta);

#ifndef QT_MAC_USE_COCOA

    if ((accel_key & Qt::ALT) == Qt::ALT)

        ret |= kMenuOptionModifier;

    if ((accel_key & Qt::SHIFT) == Qt::SHIFT)

        ret |= kMenuShiftModifier;

    if (dontSwap) {

        if ((accel_key & Qt::META) != Qt::META)

            ret |= kMenuNoCommandModifier;

        if ((accel_key & Qt::CTRL) == Qt::CTRL)

            ret |= kMenuControlModifier;

    } else {

        if ((accel_key & Qt::CTRL) != Qt::CTRL)

            ret |= kMenuNoCommandModifier;

        if ((accel_key & Qt::META) == Qt::META)

            ret |= kMenuControlModifier;

    }

#else

    if ((accel_key & Qt::CTRL) == Qt::CTRL)

        ret |= (dontSwap ? NSControlKeyMask : NSCommandKeyMask);

    if ((accel_key & Qt::META) == Qt::META)

        ret |= (dontSwap ? NSCommandKeyMask : NSControlKeyMask);

    if ((accel_key & Qt::ALT) == Qt::ALT)

        ret |= NSAlternateKeyMask;

    if ((accel_key & Qt::SHIFT) == Qt::SHIFT)

        ret |= NSShiftKeyMask;

#endif

    return ret;

}

static void cancelAllMenuTracking()

{

#ifdef QT_MAC_USE_COCOA

    QMacCocoaAutoReleasePool pool;

    NSMenu *mainMenu = [NSApp mainMenu];

    [mainMenu cancelTracking];

    for (NSMenuItem *item in [mainMenu itemArray]) {

        if ([item submenu]) {

            [[item submenu] cancelTracking];

        }

    }

#else

    CancelMenuTracking(AcquireRootMenu(), true, 0);

#endif

}

static bool actualMenuItemVisibility(const QMenuBarPrivate::QMacMenuBarPrivate *mbp,

                                     const QMacMenuAction *action)

{

    bool visible = action->action->isVisible();

    if (visible && action->action->text() == QString(QChar(0x14)))

        return false;

    if (visible && action->action->menu() && !action->action->menu()->actions().isEmpty() &&

        !qt_mac_CountMenuItems(action->action->menu()->macMenu(mbp->apple_menu)) &&

        !qt_mac_watchingAboutToShow(action->action->menu())) {

        return false;

    }

    return visible;

}

#ifndef QT_MAC_USE_COCOA

bool qt_mac_activate_action(MenuRef menu, uint command, QAction::ActionEvent action_e, bool by_accel)

{

    //fire event

    QMacMenuAction *action = 0;

    if (GetMenuCommandProperty(menu, command, kMenuCreatorQt, kMenuPropertyQAction, sizeof(action), 0, &action) != noErr) {

        QMenuMergeList *list = 0;

        GetMenuItemProperty(menu, 0, kMenuCreatorQt, kMenuPropertyMergeList,

                            sizeof(list), 0, &list);

        if (!list && qt_mac_current_menubar.qmenubar && qt_mac_current_menubar.qmenubar->isNativeMenuBar()) {

            MenuRef apple_menu = qt_mac_current_menubar.qmenubar->d_func()->mac_menubar->apple_menu;

            GetMenuItemProperty(apple_menu, 0, kMenuCreatorQt, kMenuPropertyMergeList, sizeof(list), 0, &list);

            if (list)

                menu = apple_menu;

        }

        if (list) {

            for(int i = 0; i < list->size(); ++i) {

                QMenuMergeItem item = list->at(i);

                if (item.command == command && item.action) {

                    action = item.action;

                    break;

                }

            }

        }

        if (!action)

            return false;

    }

    if (action_e == QAction::Trigger && by_accel && action->ignore_accel) //no, not a real accel (ie tab)

        return false;

    // Unhighlight the highlighted menu item before triggering the action to

    // prevent items from staying highlighted while a modal dialog is shown.

    // This also fixed the problem that parentless modal dialogs leave

    // the menu item highlighted (since the menu bar is cleared for these types of dialogs).

    if (action_e == QAction::Trigger)

        HiliteMenu(0);

    action->action->activate(action_e);

    //now walk up firing for each "caused" widget (like in the platform independent menu)

    QWidget *caused = 0;

    if (GetMenuItemProperty(menu, 0, kMenuCreatorQt, kMenuPropertyCausedQWidget, sizeof(caused), 0, &caused) == noErr) {

        MenuRef caused_menu = 0;

        if (QMenu *qmenu2 = qobject_cast<QMenu*>(caused))

            caused_menu = qmenu2->macMenu();

        else if (QMenuBar *qmenubar2 = qobject_cast<QMenuBar*>(caused))

            caused_menu = qmenubar2->macMenu();

        else

            caused_menu = 0;

        while(caused_menu) {

            //fire

            QWidget *widget = 0;

            GetMenuItemProperty(caused_menu, 0, kMenuCreatorQt, kMenuPropertyQWidget, sizeof(widget), 0, &widget);

            if (QMenu *qmenu = qobject_cast<QMenu*>(widget)) {

                if (action_e == QAction::Trigger) {

                    emit qmenu->triggered(action->action);

                } else if (action_e == QAction::Hover) {

                    action->action->showStatusText(widget);

                    emit qmenu->hovered(action->action);

                }

            } else if (QMenuBar *qmenubar = qobject_cast<QMenuBar*>(widget)) {

                if (action_e == QAction::Trigger) {

                    emit qmenubar->triggered(action->action);

                } else if (action_e == QAction::Hover) {

                    action->action->showStatusText(widget);

                    emit qmenubar->hovered(action->action);

                }

                break; //nothing more..

            }

            //walk up

            if (GetMenuItemProperty(caused_menu, 0, kMenuCreatorQt, kMenuPropertyCausedQWidget,

                                   sizeof(caused), 0, &caused) != noErr)

                break;

            if (QMenu *qmenu2 = qobject_cast<QMenu*>(caused))

                caused_menu = qmenu2->macMenu();

            else if (QMenuBar *qmenubar2 = qobject_cast<QMenuBar*>(caused))

                caused_menu = qmenubar2->macMenu();

            else

                caused_menu = 0;

        }

    }

    return true;

}

//lookup a QMacMenuAction in a menu

static int qt_mac_menu_find_action(MenuRef menu, MenuCommand cmd)

{

    MenuItemIndex ret_idx;

    MenuRef ret_menu;

    if (GetIndMenuItemWithCommandID(menu, cmd, 1, &ret_menu, &ret_idx) == noErr) {

        if (ret_menu == menu)

            return (int)ret_idx;

    }

    return -1;

}

static int qt_mac_menu_find_action(MenuRef menu, QMacMenuAction *action)

{

    return qt_mac_menu_find_action(menu, action->command);

}

typedef QMultiHash<OSMenuRef, EventHandlerRef> EventHandlerHash;

Q_GLOBAL_STATIC(EventHandlerHash, menu_eventHandlers_hash)

static EventTypeSpec widget_in_menu_events[] = {

    { kEventClassMenu, kEventMenuMeasureItemWidth },

    { kEventClassMenu, kEventMenuMeasureItemHeight },

    { kEventClassMenu, kEventMenuDrawItem },

    { kEventClassMenu, kEventMenuCalculateSize }

};

static OSStatus qt_mac_widget_in_menu_eventHandler(EventHandlerCallRef er, EventRef event, void *)

{

    UInt32 ekind = GetEventKind(event);

    UInt32 eclass = GetEventClass(event);

    OSStatus result = eventNotHandledErr;

    switch (eclass) {

    case kEventClassMenu:

        switch (ekind) {

        default:

            break;

        case kEventMenuMeasureItemWidth: {

            MenuItemIndex item;

            GetEventParameter(event, kEventParamMenuItemIndex, typeMenuItemIndex,

                              0, sizeof(item), 0, &item);

            OSMenuRef menu;

            GetEventParameter(event, kEventParamDirectObject, typeMenuRef, 0, sizeof(menu), 0, &menu);

            QWidget *widget;

            if (GetMenuItemProperty(menu, item, kMenuCreatorQt, kMenuPropertyWidgetActionWidget,

                                 sizeof(widget), 0, &widget) == noErr) {

                short width = short(widget->sizeHint().width());

                SetEventParameter(event, kEventParamMenuItemWidth, typeSInt16,

                                  sizeof(short), &width);

                result = noErr;

            }

            break; }

        case kEventMenuMeasureItemHeight: {

            MenuItemIndex item;

            GetEventParameter(event, kEventParamMenuItemIndex, typeMenuItemIndex,

                              0, sizeof(item), 0, &item);

            OSMenuRef menu;

            GetEventParameter(event, kEventParamDirectObject, typeMenuRef, 0, sizeof(menu), 0, &menu);

            QWidget *widget;

            if (GetMenuItemProperty(menu, item, kMenuCreatorQt, kMenuPropertyWidgetActionWidget,

                                     sizeof(widget), 0, &widget) == noErr && widget) {

                short height = short(widget->sizeHint().height());

                SetEventParameter(event, kEventParamMenuItemHeight, typeSInt16,

                                  sizeof(short), &height);

                result = noErr;

            }

            break; }

        case kEventMenuDrawItem:

            result = noErr;

            break;

        case kEventMenuCalculateSize: {

            result = CallNextEventHandler(er, event);

            if (result == noErr) {

                OSMenuRef menu;

                GetEventParameter(event, kEventParamDirectObject, typeMenuRef, 0, sizeof(menu), 0, &menu);

                HIViewRef content;

                HIMenuGetContentView(menu, kThemeMenuTypePullDown, &content);

                UInt16 count = CountMenuItems(menu);

                for (MenuItemIndex i = 1; i <= count; ++i) {

                    QWidget *widget;

                    if (GetMenuItemProperty(menu, i, kMenuCreatorQt, kMenuPropertyWidgetActionWidget,

                            sizeof(widget), 0, &widget) == noErr && widget) {

                        RgnHandle itemRgn = qt_mac_get_rgn();

                        GetControlRegion(content, i, itemRgn);

                        Rect bounds;

                        GetRegionBounds( itemRgn, &bounds );

                        qt_mac_dispose_rgn(itemRgn);

                        widget->setGeometry(bounds.left, bounds.top,

                                            bounds.right - bounds.left, bounds.bottom - bounds.top);

                    }

                }

            }

            break; }

        }

    }

    return result;

}

//handling of events for menurefs created by Qt..

static EventTypeSpec menu_events[] = {

    { kEventClassCommand, kEventCommandProcess },

    { kEventClassMenu, kEventMenuTargetItem },

    { kEventClassMenu, kEventMenuOpening },

    { kEventClassMenu, kEventMenuClosed }

};

// Special case for kEventMenuMatchKey, see qt_mac_create_menu below.

static EventTypeSpec menu_menu_events[] = {

    { kEventClassMenu, kEventMenuMatchKey }

};

OSStatus qt_mac_menu_event(EventHandlerCallRef er, EventRef event, void *)

{

    QScopedLoopLevelCounter loopLevelCounter(QApplicationPrivate::instance()->threadData);

    bool handled_event = true;

    UInt32 ekind = GetEventKind(event), eclass = GetEventClass(event);

    switch(eclass) {

    case kEventClassCommand:

        if (ekind == kEventCommandProcess) {

            UInt32 context;

            GetEventParameter(event, kEventParamMenuContext, typeUInt32,

                              0, sizeof(context), 0, &context);

            HICommand cmd;

            GetEventParameter(event, kEventParamDirectObject, typeHICommand,

                              0, sizeof(cmd), 0, &cmd);

            if (!mac_keyboard_grabber && (context & kMenuContextKeyMatching)) {

                QMacMenuAction *action = 0;

                if (GetMenuCommandProperty(cmd.menu.menuRef, cmd.commandID, kMenuCreatorQt,

                                          kMenuPropertyQAction, sizeof(action), 0, &action) == noErr) {

                    QWidget *widget = 0;

                    if (qApp->activePopupWidget())

                        widget = (qApp->activePopupWidget()->focusWidget() ?

                                  qApp->activePopupWidget()->focusWidget() : qApp->activePopupWidget());

                    else if (QApplicationPrivate::focus_widget)

                        widget = QApplicationPrivate::focus_widget;

                    if (widget) {

                        int key = action->action->shortcut();

                        QKeyEvent accel_ev(QEvent::ShortcutOverride, (key & (~Qt::KeyboardModifierMask)),

                                           Qt::KeyboardModifiers(key & Qt::KeyboardModifierMask));

                        accel_ev.ignore();

                        qt_sendSpontaneousEvent(widget, &accel_ev);

                        if (accel_ev.isAccepted()) {

                            handled_event = false;

                            break;

                        }

                    }

                }

            }

            handled_event = qt_mac_activate_action(cmd.menu.menuRef, cmd.commandID,

                                                   QAction::Trigger, context & kMenuContextKeyMatching);

        }

        break;

    case kEventClassMenu: {

        MenuRef menu;

        GetEventParameter(event, kEventParamDirectObject, typeMenuRef, NULL, sizeof(menu), NULL, &menu);

        if (ekind == kEventMenuMatchKey) {

            // Don't activate any actions if we are showing a native modal dialog,

            // the key events should go to the dialog in this case.

            if (QApplicationPrivate::native_modal_dialog_active)

                return menuItemNotFoundErr;

             handled_event = false;

        } else if (ekind == kEventMenuTargetItem) {

            MenuCommand command;

            GetEventParameter(event, kEventParamMenuCommand, typeMenuCommand,

                              0, sizeof(command), 0, &command);

            handled_event = qt_mac_activate_action(menu, command, QAction::Hover, false);

        } else if (ekind == kEventMenuOpening || ekind == kEventMenuClosed) {

            qt_mac_menus_open_count += (ekind == kEventMenuOpening) ? 1 : -1;

            MenuRef mr;

            GetEventParameter(event, kEventParamDirectObject, typeMenuRef,

                              0, sizeof(mr), 0, &mr);

            QWidget *widget = 0;

            if (GetMenuItemProperty(mr, 0, kMenuCreatorQt, kMenuPropertyQWidget, sizeof(widget), 0, &widget) == noErr) {

                if (QMenu *qmenu = qobject_cast<QMenu*>(widget)) {

                    handled_event = true;

                    if (ekind == kEventMenuOpening) {

                        emit qmenu->aboutToShow();

                        int merged = 0;

                        const QMenuPrivate::QMacMenuPrivate *mac_menu = qmenu->d_func()->mac_menu;

                        const int ActionItemsCount = mac_menu->actionItems.size();

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

                            QMacMenuAction *action = mac_menu->actionItems.at(i);

                            if (action->action->isSeparator()) {

                                bool hide = false;

                                if(!action->action->isVisible()) {

                                    hide = true;

                                } else if (merged && merged == i) {

                                    hide = true;

                                } else {

                                    for(int l = i+1; l < mac_menu->actionItems.size(); ++l) {

                                        QMacMenuAction *action = mac_menu->actionItems.at(l);

                                        if (action->merged) {

                                            hide = true;

                                        } else if (action->action->isSeparator()) {

                                            if (hide)

                                                break;

                                        } else if (!action->merged) {

                                            hide = false;

                                            break;

                                        }

                                    }

                                }

                                const int index = qt_mac_menu_find_action(mr, action);

                                if (hide) {

                                    ++merged;

                                    ChangeMenuItemAttributes(mr, index, kMenuItemAttrHidden, 0);

                                } else {

                                    ChangeMenuItemAttributes(mr, index, 0, kMenuItemAttrHidden);

                                }

                            } else if (action->merged) {

                                ++merged;

                            }

                        }

                    } else {

                        emit qmenu->aboutToHide();

                    }

                }

            }

        } else {

            handled_event = false;

        }

        break; }

    default:

        handled_event = false;

        break;

    }

    if (!handled_event) //let the event go through

        return CallNextEventHandler(er, event);

    return noErr; //we eat the event