/****************************************************************************
**
** Copyright (C) 2009 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 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
}
static EventHandlerRef mac_menu_event_handler = 0;
static EventHandlerUPP mac_menu_eventUPP = 0;
static void qt_mac_cleanup_menu_event()
{
if (mac_menu_event_handler) {
RemoveEventHandler(mac_menu_event_handler);
mac_menu_event_handler = 0;
}
if (mac_menu_eventUPP) {
DisposeEventHandlerUPP(mac_menu_eventUPP);
mac_menu_eventUPP = 0;
}
}
static inline void qt_mac_create_menu_event_handler()
{
if (!mac_menu_event_handler) {
mac_menu_eventUPP = NewEventHandlerUPP(qt_mac_menu_event);
InstallEventHandler(GetApplicationEventTarget(), mac_menu_eventUPP,
GetEventTypeCount(menu_events), menu_events, 0,
&mac_menu_event_handler);
qAddPostRoutine(qt_mac_cleanup_menu_event);
}
}
//enabling of commands
static void qt_mac_command_set_enabled(MenuRef menu, UInt32 cmd, bool b)
{
if (cmd == kHICommandQuit)
qt_mac_quit_menu_item_enabled = b;
if (b) {
EnableMenuCommand(menu, cmd);
if (MenuRef dock_menu = GetApplicationDockTileMenu())
EnableMenuCommand(dock_menu, cmd);
} else {
DisableMenuCommand(menu, cmd);
if (MenuRef dock_menu = GetApplicationDockTileMenu())
DisableMenuCommand(dock_menu, cmd);
}
}
static bool qt_mac_auto_apple_menu(MenuCommand cmd)
{
return (cmd == kHICommandPreferences || cmd == kHICommandQuit);
}
static void qt_mac_get_accel(quint32 accel_key, quint32 *modif, quint32 *key) {
if (modif) {
*modif = constructModifierMask(accel_key);
}
accel_key &= ~(Qt::MODIFIER_MASK | Qt::UNICODE_ACCEL);
if (key) {
*key = 0;
if (accel_key == Qt::Key_Return)
*key = kMenuReturnGlyph;
else if (accel_key == Qt::Key_Enter)
*key = kMenuEnterGlyph;
else if (accel_key == Qt::Key_Tab)
*key = kMenuTabRightGlyph;
else if (accel_key == Qt::Key_Backspace)
*key = kMenuDeleteLeftGlyph;
else if (accel_key == Qt::Key_Delete)
*key = kMenuDeleteRightGlyph;
else if (accel_key == Qt::Key_Escape)
*key = kMenuEscapeGlyph;
else if (accel_key == Qt::Key_PageUp)
*key = kMenuPageUpGlyph;
else if (accel_key == Qt::Key_PageDown)
*key = kMenuPageDownGlyph;
else if (accel_key == Qt::Key_Up)
*key = kMenuUpArrowGlyph;
else if (accel_key == Qt::Key_Down)
*key = kMenuDownArrowGlyph;
else if (accel_key == Qt::Key_Left)
*key = kMenuLeftArrowGlyph;
else if (accel_key == Qt::Key_Right)
*key = kMenuRightArrowGlyph;
else if (accel_key == Qt::Key_CapsLock)
*key = kMenuCapsLockGlyph;
else if (accel_key >= Qt::Key_F1 && accel_key <= Qt::Key_F15)
*key = (accel_key - Qt::Key_F1) + kMenuF1Glyph;
else if (accel_key == Qt::Key_Home)
*key = kMenuNorthwestArrowGlyph;
else if (accel_key == Qt::Key_End)
*key = kMenuSoutheastArrowGlyph;
}
}
#else // Cocoa
static inline void syncNSMenuItemVisiblity(NSMenuItem *menuItem, bool actionVisibility)
{
[menuItem setHidden:NO];
[menuItem setHidden:YES];
[menuItem setHidden:!actionVisibility];
}
static inline void syncNSMenuItemEnabled(NSMenuItem *menuItem, bool enabled)
{
[menuItem setEnabled:NO];
[menuItem setEnabled:YES];
[menuItem setEnabled:enabled];
}
static inline void syncMenuBarItemsVisiblity(const QMenuBarPrivate::QMacMenuBarPrivate *mac_menubar)
{
const QList<QMacMenuAction *> &menubarActions = mac_menubar->actionItems;
for (int i = 0; i < menubarActions.size(); ++i) {
const QMacMenuAction *action = menubarActions.at(i);
syncNSMenuItemVisiblity(action->menuItem, actualMenuItemVisibility(mac_menubar, action));
}
}
static inline QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *getMenuLoader()
{
return [NSApp QT_MANGLE_NAMESPACE(qt_qcocoamenuLoader)];
}
static NSMenuItem *createNSMenuItem(const QString &title)
{
NSMenuItem *item = [[NSMenuItem alloc]
initWithTitle:qt_mac_QStringToNSString(title)
action:@selector(qtDispatcherToQAction:) keyEquivalent:@""];
[item setTarget:getMenuLoader()];
return item;
}
#endif
// helper that recurses into a menu structure and en/dis-ables them
void qt_mac_set_modal_state_helper_recursive(OSMenuRef menu, OSMenuRef merge, bool on)
{
#ifndef QT_MAC_USE_COCOA
for (int i = 0; i < CountMenuItems(menu); i++) {
OSMenuRef submenu;
GetMenuItemHierarchicalMenu(menu, i+1, &submenu);
if (submenu != merge) {
if (submenu)
qt_mac_set_modal_state_helper_recursive(submenu, merge, on);
if (on)
DisableMenuItem(submenu, 0);
else
EnableMenuItem(submenu, 0);
}
}
#else
for (NSMenuItem *item in [menu itemArray]) {
OSMenuRef submenu = [item submenu];
if (submenu != merge) {
if (submenu)
qt_mac_set_modal_state_helper_recursive(submenu, merge, on);
if (!on) {
// The item should follow what the QAction has.
if ([item tag]) {
QAction *action = reinterpret_cast<QAction *>([item tag]);
syncNSMenuItemEnabled(item, action->isEnabled());
} else {
syncNSMenuItemEnabled(item, YES);
}
} else {
syncNSMenuItemEnabled(item, NO);
}
}
}
#endif
}
//toggling of modal state
static void qt_mac_set_modal_state(OSMenuRef menu, bool on)
{
#ifndef QT_MAC_USE_COCOA
OSMenuRef merge = 0;
GetMenuItemProperty(menu, 0, kMenuCreatorQt, kMenuPropertyMergeMenu,
sizeof(merge), 0, &merge);
qt_mac_set_modal_state_helper_recursive(menu, merge, on);
UInt32 commands[] = { kHICommandQuit, kHICommandPreferences, kHICommandAbout, kHICommandAboutQt, 0 };
for(int c = 0; commands[c]; c++) {
bool enabled = !on;
if (enabled) {
QMacMenuAction *action = 0;
GetMenuCommandProperty(menu, commands[c], kMenuCreatorQt, kMenuPropertyQAction,
sizeof(action), 0, &action);
if (!action && merge) {
GetMenuCommandProperty(merge, commands[c], kMenuCreatorQt, kMenuPropertyQAction,
sizeof(action), 0, &action);
if (!action) {
QMenuMergeList *list = 0;
GetMenuItemProperty(merge, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list);
for(int i = 0; list && i < list->size(); ++i) {
QMenuMergeItem item = list->at(i);
if (item.command == commands[c] && item.action) {
action = item.action;
break;
}
}
}
}
if (!action) {
if (commands[c] != kHICommandQuit)
enabled = false;
} else {
enabled = action->action ? action->action->isEnabled() : 0;
}
}
qt_mac_command_set_enabled(menu, commands[c], enabled);
}
#else
OSMenuRef merge = QMenuPrivate::mergeMenuHash.value(menu);
qt_mac_set_modal_state_helper_recursive(menu, merge, on);
// I'm ignoring the special items now, since they should get handled via a syncAction()
#endif
}
bool qt_mac_menubar_is_open()
{
return qt_mac_menus_open_count > 0;
}
void qt_mac_clear_menubar()
{
if (QApplication::testAttribute(Qt::AA_MacPluginApplication))
return;
#ifndef QT_MAC_USE_COCOA
MenuRef clear_menu = 0;
if (CreateNewMenu(0, 0, &clear_menu) == noErr) {
SetRootMenu(clear_menu);
ReleaseMenu(clear_menu);
} else {
qWarning("QMenu: Internal error at %s:%d", __FILE__, __LINE__);
}
ClearMenuBar();
qt_mac_command_set_enabled(0, kHICommandPreferences, false);
InvalMenuBar();
#else
QMacCocoaAutoReleasePool pool;
QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
NSMenu *menu = [loader menu];
[loader ensureAppMenuInMenu:menu];
[NSApp setMainMenu:menu];
#endif
}
QMacMenuAction::~QMacMenuAction()
{
#ifdef QT_MAC_USE_COCOA
[menu release];
// Update the menu item if this action still owns it. For some items
// (like 'Quit') ownership will be transferred between all menu bars...
if (action && action.data() == reinterpret_cast<QAction *>([menuItem tag])) {
QAction::MenuRole role = action->menuRole();
// Check if the item is owned by Qt, and should be hidden to keep it from causing
// problems. Do it for everything but the quit menu item since that should always
// be visible.
if (role > QAction::ApplicationSpecificRole && role < QAction::QuitRole) {
[menuItem setHidden:YES];
} else if (role == QAction::TextHeuristicRole
&& menuItem != [getMenuLoader() quitMenuItem]) {
[menuItem setHidden:YES];
}
[menuItem setTag:nil];
}
[menuItem release];
#endif
}
#ifndef QT_MAC_USE_COCOA
static MenuCommand qt_mac_menu_merge_action(MenuRef merge, QMacMenuAction *action)
#else
static NSMenuItem *qt_mac_menu_merge_action(OSMenuRef merge, QMacMenuAction *action)
#endif
{
if (qt_mac_no_menubar_merge || action->action->menu() || action->action->isSeparator()
|| action->action->menuRole() == QAction::NoRole)
return 0;
QString t = qt_mac_removeMnemonics(action->action->text().toLower());
int st = t.lastIndexOf(QLatin1Char('\t'));
if (st != -1)
t.remove(st, t.length()-st);
t.replace(QRegExp(QString::fromLatin1("\\.*$")), QLatin1String("")); //no ellipses
//now the fun part
#ifndef QT_MAC_USE_COCOA
MenuCommand ret = 0;
#else
NSMenuItem *ret = 0;
QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
#endif
switch (action->action->menuRole()) {
case QAction::NoRole:
ret = 0;
break;
case QAction::ApplicationSpecificRole:
#ifndef QT_MAC_USE_COCOA
{
QMenuMergeList *list = 0;
if (GetMenuItemProperty(merge, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list) == noErr && list) {
MenuCommand lastCustom = kHICommandCustomMerge;
for(int i = 0; i < list->size(); ++i) {
QMenuMergeItem item = list->at(i);
if (item.command == lastCustom)
++lastCustom;
}
ret = lastCustom;
} else {
// The list hasn't been created, so, must be the first one.
ret = kHICommandCustomMerge;
}
}
#else
ret = [loader appSpecificMenuItem];
#endif
break;
case QAction::AboutRole:
#ifndef QT_MAC_USE_COCOA
ret = kHICommandAbout;
#else
ret = [loader aboutMenuItem];
#endif
break;
case QAction::AboutQtRole:
#ifndef QT_MAC_USE_COCOA
ret = kHICommandAboutQt;
#else
ret = [loader aboutQtMenuItem];
#endif
break;
case QAction::QuitRole:
#ifndef QT_MAC_USE_COCOA
ret = kHICommandQuit;
#else
ret = [loader quitMenuItem];
#endif
break;
case QAction::PreferencesRole:
#ifndef QT_MAC_USE_COCOA
ret = kHICommandPreferences;
#else
ret = [loader preferencesMenuItem];
#endif
break;
case QAction::TextHeuristicRole: {
QString aboutString = QMenuBar::tr("About").toLower();
if (t.startsWith(aboutString) || t.endsWith(aboutString)) {
if (t.indexOf(QRegExp(QString::fromLatin1("qt$"), Qt::CaseInsensitive)) == -1) {
#ifndef QT_MAC_USE_COCOA
ret = kHICommandAbout;
#else
ret = [loader aboutMenuItem];
#endif
} else {
#ifndef QT_MAC_USE_COCOA
ret = kHICommandAboutQt;
#else
ret = [loader aboutQtMenuItem];
#endif
}
} else if (t.startsWith(QMenuBar::tr("Config").toLower())
|| t.startsWith(QMenuBar::tr("Preference").toLower())
|| t.startsWith(QMenuBar::tr("Options").toLower())
|| t.startsWith(QMenuBar::tr("Setting").toLower())
|| t.startsWith(QMenuBar::tr("Setup").toLower())) {
#ifndef QT_MAC_USE_COCOA
ret = kHICommandPreferences;
#else
ret = [loader preferencesMenuItem];
#endif
} else if (t.startsWith(QMenuBar::tr("Quit").toLower())
|| t.startsWith(QMenuBar::tr("Exit").toLower())) {
#ifndef QT_MAC_USE_COCOA
ret = kHICommandQuit;
#else
ret = [loader quitMenuItem];
#endif
}
}
break;
}
#ifndef QT_MAC_USE_COCOA
QMenuMergeList *list = 0;
if (GetMenuItemProperty(merge, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list) == noErr && list) {
for(int i = 0; i < list->size(); ++i) {
QMenuMergeItem item = list->at(i);
if (item.command == ret && item.action)
return 0;
}
}
QAction *cmd_action = 0;
if (GetMenuCommandProperty(merge, ret, kMenuCreatorQt, kMenuPropertyQAction,
sizeof(cmd_action), 0, &cmd_action) == noErr && cmd_action)
return 0; //already taken
#else
if (QMenuMergeList *list = QMenuPrivate::mergeMenuItemsHash.value(merge)) {
for(int i = 0; i < list->size(); ++i) {
const QMenuMergeItem &item = list->at(i);
if (item.menuItem == ret && item.action)
return 0;
}
}
#endif
return ret;
}
static QString qt_mac_menu_merge_text(QMacMenuAction *action)
{
QString ret;
#ifdef QT_MAC_USE_COCOA
QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
#endif
if (action->action->menuRole() == QAction::ApplicationSpecificRole)
ret = action->action->text();
#ifndef QT_MAC_USE_COCOA
else if (action->command == kHICommandAbout)
ret = QMenuBar::tr("About %1").arg(qAppName());
else if (action->command == kHICommandAboutQt)
ret = QMenuBar::tr("About Qt");
else if (action->command == kHICommandPreferences)
ret = QMenuBar::tr("Preferences");
else if (action->command == kHICommandQuit)
ret = QMenuBar::tr("Quit %1").arg(qAppName());
#else
else if (action->menuItem == [loader aboutMenuItem])
ret = QMenuBar::tr("About %1").arg(qAppName());
else if (action->menuItem == [loader aboutQtMenuItem])
ret = QMenuBar::tr("About Qt");
else if (action->menuItem == [loader preferencesMenuItem])
ret = QMenuBar::tr("Preferences");
else if (action->menuItem == [loader quitMenuItem])
ret = QMenuBar::tr("Quit %1").arg(qAppName());
#endif
return ret;
}
static QKeySequence qt_mac_menu_merge_accel(QMacMenuAction *action)
{
QKeySequence ret;
#ifdef QT_MAC_USE_COCOA
QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
#endif
if (action->action->menuRole() == QAction::ApplicationSpecificRole)
ret = action->action->shortcut();
#ifndef QT_MAC_USE_COCOA
else if (action->command == kHICommandPreferences)
ret = QKeySequence(QKeySequence::Preferences);
else if (action->command == kHICommandQuit)
ret = QKeySequence(QKeySequence::Quit);
#else
else if (action->menuItem == [loader preferencesMenuItem])
ret = QKeySequence(QKeySequence::Preferences);
else if (action->menuItem == [loader quitMenuItem])
ret = QKeySequence(QKeySequence::Quit);
#endif
return ret;
}
void Q_GUI_EXPORT qt_mac_set_menubar_icons(bool b)
{ QApplication::instance()->setAttribute(Qt::AA_DontShowIconsInMenus, !b); }
void Q_GUI_EXPORT qt_mac_set_native_menubar(bool b)
{ QApplication::instance()->setAttribute(Qt::AA_DontUseNativeMenuBar, !b); }
void Q_GUI_EXPORT qt_mac_set_menubar_merge(bool b) { qt_mac_no_menubar_merge = !b; }
/*****************************************************************************
QMenu bindings
*****************************************************************************/
QMenuPrivate::QMacMenuPrivate::QMacMenuPrivate() : menu(0)
{
}
QMenuPrivate::QMacMenuPrivate::~QMacMenuPrivate()
{
#ifndef QT_MAC_USE_COCOA
for(QList<QMacMenuAction*>::Iterator it = actionItems.begin(); it != actionItems.end(); ++it) {
QMacMenuAction *action = (*it);
RemoveMenuCommandProperty(action->menu, action->command, kMenuCreatorQt, kMenuPropertyQAction);
if (action->merged) {
QMenuMergeList *list = 0;
GetMenuItemProperty(action->menu, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list);
for(int i = 0; list && i < list->size(); ) {
QMenuMergeItem item = list->at(i);
if (item.action == action)
list->removeAt(i);
else
++i;
}
}
delete action;
}
if (menu) {
EventHandlerHash::iterator it = menu_eventHandlers_hash()->find(menu);
while (it != menu_eventHandlers_hash()->end() && it.key() == menu) {
RemoveEventHandler(it.value());
++it;
}
menu_eventHandlers_hash()->remove(menu);
ReleaseMenu(menu);
}
#else
QMacCocoaAutoReleasePool pool;
while (actionItems.size()) {
QMacMenuAction *action = actionItems.takeFirst();
if (QMenuMergeList *list = mergeMenuItemsHash.value(action->menu)) {
int i = 0;
while (i < list->size()) {
const QMenuMergeItem &item = list->at(i);
if (item.action == action)
list->removeAt(i);
else
++i;
}
}
delete action;
}
mergeMenuHash.remove(menu);
mergeMenuItemsHash.remove(menu);
[menu release];
#endif
}
void
QMenuPrivate::QMacMenuPrivate::addAction(QAction *a, QMacMenuAction *before, QMenuPrivate *qmenu)
{
QMacMenuAction *action = new QMacMenuAction;
action->action = a;
action->ignore_accel = 0;
action->merged = 0;
action->menu = 0;
#ifndef QT_MAC_USE_COCOA
action->command = qt_mac_menu_static_cmd_id++;
#endif
addAction(action, before, qmenu);
}
void
QMenuPrivate::QMacMenuPrivate::addAction(QMacMenuAction *action, QMacMenuAction *before, QMenuPrivate *qmenu)
{
#ifdef QT_MAC_USE_COCOA
QMacCocoaAutoReleasePool pool;
Q_UNUSED(qmenu);
#endif
if (!action)
return;
int before_index = actionItems.indexOf(before);
if (before_index < 0) {
before = 0;
before_index = actionItems.size();
}
actionItems.insert(before_index, action);
#ifndef QT_MAC_USE_COCOA
int index = qt_mac_menu_find_action(menu, action);
#else
[menu retain];
[action->menu release];
#endif
action->menu = menu;
/* When the action is considered a mergable action it
will stay that way, until removed.. */
if (!qt_mac_no_menubar_merge) {
#ifndef QT_MAC_USE_COCOA
MenuRef merge = 0;
GetMenuItemProperty(menu, 0, kMenuCreatorQt, kMenuPropertyMergeMenu,
sizeof(merge), 0, &merge);
#else
OSMenuRef merge = QMenuPrivate::mergeMenuHash.value(menu);
#endif
if (merge) {
#ifndef QT_MAC_USE_COCOA
if (MenuCommand cmd = qt_mac_menu_merge_action(merge, action)) {
action->merged = 1;
action->menu = merge;
action->command = cmd;
if (qt_mac_auto_apple_menu(cmd))
index = 0; //no need
QMenuMergeList *list = 0;
if (GetMenuItemProperty(merge, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list) != noErr || !list) {
list = new QMenuMergeList;
SetMenuItemProperty(merge, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), &list);
}
list->append(QMenuMergeItem(cmd, action));
}
#else
if (NSMenuItem *cmd = qt_mac_menu_merge_action(merge, action)) {
action->merged = 1;
[merge retain];
[action->menu release];
action->menu = merge;
[cmd retain];
[cmd setAction:@selector(qtDispatcherToQAction:)];
[cmd setTarget:getMenuLoader()];
[action->menuItem release];
action->menuItem = cmd;
QMenuMergeList *list = QMenuPrivate::mergeMenuItemsHash.value(merge);
if (!list) {
list = new QMenuMergeList;
QMenuPrivate::mergeMenuItemsHash.insert(merge, list);
}
list->append(QMenuMergeItem(cmd, action));
}
#endif
}
}
#ifdef QT_MAC_USE_COCOA
NSMenuItem *newItem = action->menuItem;
#endif
if (
#ifndef QT_MAC_USE_COCOA
index == -1
#else
newItem == 0
#endif
) {
#ifndef QT_MAC_USE_COCOA
index = before_index;
MenuItemAttributes attr = kMenuItemAttrAutoRepeat;
#else
newItem = createNSMenuItem(action->action->text());
action->menuItem = newItem;
#endif
if (before) {
#ifndef QT_MAC_USE_COCOA
InsertMenuItemTextWithCFString(action->menu, 0, qMax(before_index, 0), attr, action->command);
#else
[menu insertItem:newItem atIndex:qMax(before_index, 0)];
#endif
} else {
#ifndef QT_MAC_USE_COCOA
// Append the menu item to the menu. If it is a kHICommandAbout or a kHICommandAboutQt append
// a separator also (to get a separator above "Preferences"), but make sure that we don't
// add separators between two "about" items.
// Build a set of all commands that could possibly be before the separator.
QSet<MenuCommand> mergedItems;
mergedItems.insert(kHICommandAbout);
mergedItems.insert(kHICommandAboutQt);
mergedItems.insert(kHICommandCustomMerge);
QMenuMergeList *list = 0;
if (GetMenuItemProperty(action->menu, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list) == noErr && list) {
for (int i = 0; i < list->size(); ++i) {
MenuCommand command = list->at(i).command;
if (command > kHICommandCustomMerge) {
mergedItems.insert(command);
}
}
}
const int itemCount = CountMenuItems(action->menu);
MenuItemAttributes testattr;
GetMenuItemAttributes(action->menu, itemCount , &testattr);
if (mergedItems.contains(action->command)
&& (testattr & kMenuItemAttrSeparator)) {
InsertMenuItemTextWithCFString(action->menu, 0, qMax(itemCount - 1, 0), attr, action->command);
index = itemCount;
} else {
MenuItemIndex tmpIndex;
AppendMenuItemTextWithCFString(action->menu, 0, attr, action->command, &tmpIndex);
index = tmpIndex;
if (mergedItems.contains(action->command))
AppendMenuItemTextWithCFString(action->menu, 0, kMenuItemAttrSeparator, 0, &tmpIndex);
}
#else
[menu addItem:newItem];
#endif
}
QWidget *widget = qmenu ? qmenu->widgetItems.value(action->action) : 0;
if (widget) {
#ifndef QT_MAC_USE_COCOA
ChangeMenuAttributes(action->menu, kMenuAttrDoNotCacheImage, 0);
attr = kMenuItemAttrCustomDraw;
SetMenuItemProperty(action->menu, index, kMenuCreatorQt, kMenuPropertyWidgetActionWidget,
sizeof(QWidget *), &widget);
HIViewRef content;
HIMenuGetContentView(action->menu, kThemeMenuTypePullDown, &content);
EventHandlerRef eventHandlerRef;
InstallMenuEventHandler(action->menu, qt_mac_widget_in_menu_eventHandler,
GetEventTypeCount(widget_in_menu_events),
widget_in_menu_events, 0, &eventHandlerRef);
menu_eventHandlers_hash()->insert(action->menu, eventHandlerRef);
QWidget *menuWidget = 0;
GetMenuItemProperty(action->menu, 0, kMenuCreatorQt, kMenuPropertyWidgetMenu,
sizeof(menuWidget), 0, &menuWidget);
if(!menuWidget) {
menuWidget = new QMacNativeWidget(content);
SetMenuItemProperty(menu, 0, kMenuCreatorQt, kMenuPropertyWidgetMenu,
sizeof(menuWidget), &menuWidget);
menuWidget->show();
}
widget->setParent(menuWidget);
#else
QMacNativeWidget *container = new QMacNativeWidget(0);
container->resize(widget->sizeHint());
widget->setAttribute(Qt::WA_LayoutUsesWidgetRect);
widget->setParent(container);
NSView *containerView = qt_mac_nativeview_for(container);
[containerView setAutoresizesSubviews:YES];
[containerView setAutoresizingMask:NSViewWidthSizable];
[qt_mac_nativeview_for(widget) setAutoresizingMask:NSViewWidthSizable];
[newItem setView:containerView];
container->show();
#endif
widget->show();
}
} else {
#ifndef QT_MAC_USE_COCOA
qt_mac_command_set_enabled(action->menu, action->command, !QApplicationPrivate::modalState());
#else
[newItem setEnabled:!QApplicationPrivate::modalState()];
#endif
}
#ifndef QT_MAC_USE_COCOA
SetMenuCommandProperty(action->menu, action->command, kMenuCreatorQt, kMenuPropertyQAction,
sizeof(action), &action);
#else
[newItem setTag:long(static_cast<QAction *>(action->action))];
#endif
syncAction(action);
}
// return an autoreleased string given a QKeySequence (currently only looks at the first one).
NSString *keySequenceToKeyEqivalent(const QKeySequence &accel)
{
quint32 accel_key = (accel[0] & ~(Qt::MODIFIER_MASK | Qt::UNICODE_ACCEL));
extern QChar qt_macSymbolForQtKey(int key); // qkeysequence.cpp
QChar keyEquiv = qt_macSymbolForQtKey(accel_key);
if (keyEquiv.isNull()) {
if (accel_key >= Qt::Key_F1 && accel_key <= Qt::Key_F15)
keyEquiv = (accel_key - Qt::Key_F1) + NSF1FunctionKey;
else
keyEquiv = unichar(QChar(accel_key).toLower().unicode());
}
return [NSString stringWithCharacters:&keyEquiv.unicode() length:1];
}
// return the cocoa modifier mask for the QKeySequence (currently only looks at the first one).
NSUInteger keySequenceModifierMask(const QKeySequence &accel)
{
return constructModifierMask(accel[0]);
}
void
QMenuPrivate::QMacMenuPrivate::syncAction(QMacMenuAction *action)
{
if (!action)
return;
#ifndef QT_MAC_USE_COCOA
const int index = qt_mac_menu_find_action(action->menu, action);
if (index == -1)
return;
#else
NSMenuItem *item = action->menuItem;
if (!item)
return;
#endif
#ifndef QT_MAC_USE_COCOA
if (!action->action->isVisible()) {
ChangeMenuItemAttributes(action->menu, index, kMenuItemAttrHidden, 0);
return;
}
ChangeMenuItemAttributes(action->menu, index, 0, kMenuItemAttrHidden);
#else
QMacCocoaAutoReleasePool pool;
NSMenu *menu = [item menu];
bool actionVisible = action->action->isVisible();
[item setHidden:!actionVisible];
if (!actionVisible)
return;
#endif
#ifndef QT_MAC_USE_COCOA
if (action->action->isSeparator()) {
ChangeMenuItemAttributes(action->menu, index, kMenuItemAttrSeparator, 0);
return;
}
ChangeMenuItemAttributes(action->menu, index, 0, kMenuItemAttrSeparator);
#else
int itemIndex = [menu indexOfItem:item];
Q_ASSERT(itemIndex != -1);
if (action->action->isSeparator()) {
action->menuItem = [NSMenuItem separatorItem];
[action->menuItem retain];
[menu insertItem: action->menuItem atIndex:itemIndex];
[menu removeItem:item];
[item release];
item = action->menuItem;
return;
} else if ([item isSeparatorItem]) {
// I'm no longer a separator...
action->menuItem = createNSMenuItem(action->action->text());
[menu insertItem:action->menuItem atIndex:itemIndex];
[menu removeItem:item];
[item release];
item = action->menuItem;
}
#endif
//find text (and accel)
action->ignore_accel = 0;
QString text = action->action->text();
QKeySequence accel = action->action->shortcut();
{
int st = text.lastIndexOf(QLatin1Char('\t'));
if (st != -1) {
action->ignore_accel = 1;
accel = QKeySequence(text.right(text.length()-(st+1)));
text.remove(st, text.length()-st);
}
}
{
QString cmd_text = qt_mac_menu_merge_text(action);
if (!cmd_text.isEmpty()) {
text = cmd_text;
accel = qt_mac_menu_merge_accel(action);
}
}
// Show multiple key sequences as part of the menu text.
if (accel.count() > 1)
text += QLatin1String(" (") + accel.toString(QKeySequence::NativeText) + QLatin1String(")");
QString finalString = qt_mac_removeMnemonics(text);
#ifndef QT_MAC_USE_COCOA
MenuItemDataRec data;
memset(&data, '\0', sizeof(data));
//Carbon text
data.whichData |= kMenuItemDataCFString;
QCFString cfstring(finalString); // Hold the reference to the end of the function.
data.cfText = cfstring;
// Carbon enabled
data.whichData |= kMenuItemDataEnabled;
data.enabled = action->action->isEnabled();
// Carbon icon
data.whichData |= kMenuItemDataIconHandle;
if (!action->action->icon().isNull()
&& action->action->isIconVisibleInMenu()) {
data.iconType = kMenuIconRefType;
data.iconHandle = (Handle)qt_mac_create_iconref(action->action->icon().pixmap(16, QIcon::Normal));
} else {
data.iconType = kMenuNoIcon;
}
if (action->action->font().resolve()) { // Carbon font
if (action->action->font().bold())
data.style |= bold;
if (action->action->font().underline())
data.style |= underline;
if (action->action->font().italic())
data.style |= italic;
if (data.style)
data.whichData |= kMenuItemDataStyle;
data.whichData |= kMenuItemDataFontID;
data.fontID = action->action->font().macFontID();
}
#else
// Cocoa Font and title
if (action->action->font().resolve()) {
const QFont &actionFont = action->action->font();
NSFont *customMenuFont = [NSFont fontWithName:qt_mac_QStringToNSString(actionFont.family())
size:actionFont.pointSize()];
NSArray *keys = [NSArray arrayWithObjects:NSFontAttributeName, nil];
NSArray *objects = [NSArray arrayWithObjects:customMenuFont, nil];
NSDictionary *attributes = [NSDictionary dictionaryWithObjects:objects forKeys:keys];
NSAttributedString *str = [[[NSAttributedString alloc] initWithString:qt_mac_QStringToNSString(finalString)
attributes:attributes] autorelease];
[item setAttributedTitle: str];
} else {
[item setTitle: qt_mac_QStringToNSString(finalString)];
}
[item setTitle:qt_mac_QStringToNSString(qt_mac_removeMnemonics(text))];
// Cocoa Enabled
[item setEnabled: action->action->isEnabled()];
// Cocoa icon
NSImage *nsimage = 0;
if (!action->action->icon().isNull() && action->action->isIconVisibleInMenu()) {
nsimage = static_cast<NSImage *>(qt_mac_create_nsimage(action->action->icon().pixmap(16, QIcon::Normal)));
}
[item setImage:nsimage];
[nsimage release];
#endif
if (action->action->menu()) { //submenu
#ifndef QT_MAC_USE_COCOA
data.whichData |= kMenuItemDataSubmenuHandle;
data.submenuHandle = action->action->menu()->macMenu();
QWidget *caused = 0;
GetMenuItemProperty(action->menu, 0, kMenuCreatorQt, kMenuPropertyQWidget, sizeof(caused), 0, &caused);
SetMenuItemProperty(data.submenuHandle, 0, kMenuCreatorQt, kMenuPropertyCausedQWidget, sizeof(caused), &caused);
#else
NSMenu *subMenu = static_cast<NSMenu *>(action->action->menu()->macMenu());
if ([subMenu supermenu] && [subMenu supermenu] != [item menu]) {
// The menu is already a sub-menu of another one. Cocoa will throw an exception,
// in such cases. For the time being, a new QMenu with same set of actions is the
// only workaround.
action->action->setEnabled(false);
} else {
[item setSubmenu:subMenu];
}
#endif
} else { //respect some other items
#ifndef QT_MAC_USE_COCOA
//shortcuts (say we are setting them all so that we can also clear them).
data.whichData |= kMenuItemDataCmdKey;
data.whichData |= kMenuItemDataCmdKeyModifiers;
data.whichData |= kMenuItemDataCmdKeyGlyph;
if (accel.count() == 1) {
qt_mac_get_accel(accel[0], (quint32*)&data.cmdKeyModifiers, (quint32*)&data.cmdKeyGlyph);
if (data.cmdKeyGlyph == 0)
data.cmdKey = (UniChar)accel[0];
}
#else
[item setSubmenu:0];
// No key equivalent set for multiple key QKeySequence.
if (accel.count() == 1) {
[item setKeyEquivalent:keySequenceToKeyEqivalent(accel)];
[item setKeyEquivalentModifierMask:keySequenceModifierMask(accel)];
} else {
[item setKeyEquivalent:@""];
[item setKeyEquivalentModifierMask:NSCommandKeyMask];
}
#endif
}
#ifndef QT_MAC_USE_COCOA
//mark glyph
data.whichData |= kMenuItemDataMark;
if (action->action->isChecked()) {
#if 0
if (action->action->actionGroup() &&
action->action->actionGroup()->isExclusive())
data.mark = diamondMark;
else
#endif
data.mark = checkMark;
} else {
data.mark = noMark;
}
//actually set it
SetMenuItemData(action->menu, action->command, true, &data);
// Free up memory
if (data.iconHandle)
ReleaseIconRef(IconRef(data.iconHandle));
#else
//mark glyph
[item setState:action->action->isChecked() ? NSOnState : NSOffState];
#endif
}
void
QMenuPrivate::QMacMenuPrivate::removeAction(QMacMenuAction *action)
{
if (!action)
return;
#ifndef QT_MAC_USE_COCOA
if (action->command == kHICommandQuit || action->command == kHICommandPreferences)
qt_mac_command_set_enabled(action->menu, action->command, false);
else
DeleteMenuItem(action->menu, qt_mac_menu_find_action(action->menu, action));
#else
QMacCocoaAutoReleasePool pool;
if (action->merged) {
if (reinterpret_cast<QAction *>([action->menuItem tag]) == action->action) {
QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
[action->menuItem setEnabled:false];
if (action->menuItem != [loader quitMenuItem]
&& action->menuItem != [loader preferencesMenuItem]) {
[[action->menuItem menu] removeItem:action->menuItem];
}
}
} else {
[[action->menuItem menu] removeItem:action->menuItem];
}
#endif
actionItems.removeAll(action);
}
OSMenuRef
QMenuPrivate::macMenu(OSMenuRef merge)
{
Q_UNUSED(merge);
Q_Q(QMenu);
if (mac_menu && mac_menu->menu)
return mac_menu->menu;
if (!mac_menu)
mac_menu = new QMacMenuPrivate;
mac_menu->menu = qt_mac_create_menu(q);
if (merge) {
#ifndef QT_MAC_USE_COCOA
SetMenuItemProperty(mac_menu->menu, 0, kMenuCreatorQt, kMenuPropertyMergeMenu, sizeof(merge), &merge);
#else
mergeMenuHash.insert(mac_menu->menu, merge);
#endif
}
QList<QAction*> items = q->actions();
for(int i = 0; i < items.count(); i++)
mac_menu->addAction(items[i], 0, this);
syncSeparatorsCollapsible(collapsibleSeparators);
return mac_menu->menu;
}
/*!
\internal
*/
void
QMenuPrivate::syncSeparatorsCollapsible(bool collapse)
{
#ifndef QT_MAC_USE_COCOA
if (collapse)
ChangeMenuAttributes(mac_menu->menu, kMenuAttrCondenseSeparators, 0);
else
ChangeMenuAttributes(mac_menu->menu, 0, kMenuAttrCondenseSeparators);
#else
qt_mac_menu_collapseSeparators(mac_menu->menu, collapse);
#endif
}
/*!
\internal
*/
void QMenuPrivate::setMacMenuEnabled(bool enable)
{
if (!macMenu(0))
return;
QMacCocoaAutoReleasePool pool;
if (enable) {
for (int i = 0; i < mac_menu->actionItems.count(); ++i) {
QMacMenuAction *menuItem = mac_menu->actionItems.at(i);
if (menuItem && menuItem->action && menuItem->action->isEnabled()) {
#ifndef QT_MAC_USE_COCOA
// Only enable those items which contains an enabled QAction.
// i == 0 -> the menu itself, hence i + 1 for items.
EnableMenuItem(mac_menu->menu, i + 1);
#else
[menuItem->menuItem setEnabled:true];
#endif
}
}
} else {
#ifndef QT_MAC_USE_COCOA
DisableAllMenuItems(mac_menu->menu);
#else
NSMenu *menu = mac_menu->menu;
for (NSMenuItem *item in [menu itemArray]) {
[item setEnabled:false];
}
#endif
}
}
/*!
\internal
This function will return the OSMenuRef used to create the native menu bar
bindings.
If Qt is built against Carbon, the OSMenuRef is a MenuRef that can be used
with Carbon's Menu Manager API.
If Qt is built against Cocoa, the OSMenuRef is a NSMenu pointer.
\warning This function is not portable.
\sa QMenuBar::macMenu()
*/
OSMenuRef QMenu::macMenu(OSMenuRef merge) { return d_func()->macMenu(merge); }
/*****************************************************************************
QMenuBar bindings
*****************************************************************************/
typedef QHash<QWidget *, QMenuBar *> MenuBarHash;
Q_GLOBAL_STATIC(MenuBarHash, menubars)
static QMenuBar *fallback = 0;
QMenuBarPrivate::QMacMenuBarPrivate::QMacMenuBarPrivate() : menu(0), apple_menu(0)
{
}
QMenuBarPrivate::QMacMenuBarPrivate::~QMacMenuBarPrivate()
{
for(QList<QMacMenuAction*>::Iterator it = actionItems.begin(); it != actionItems.end(); ++it)
delete (*it);
#ifndef QT_MAC_USE_COCOA
if (apple_menu) {
QMenuMergeList *list = 0;
GetMenuItemProperty(apple_menu, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list);
if (list) {
RemoveMenuItemProperty(apple_menu, 0, kMenuCreatorQt, kMenuPropertyMergeList);
delete list;
}
ReleaseMenu(apple_menu);
}
if (menu)
ReleaseMenu(menu);
#else
[apple_menu release];
[menu release];
#endif
}
void
QMenuBarPrivate::QMacMenuBarPrivate::addAction(QAction *a, QMacMenuAction *before)
{
if (a->isSeparator() || !menu)
return;
QMacMenuAction *action = new QMacMenuAction;
action->action = a;
action->ignore_accel = 1;
#ifndef QT_MAC_USE_COCOA
action->command = qt_mac_menu_static_cmd_id++;
#endif
addAction(action, before);
}
void
QMenuBarPrivate::QMacMenuBarPrivate::addAction(QMacMenuAction *action, QMacMenuAction *before)
{
if (!action || !menu)
return;
int before_index = actionItems.indexOf(before);
if (before_index < 0) {
before = 0;
before_index = actionItems.size();
}
actionItems.insert(before_index, action);
MenuItemIndex index = actionItems.size()-1;
action->menu = menu;
#ifdef QT_MAC_USE_COCOA
QMacCocoaAutoReleasePool pool;
[action->menu retain];
NSMenuItem *newItem = createNSMenuItem(action->action->text());
action->menuItem = newItem;
#endif
if (before) {
#ifndef QT_MAC_USE_COCOA
InsertMenuItemTextWithCFString(action->menu, 0, qMax(1, before_index+1), 0, action->command);
#else
[menu insertItem:newItem atIndex:qMax(1, before_index + 1)];
#endif
index = before_index;
} else {
#ifndef QT_MAC_USE_COCOA
AppendMenuItemTextWithCFString(action->menu, 0, 0, action->command, &index);
#else
[menu addItem:newItem];
#endif
}
#ifndef QT_MAC_USE_COCOA
SetMenuItemProperty(action->menu, index, kMenuCreatorQt, kMenuPropertyQAction, sizeof(action),
&action);
#else
[newItem setTag:long(static_cast<QAction *>(action->action))];
#endif
syncAction(action);
}
void
QMenuBarPrivate::QMacMenuBarPrivate::syncAction(QMacMenuAction *action)
{
if (!action || !menu)
return;
#ifndef QT_MAC_USE_COCOA
const int index = qt_mac_menu_find_action(action->menu, action);
#else
QMacCocoaAutoReleasePool pool;
NSMenuItem *item = action->menuItem;
#endif
OSMenuRef submenu = 0;
bool release_submenu = false;
if (action->action->menu()) {
if ((submenu = action->action->menu()->macMenu(apple_menu))) {
#ifndef QT_MAC_USE_COCOA
QWidget *caused = 0;
GetMenuItemProperty(action->menu, 0, kMenuCreatorQt, kMenuPropertyQWidget, sizeof(caused), 0, &caused);
SetMenuItemProperty(submenu, 0, kMenuCreatorQt, kMenuPropertyCausedQWidget, sizeof(caused), &caused);
#else
if ([submenu supermenu] && [submenu supermenu] != [item menu])
return;
else
[item setSubmenu:submenu];
#endif
}
#ifndef QT_MAC_USE_COCOA
} else { // create a submenu to act as menu
release_submenu = true;
CreateNewMenu(0, 0, &submenu);
#endif
}
if (submenu) {
bool visible = actualMenuItemVisibility(this, action);
#ifndef QT_MAC_USE_COCOA
SetMenuItemHierarchicalMenu(action->menu, index, submenu);
SetMenuTitleWithCFString(submenu, QCFString(qt_mac_removeMnemonics(action->action->text())));
if (visible)
ChangeMenuAttributes(submenu, 0, kMenuAttrHidden);
else
ChangeMenuAttributes(submenu, kMenuAttrHidden, 0);
#else
[item setSubmenu: submenu];
[submenu setTitle:qt_mac_QStringToNSString(qt_mac_removeMnemonics(action->action->text()))];
syncNSMenuItemVisiblity(item, visible);
#endif
if (release_submenu) { //no pointers to it
#ifndef QT_MAC_USE_COCOA
ReleaseMenu(submenu);
#else
[submenu release];
#endif
}
} else {
qWarning("QMenu: No OSMenuRef created for popup menu");
}
}
void
QMenuBarPrivate::QMacMenuBarPrivate::removeAction(QMacMenuAction *action)
{
if (!action || !menu)
return;
#ifndef QT_MAC_USE_COCOA
DeleteMenuItem(action->menu, qt_mac_menu_find_action(action->menu, action));
#else
QMacCocoaAutoReleasePool pool;
[action->menu removeItem:action->menuItem];
#endif
actionItems.removeAll(action);
}
bool QMenuBarPrivate::macWidgetHasNativeMenubar(QWidget *widget)
{
// This function is different from q->isNativeMenuBar(), as
// it returns true only if a native menu bar is actually
// _created_.
if (!widget)
return false;
return menubars()->contains(widget->window());
}
void
QMenuBarPrivate::macCreateMenuBar(QWidget *parent)
{
Q_Q(QMenuBar);
static int dontUseNativeMenuBar = -1;
// We call the isNativeMenuBar function here
// because that will make sure that local overrides
// are dealt with correctly. q->isNativeMenuBar() will, if not
// overridden, depend on the attribute Qt::AA_DontUseNativeMenuBar:
bool qt_mac_no_native_menubar = !q->isNativeMenuBar();
if (qt_mac_no_native_menubar == false && dontUseNativeMenuBar < 0) {
// The menubar is set to be native. Let's check (one time only
// for all menubars) if this is OK with the rest of the environment.
// As a result, Qt::AA_DontUseNativeMenuBar is set. NB: the application
// might still choose to not respect, or change, this flag.
bool isPlugin = QApplication::testAttribute(Qt::AA_MacPluginApplication);
bool environmentSaysNo = !qgetenv("QT_MAC_NO_NATIVE_MENUBAR").isEmpty();
dontUseNativeMenuBar = isPlugin || environmentSaysNo;
QApplication::instance()->setAttribute(Qt::AA_DontUseNativeMenuBar, dontUseNativeMenuBar);
qt_mac_no_native_menubar = !q->isNativeMenuBar();
}
if (qt_mac_no_native_menubar == false) {
// INVARIANT: Use native menubar.
extern void qt_event_request_menubarupdate(); //qapplication_mac.cpp
qt_event_request_menubarupdate();
if (!parent && !fallback) {
fallback = q;
mac_menubar = new QMacMenuBarPrivate;
} else if (parent && parent->isWindow()) {
menubars()->insert(q->window(), q);
mac_menubar = new QMacMenuBarPrivate;
}
}
}
void QMenuBarPrivate::macDestroyMenuBar()
{
Q_Q(QMenuBar);
QMacCocoaAutoReleasePool pool;
if (fallback == q)
fallback = 0;
delete mac_menubar;
QWidget *tlw = q->window();
menubars()->remove(tlw);
mac_menubar = 0;
if (qt_mac_current_menubar.qmenubar == q) {
extern void qt_event_request_menubarupdate(); //qapplication_mac.cpp
qt_event_request_menubarupdate();
}
}
OSMenuRef QMenuBarPrivate::macMenu()
{
Q_Q(QMenuBar);
if (!q->isNativeMenuBar() || !mac_menubar) {
return 0;
} else if (!mac_menubar->menu) {
mac_menubar->menu = qt_mac_create_menu(q);
ProcessSerialNumber mine, front;
if (GetCurrentProcess(&mine) == noErr && GetFrontProcess(&front) == noErr) {
if (!qt_mac_no_menubar_merge && !mac_menubar->apple_menu) {
mac_menubar->apple_menu = qt_mac_create_menu(q);
#ifndef QT_MAC_USE_COCOA
MenuItemIndex index;
AppendMenuItemTextWithCFString(mac_menubar->menu, 0, 0, 0, &index);
SetMenuTitleWithCFString(mac_menubar->apple_menu, QCFString(QString(QChar(0x14))));
SetMenuItemHierarchicalMenu(mac_menubar->menu, index, mac_menubar->apple_menu);
SetMenuItemProperty(mac_menubar->apple_menu, 0, kMenuCreatorQt, kMenuPropertyQWidget, sizeof(q), &q);
#else
[mac_menubar->apple_menu setTitle:qt_mac_QStringToNSString(QString(QChar(0x14)))];
NSMenuItem *apple_menuItem = [[NSMenuItem alloc] init];
[apple_menuItem setSubmenu:mac_menubar->menu];
[mac_menubar->apple_menu addItem:apple_menuItem];
[apple_menuItem release];
#endif
}
if (mac_menubar->apple_menu) {
#ifndef QT_MAC_USE_COCOA
SetMenuItemProperty(mac_menubar->menu, 0, kMenuCreatorQt, kMenuPropertyMergeMenu,
sizeof(mac_menubar->apple_menu), &mac_menubar->apple_menu);
#else
QMenuPrivate::mergeMenuHash.insert(mac_menubar->menu, mac_menubar->apple_menu);
#endif
}
QList<QAction*> items = q->actions();
for(int i = 0; i < items.count(); i++)
mac_menubar->addAction(items[i]);
}
}
return mac_menubar->menu;
}
/*!
\internal
This function will return the OSMenuRef used to create the native menu bar
bindings. This OSMenuRef is then set as the root menu for the Menu
Manager.
\warning This function is not portable.
\sa QMenu::macMenu()
*/
OSMenuRef QMenuBar::macMenu() { return d_func()->macMenu(); }
/* !
\internal
Ancestor function that crosses windows (QWidget::isAncestorOf
only considers widgets within the same window).
*/
static bool qt_mac_is_ancestor(QWidget* possibleAncestor, QWidget *child)
{
if (!possibleAncestor)
return false;
QWidget * current = child->parentWidget();
while (current != 0) {
if (current == possibleAncestor)
return true;
current = current->parentWidget();
}
return false;
}
/* !
\internal
Returns true if the entries of menuBar should be disabled,
based on the modality type of modalWidget.
*/
static bool qt_mac_should_disable_menu(QMenuBar *menuBar, QWidget *modalWidget)
{
if (modalWidget == 0 || menuBar == 0)
return false;
// If there is an application modal window on
// screen, the entries of the menubar should be disabled:
QWidget *w = modalWidget;
while (w) {
if (w->isVisible() && w->windowModality() == Qt::ApplicationModal)
return true;
w = w->parentWidget();
}
// INVARIANT: modalWidget is window modal. Disable menu entries
// if the menu bar belongs to an ancestor of modalWidget:
return qt_mac_is_ancestor(menuBar->parentWidget(), modalWidget);
}
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];
}
}
#endif
}
/*!
\internal
This function will update the current menu bar and set it as the
active menu bar in the Menu Manager.
\warning This function is not portable.
\sa QMenu::macMenu(), QMenuBar::macMenu()
*/
bool QMenuBar::macUpdateMenuBar()
{
cancelAllMenuTracking();
QMenuBar *mb = 0;
//find a menu bar
QWidget *w = qApp->activeWindow();
if (!w) {
QWidgetList tlws = QApplication::topLevelWidgets();
for(int i = 0; i < tlws.size(); ++i) {
QWidget *tlw = tlws.at(i);
if ((tlw->isVisible() && tlw->windowType() != Qt::Tool &&
tlw->windowType() != Qt::Popup)) {
w = tlw;
break;
}
}
}
if (w) {
mb = menubars()->value(w);
#ifndef QT_NO_MAINWINDOW
QDockWidget *dw = qobject_cast<QDockWidget *>(w);
if (!mb && dw) {
QMainWindow *mw = qobject_cast<QMainWindow *>(dw->parentWidget());
if (mw && (mb = menubars()->value(mw)))
w = mw;
}
#endif
while(w && !mb)
mb = menubars()->value((w = w->parentWidget()));
}
if (!mb)
mb = fallback;
//now set it
bool ret = false;
if (mb && mb->isNativeMenuBar()) {
#ifdef QT_MAC_USE_COCOA
QMacCocoaAutoReleasePool pool;
#endif
if (OSMenuRef menu = mb->macMenu()) {
#ifndef QT_MAC_USE_COCOA
SetRootMenu(menu);
#else
QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
[loader ensureAppMenuInMenu:menu];
[NSApp setMainMenu:menu];
syncMenuBarItemsVisiblity(mb->d_func()->mac_menubar);
if (OSMenuRef tmpMerge = QMenuPrivate::mergeMenuHash.value(menu)) {
if (QMenuMergeList *mergeList
= QMenuPrivate::mergeMenuItemsHash.value(tmpMerge)) {
const int mergeListSize = mergeList->size();
for (int i = 0; i < mergeListSize; ++i) {
const QMenuMergeItem &mergeItem = mergeList->at(i);
// Ideally we would call QMenuPrivate::syncAction, but that requires finding
// the original QMen and likely doing more work than we need.
// For example, enabled is handled below.
[mergeItem.menuItem setTag:reinterpret_cast<long>(
static_cast<QAction *>(mergeItem.action->action))];
[mergeItem.menuItem setHidden:!(mergeItem.action->action->isVisible())];
}
}
}
#endif
QWidget *modalWidget = qApp->activeModalWidget();
if (mb != menubars()->value(modalWidget)) {
qt_mac_set_modal_state(menu, qt_mac_should_disable_menu(mb, modalWidget));
}
}
qt_mac_current_menubar.qmenubar = mb;
qt_mac_current_menubar.modal = QApplicationPrivate::modalState();
ret = true;
} else if (qt_mac_current_menubar.qmenubar && qt_mac_current_menubar.qmenubar->isNativeMenuBar()) {
const bool modal = QApplicationPrivate::modalState();
if (modal != qt_mac_current_menubar.modal) {
ret = true;
if (OSMenuRef menu = qt_mac_current_menubar.qmenubar->macMenu()) {
#ifndef QT_MAC_USE_COCOA
SetRootMenu(menu);
#else
QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
[loader ensureAppMenuInMenu:menu];
[NSApp setMainMenu:menu];
syncMenuBarItemsVisiblity(qt_mac_current_menubar.qmenubar->d_func()->mac_menubar);
#endif
QWidget *modalWidget = qApp->activeModalWidget();
if (qt_mac_current_menubar.qmenubar != menubars()->value(modalWidget)) {
qt_mac_set_modal_state(menu, qt_mac_should_disable_menu(mb, modalWidget));
}
}
qt_mac_current_menubar.modal = modal;
}
}
if(!ret)
qt_mac_clear_menubar();
return ret;
}
QHash<OSMenuRef, OSMenuRef> QMenuPrivate::mergeMenuHash;
QHash<OSMenuRef, QMenuMergeList*> QMenuPrivate::mergeMenuItemsHash;
bool QMenuPrivate::QMacMenuPrivate::merged(const QAction *action) const
{
#ifndef QT_MAC_USE_COCOA
MenuRef merge = 0;
GetMenuItemProperty(menu, 0, kMenuCreatorQt, kMenuPropertyMergeMenu,
sizeof(merge), 0, &merge);
if (merge) {
QMenuMergeList *list = 0;
if (GetMenuItemProperty(merge, 0, kMenuCreatorQt, kMenuPropertyMergeList,
sizeof(list), 0, &list) == noErr && list) {
for(int i = 0; i < list->size(); ++i) {
QMenuMergeItem item = list->at(i);
if (item.action->action == action)
return true;
}
}
}
#else
if (OSMenuRef merge = mergeMenuHash.value(menu)) {
if (QMenuMergeList *list = mergeMenuItemsHash.value(merge)) {
for(int i = 0; i < list->size(); ++i) {
const QMenuMergeItem &item = list->at(i);
if (item.action->action == action)
return true;
}
}
}
#endif
return false;
}
//creation of the OSMenuRef
static OSMenuRef qt_mac_create_menu(QWidget *w)
{
OSMenuRef ret;
#ifndef QT_MAC_USE_COCOA
ret = 0;
if (CreateNewMenu(0, 0, &ret) == noErr) {
qt_mac_create_menu_event_handler();
SetMenuItemProperty(ret, 0, kMenuCreatorQt, kMenuPropertyQWidget, sizeof(w), &w);
// kEventMenuMatchKey is only sent to the menu itself and not to
// the application, install a separate handler for that event.
EventHandlerRef eventHandlerRef;
InstallMenuEventHandler(ret, qt_mac_menu_event,
GetEventTypeCount(menu_menu_events),
menu_menu_events, 0, &eventHandlerRef);
menu_eventHandlers_hash()->insert(ret, eventHandlerRef);
} else {
qWarning("QMenu: Internal error");
}
#else
if (QMenu *qmenu = qobject_cast<QMenu *>(w)){
ret = [[QT_MANGLE_NAMESPACE(QCocoaMenu) alloc] initWithQMenu:qmenu];
} else {
ret = [[NSMenu alloc] init];
}
#endif
return ret;
}
QT_END_NAMESPACE