qmenu_mac.mm File Reference

#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>

Go to the source code of this file.

Typedefs
typedef QMultiHash< OSMenuRef, EventHandlerRef >	EventHandlerHash
typedef QHash< QWidget *, QMenuBar * >	MenuBarHash

Enumerations
enum	{   kMenuPropertyQAction = 'QAcT', kMenuPropertyQWidget = 'QWId', kMenuPropertyCausedQWidget = 'QCAU', kMenuPropertyMergeMenu = 'QApP',   kMenuPropertyMergeList = 'QAmL', kMenuPropertyWidgetActionWidget = 'QWid', kMenuPropertyWidgetMenu = 'QWMe', kHICommandAboutQt = 'AOQT',   kHICommandCustomMerge = 'AQt0' }

Functions
static bool	actualMenuItemVisibility (const QMenuBarPrivate::QMacMenuBarPrivate *mbp, const QMacMenuAction *action)
static void	cancelAllMenuTracking ()
static quint32	constructModifierMask (quint32 accel_key)
static QMenuBar *	findMenubarForWindow (QWidget *w)
static QWidget *	findWindowThatShouldDisplayMenubar ()
NSUInteger	keySequenceModifierMask (const QKeySequence &accel)
NSString *	keySequenceToKeyEqivalent (const QKeySequence &accel)
bool	qt_mac_activate_action (MenuRef menu, uint command, QAction::ActionEvent action_e, bool by_accel)
static bool	qt_mac_auto_apple_menu (MenuCommand cmd)
static void	qt_mac_cleanup_menu_event ()
void	qt_mac_clear_menubar ()
static void	qt_mac_command_set_enabled (MenuRef menu, UInt32 cmd, bool b)
static int	qt_mac_CountMenuItems (OSMenuRef menu)
IconRef	qt_mac_create_iconref (const QPixmap &px)
static OSMenuRef	qt_mac_create_menu (QWidget *w)
static void	qt_mac_create_menu_event_handler ()
void	qt_mac_dispose_rgn (RgnHandle r)
static void	qt_mac_get_accel (quint32 accel_key, quint32 *modif, quint32 *key)
RgnHandle	qt_mac_get_rgn ()
OSViewRef	qt_mac_hiview_for (const QWidget *w)
HIViewRef	qt_mac_hiview_for (OSWindowRef w)
static bool	qt_mac_is_ancestor (QWidget *possibleAncestor, QWidget *child)
OSStatus	qt_mac_menu_event (EventHandlerCallRef er, EventRef event, void *)
static int	qt_mac_menu_find_action (MenuRef menu, MenuCommand cmd)
static int	qt_mac_menu_find_action (MenuRef menu, QMacMenuAction *action)
static QKeySequence	qt_mac_menu_merge_accel (QMacMenuAction *action)
static MenuCommand	qt_mac_menu_merge_action (MenuRef merge, QMacMenuAction *action)
static QString	qt_mac_menu_merge_text (QMacMenuAction *action)
bool	qt_mac_menubar_is_open ()
void Q_GUI_EXPORT	qt_mac_set_menubar_icons (bool b)
void Q_GUI_EXPORT	qt_mac_set_menubar_merge (bool b)
static void	qt_mac_set_modal_state (OSMenuRef menu, bool on)
void	qt_mac_set_modal_state_helper_recursive (OSMenuRef menu, OSMenuRef merge, bool on)
void Q_GUI_EXPORT	qt_mac_set_native_menubar (bool b)
static bool	qt_mac_should_disable_menu (QMenuBar *menuBar)
bool	qt_mac_watchingAboutToShow (QMenu *menu)
static OSStatus	qt_mac_widget_in_menu_eventHandler (EventHandlerCallRef er, EventRef event, void *)
bool	qt_sendSpontaneousEvent (QObject *, QEvent *)

Variables
static QMenuBar *	fallback = 0
const UInt32	kMenuCreatorQt = 'cute'
QWidget *	mac_keyboard_grabber
static EventHandlerRef	mac_menu_event_handler = 0
static EventHandlerUPP	mac_menu_eventUPP = 0
static EventTypeSpec	menu_events []
static EventTypeSpec	menu_menu_events []
struct {
bool   modal
QPointer< QMenuBar >   qmenubar
}	qt_mac_current_menubar = { 0, false }
static uint	qt_mac_menu_static_cmd_id = 'QT00'
int	qt_mac_menus_open_count = 0
bool	qt_mac_no_menubar_merge = false
bool	qt_mac_quit_menu_item_enabled = true
static EventTypeSpec	widget_in_menu_events []

Typedef Documentation

EventHandlerHash

typedef QMultiHash<OSMenuRef, EventHandlerRef> EventHandlerHash

Definition at line 302 of file qmenu_mac.mm.

MenuBarHash

typedef QHash<QWidget *, QMenuBar *> MenuBarHash

Definition at line 1615 of file qmenu_mac.mm.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kMenuPropertyQAction
kMenuPropertyQWidget
kMenuPropertyCausedQWidget
kMenuPropertyMergeMenu
kMenuPropertyMergeList
kMenuPropertyWidgetActionWidget
kMenuPropertyWidgetMenu
kHICommandAboutQt
kHICommandCustomMerge

Definition at line 83 of file qmenu_mac.mm.

     {
    kMenuPropertyQAction = 'QAcT',
    kMenuPropertyQWidget = 'QWId',
    kMenuPropertyCausedQWidget = 'QCAU',
    kMenuPropertyMergeMenu = 'QApP',
    kMenuPropertyMergeList = 'QAmL',
    kMenuPropertyWidgetActionWidget = 'QWid',
    kMenuPropertyWidgetMenu = 'QWMe',

    kHICommandAboutQt = 'AOQT',
    kHICommandCustomMerge = 'AQt0'
};

Function Documentation

actualMenuItemVisibility()

static bool actualMenuItemVisibility ( const QMenuBarPrivate::QMacMenuBarPrivate *  mbp, const QMacMenuAction *  action  )

static

Definition at line 194 of file qmenu_mac.mm.

Referenced by qt_mac_get_accel(), and QMenuBarPrivate::QMacMenuBarPrivate::syncAction().

{
    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;
}

cancelAllMenuTracking()

static void cancelAllMenuTracking ( )

static

Definition at line 178 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::macDestroyMenuBar(), and QMenuBarPrivate::macUpdateMenuBarImmediatly().

{
#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
}

constructModifierMask()

static quint32 constructModifierMask ( quint32  accel_key )

static

Definition at line 145 of file qmenu_mac.mm.

Referenced by keySequenceModifierMask(), and qt_mac_get_accel().

{
    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;
}

findMenubarForWindow()

static QMenuBar* findMenubarForWindow ( QWidget *  w )

static

Definition at line 1989 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::macUpdateMenuBarImmediatly().

{
    QMenuBar *mb = 0;
    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) {
        // We could not find a menu bar for the window. Lets
        // check if we have a global (parentless) menu bar instead:
        mb = fallback;
    }

    return mb;
}

findWindowThatShouldDisplayMenubar()

static QWidget* findWindowThatShouldDisplayMenubar ( )

static

Definition at line 1970 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::macUpdateMenuBarImmediatly().

{
    QWidget *w = qApp->activeWindow();
    if (!w) {
        // We have no active window on screen. Try to
        // find a window from the list of top levels:
        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;
            }
        }
    }
    return w;
}

keySequenceModifierMask()

NSUInteger keySequenceModifierMask

(

const QKeySequence &

accel

)

Definition at line 1265 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::syncAction().

{
    return constructModifierMask(accel[0]);
}

keySequenceToKeyEqivalent()

NSString* keySequenceToKeyEqivalent

(

const QKeySequence &

accel

)

Definition at line 1254 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::syncAction().

{
    quint32 accel_key = (accel[0] & ~(Qt::MODIFIER_MASK | Qt::UNICODE_ACCEL));
    extern QChar qtKey2CocoaKey(Qt::Key key);
    QChar cocoa_key = qtKey2CocoaKey(Qt::Key(accel_key));
    if (cocoa_key.isNull())
        cocoa_key = QChar(accel_key).toLower().unicode();
    return [NSString stringWithCharacters:&cocoa_key.unicode() length:1];
}

qt_mac_activate_action()

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

Definition at line 209 of file qmenu_mac.mm.

Referenced by qt_mac_menu_event().

{
    //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 (action_e == QAction::Hover && 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)) {
                action->action->showStatusText(widget);
                emit qmenu->hovered(action->action);
            } else if (QMenuBar *qmenubar = qobject_cast<QMenuBar*>(widget)) {
                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;
}

qt_mac_auto_apple_menu()

static bool qt_mac_auto_apple_menu ( MenuCommand  cmd )

static

Definition at line 563 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction().

{
    return (cmd == kHICommandPreferences || cmd == kHICommandQuit);
}

qt_mac_cleanup_menu_event()

static void qt_mac_cleanup_menu_event ( )

static

Definition at line 523 of file qmenu_mac.mm.

Referenced by qt_mac_create_menu_event_handler().

{
    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;
    }
}

qt_mac_clear_menubar()

void qt_mac_clear_menubar

(

)

Definition at line 2015 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::macUpdateMenuBarImmediatly(), and QMenuBar::setNativeMenuBar().

{
    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];
    const bool modal = qt_mac_should_disable_menu(0);
    if (qt_mac_current_menubar.qmenubar || modal != qt_mac_current_menubar.modal)
        qt_mac_set_modal_state(menu, modal);
    qt_mac_current_menubar.qmenubar = 0;
    qt_mac_current_menubar.modal = modal;
#endif
}

qt_mac_command_set_enabled()

static void qt_mac_command_set_enabled ( MenuRef  menu, UInt32  cmd, bool  b  )

static

Definition at line 547 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction(), qt_mac_clear_menubar(), qt_mac_set_modal_state(), and QMenuPrivate::QMacMenuPrivate::removeAction().

{
    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);
    }
}

qt_mac_CountMenuItems()

static int qt_mac_CountMenuItems ( OSMenuRef  menu )

static

Definition at line 124 of file qmenu_mac.mm.

Referenced by actualMenuItemVisibility().

{
    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;
}

qt_mac_create_iconref()

IconRef qt_mac_create_iconref

(

const QPixmap &

px

)

Definition at line 1109 of file qpixmap_mac.cpp.

Referenced by QMenuPrivate::QMacMenuPrivate::syncAction().

{
    if (px.isNull())
        return 0;

    //create icon
    IconFamilyHandle iconFamily = reinterpret_cast<IconFamilyHandle>(NewHandle(0));
    //create data
    {
        struct {
            OSType mac_type;
            int width, height, depth;
            bool mask;
        } images[] = {
            { kThumbnail32BitData, 128, 128, 32, false },
            { kThumbnail8BitMask, 128, 128, 8, true },
            { 0, 0, 0, 0, false } //end marker
        };
        for(int i = 0; images[i].mac_type; i++) {
            //get QPixmap data
            QImage scaled_px = px.toImage().scaled(images[i].width, images[i].height);

            quint32 *sptr = (quint32 *) scaled_px.bits();
            quint32 *srow;
            uint sbpr = scaled_px.bytesPerLine();

            //get Handle data
            const int dbpr = images[i].width * (images[i].depth/8);
            Handle hdl = NewHandle(dbpr*images[i].height);
            if(!sptr) { //handle null pixmap
                memset((*hdl), '\0', dbpr*images[i].height);
            } else if(images[i].mask) {
                if(images[i].mac_type == kThumbnail8BitMask) {
                    for(int y = 0, hindex = 0; y < images[i].height; ++y) {
                        srow = sptr + (y * (sbpr/4));
                        for(int x = 0; x < images[i].width; ++x)
                            *((*hdl)+(hindex++)) = qAlpha(*(srow+x));
                    }
                }
            } else {
                char *dest = (*hdl);
#if defined(__i386__)
                if(images[i].depth == 32) {
                    for(int y = 0; y < images[i].height; ++y) {
                        uint *source = (uint*)((const uchar*)sptr+(sbpr*y));
                        for(int x = 0; x < images[i].width; ++x, dest += 4)
                            *((uint*)dest) = CFSwapInt32(*(source + x));
                    }
                } else
#endif
                {
                    for(int y = 0; y < images[i].height; ++y)
                        memcpy(dest+(y*dbpr), ((const uchar*)sptr+(sbpr*y)), dbpr);
                }
            }

            //set the family data to the Handle
            OSStatus set = SetIconFamilyData(iconFamily, images[i].mac_type, hdl);
            if(set != noErr)
                qWarning("%s: %d -- Unable to create icon data[%d]!! %ld",
                         __FILE__, __LINE__, i, long(set));
            DisposeHandle(hdl);
        }
    }

    //acquire and cleanup
    IconRef ret;
    static int counter = 0;
    const OSType kQtCreator = 'CUTE';
    RegisterIconRefFromIconFamily(kQtCreator, (OSType)counter, iconFamily, &ret);
    AcquireIconRef(ret);
    UnregisterIconRef(kQtCreator, (OSType)counter);
    DisposeHandle(reinterpret_cast<Handle>(iconFamily));
    counter++;
    return ret;

}

qt_mac_create_menu()

static OSMenuRef qt_mac_create_menu ( QWidget *  w )

static

Definition at line 2193 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::macMenu(), and QMenuPrivate::macMenu().

{
    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_mac_create_menu_event_handler()

static void qt_mac_create_menu_event_handler ( )

inlinestatic

Definition at line 534 of file qmenu_mac.mm.

Referenced by qt_mac_create_menu().

{
    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);
    }
}

qt_mac_dispose_rgn()

void qt_mac_dispose_rgn

(

RgnHandle

r

)

Referenced by qt_mac_widget_in_menu_eventHandler().

qt_mac_get_accel()

static void qt_mac_get_accel ( quint32  accel_key, quint32 *  modif, quint32 *  key  )

static

Definition at line 568 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::syncAction().

                                                                              {
    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;
    }
}

qt_mac_get_rgn()

RgnHandle qt_mac_get_rgn

(

)

Referenced by qt_mac_widget_in_menu_eventHandler().

qt_mac_hiview_for() [1/2]

OSViewRef qt_mac_hiview_for

(

const QWidget *

w

)

qt_mac_hiview_for() [2/2]

HIViewRef qt_mac_hiview_for

(

OSWindowRef

w

)

qt_mac_is_ancestor()

static bool qt_mac_is_ancestor ( QWidget *  possibleAncestor, QWidget *  child  )

static

Definition at line 1910 of file qmenu_mac.mm.

Referenced by qt_mac_should_disable_menu().

{
    if (!possibleAncestor)
        return false;

    QWidget * current = child->parentWidget();
    while (current != 0) {
        if (current == possibleAncestor)
            return true;
        current = current->parentWidget();
    }
    return false;
}

qt_mac_menu_event()

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

Definition at line 397 of file qmenu_mac.mm.

Referenced by qt_mac_create_menu(), and qt_mac_create_menu_event_handler().

{
    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
}

qt_mac_menu_find_action() [1/2]

static int qt_mac_menu_find_action ( MenuRef  menu, MenuCommand  cmd  )

static

Definition at line 287 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction(), qt_mac_menu_event(), qt_mac_menu_find_action(), QMenuBarPrivate::QMacMenuBarPrivate::removeAction(), QMenuPrivate::QMacMenuPrivate::removeAction(), QMenuBarPrivate::QMacMenuBarPrivate::syncAction(), and QMenuPrivate::QMacMenuPrivate::syncAction().

{
    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;
}

qt_mac_menu_find_action() [2/2]

static int qt_mac_menu_find_action ( MenuRef  menu, QMacMenuAction *  action  )

static

Definition at line 297 of file qmenu_mac.mm.

{
    return qt_mac_menu_find_action(menu, action->command);
}

qt_mac_menu_merge_accel()

static QKeySequence qt_mac_menu_merge_accel ( QMacMenuAction *  action )

static

Definition at line 955 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::syncAction().

{
    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;
}

qt_mac_menu_merge_action()

static MenuCommand qt_mac_menu_merge_action ( MenuRef  merge, QMacMenuAction *  action  )

static

Definition at line 779 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction().

{
    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;
}

qt_mac_menu_merge_text()

static QString qt_mac_menu_merge_text ( QMacMenuAction *  action )

static

Definition at line 920 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::syncAction().

{
    QString ret;
    extern QString qt_mac_applicationmenu_string(int type);
#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 = qt_mac_applicationmenu_string(6).arg(qAppName());
    else if (action->command == kHICommandAboutQt)
        ret = QMenuBar::tr("About Qt");
    else if (action->command == kHICommandPreferences)
        ret = qt_mac_applicationmenu_string(4);
    else if (action->command == kHICommandQuit)
        ret = qt_mac_applicationmenu_string(5).arg(qAppName());
#else
    else if (action->menuItem == [loader aboutMenuItem]) {
        ret = qt_mac_applicationmenu_string(6).arg(qAppName());
    } else if (action->menuItem == [loader aboutQtMenuItem]) {
        if (action->action->text() == QString("About Qt"))
            ret = QMenuBar::tr("About Qt");
        else
            ret = action->action->text();
    } else if (action->menuItem == [loader preferencesMenuItem]) {
        ret = qt_mac_applicationmenu_string(4);
    } else if (action->menuItem == [loader quitMenuItem]) {
        ret = qt_mac_applicationmenu_string(5).arg(qAppName());
    }
#endif
    return ret;
}

qt_mac_menubar_is_open()

bool qt_mac_menubar_is_open

(

)

Definition at line 750 of file qmenu_mac.mm.

Referenced by QKeyMapperPrivate::translateKeyEvent().

{
    return qt_mac_menus_open_count > 0;
}

qt_mac_set_menubar_icons()

void Q_GUI_EXPORT qt_mac_set_menubar_icons

(

bool

b

)

Definition at line 977 of file qmenu_mac.mm.

{ QApplication::instance()->setAttribute(Qt::AA_DontShowIconsInMenus, !b); }

qt_mac_set_menubar_merge()

void Q_GUI_EXPORT qt_mac_set_menubar_merge

(

bool

b

)

Definition at line 981 of file qmenu_mac.mm.

{ qt_mac_no_menubar_merge = !b; }

qt_mac_set_modal_state()

static void qt_mac_set_modal_state ( OSMenuRef  menu, bool  on  )

static

Definition at line 701 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::macUpdateMenuBarImmediatly(), and qt_mac_clear_menubar().

{
#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
}

qt_mac_set_modal_state_helper_recursive()

void qt_mac_set_modal_state_helper_recursive	(	OSMenuRef	menu,
		OSMenuRef	merge,
		bool	on
	)

Definition at line 652 of file qmenu_mac.mm.

Referenced by qt_mac_set_modal_state().

{
#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
    bool modalWindowOnScreen = qApp->activeModalWidget() != 0;
    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);
                }
                // We sneak in some extra code here to handle a menu problem:
                // If there is no window on screen, we cannot set 'nil' as
                // menu item target, because then cocoa will disable the item
                // (guess it assumes that there will be no first responder to
                // catch the trigger anyway?) OTOH, If we have a modal window,
                // then setting the menu loader as target will make cocoa not
                // deliver the trigger because the loader is then seen as modally
                // shaddowed). So either way there are shortcomings. Instead, we
                // decide the target as late as possible:
                [item setTarget:modalWindowOnScreen ? nil : getMenuLoader()];
            } else {
                syncNSMenuItemEnabled(item, NO);
            }
        }
    }
#endif
}

qt_mac_set_native_menubar()

void Q_GUI_EXPORT qt_mac_set_native_menubar

(

bool

b

)

Definition at line 979 of file qmenu_mac.mm.

{  QApplication::instance()->setAttribute(Qt::AA_DontUseNativeMenuBar, !b); }

qt_mac_should_disable_menu()

static bool qt_mac_should_disable_menu ( QMenuBar *  menuBar )

static

Definition at line 1929 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::macUpdateMenuBarImmediatly(), and qt_mac_clear_menubar().

{
    QWidget *modalWidget = qApp->activeModalWidget();
    if (!modalWidget)
        return false;

    if (menuBar && menuBar == menubars()->value(modalWidget))
        // The menu bar is owned by the modal widget.
        // In that case we should enable it:
        return false;

    // When there is an application modal window on screen, the entries of
    // the menubar should be disabled. The exception in Qt is that if the
    // modal window is the only window on screen, then we enable the menu bar.
    QWidget *w = modalWidget;
    QWidgetList topLevelWidgets = QApplication::topLevelWidgets();
    while (w) {
        if (w->isVisible() && w->windowModality() == Qt::ApplicationModal) {
            for (int i=0; i<topLevelWidgets.size(); ++i) {
                QWidget *top = topLevelWidgets.at(i);
                if (w != top && top->isVisible()) {
                    // INVARIANT: we found another visible window
                    // on screen other than our modalWidget. We therefore
                    // disable the menu bar to follow normal modality logic:
                    return true;
                }
            }
            // INVARIANT: We have only one window on screen that happends
            // to be application modal. We choose to enable the menu bar
            // in that case to e.g. enable the quit menu item.
            return false;
        }
        w = w->parentWidget();
    }

    // INVARIANT: modalWidget is window modal. Disable menu entries
    // if the menu bar belongs to an ancestor of modalWidget. If menuBar
    // is nil, we understand it as the default menu bar set by the nib:
    return menuBar ? qt_mac_is_ancestor(menuBar->parentWidget(), modalWidget) : false;
}

qt_mac_watchingAboutToShow()

bool qt_mac_watchingAboutToShow

(

QMenu *

menu

)

Definition at line 119 of file qmenu_mac.mm.

Referenced by actualMenuItemVisibility().

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

qt_mac_widget_in_menu_eventHandler()

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

static

Definition at line 312 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction().

{
    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;
}

qt_sendSpontaneousEvent()

bool qt_sendSpontaneousEvent	(	QObject *	,
		QEvent *
	)

Definition at line 5779 of file qapplication.cpp.

Referenced by qt_mac_menu_event().

{
    return QCoreApplication::sendSpontaneousEvent(receiver, event);
}

Variable Documentation

fallback

QMenuBar* fallback = 0

static

Definition at line 1617 of file qmenu_mac.mm.

Referenced by QStyleSheetStyle::drawControl(), findMenubarForWindow(), getFcPattern(), QGtkStylePrivate::getGConfBool(), QGtkStylePrivate::getGConfString(), QGtkStylePrivate::isThemeAvailable(), QMenuBarPrivate::macCreateMenuBar(), QMenuBarPrivate::macDestroyMenuBar(), and QIcon::paint().

kMenuCreatorQt

const UInt32 kMenuCreatorQt = 'cute'

Definition at line 82 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::QMacMenuBarPrivate::addAction(), QMenuPrivate::QMacMenuPrivate::addAction(), QMenuBarPrivate::macMenu(), QMenuPrivate::macMenu(), QMenuPrivate::QMacMenuPrivate::merged(), qt_mac_activate_action(), qt_mac_create_menu(), qt_mac_menu_event(), qt_mac_menu_merge_action(), qt_mac_set_modal_state(), qt_mac_widget_in_menu_eventHandler(), QMenuBarPrivate::QMacMenuBarPrivate::syncAction(), QMenuPrivate::QMacMenuPrivate::syncAction(), QMenuBarPrivate::QMacMenuBarPrivate::~QMacMenuBarPrivate(), and QMenuPrivate::QMacMenuPrivate::~QMacMenuPrivate().

mac_keyboard_grabber

QWidget* mac_keyboard_grabber

Definition at line 157 of file qwidget_mac.mm.

Referenced by QWidget::keyboardGrabber().

mac_menu_event_handler

EventHandlerRef mac_menu_event_handler = 0

static

Definition at line 521 of file qmenu_mac.mm.

Referenced by qt_mac_cleanup_menu_event(), and qt_mac_create_menu_event_handler().

mac_menu_eventUPP

EventHandlerUPP mac_menu_eventUPP = 0

static

Definition at line 522 of file qmenu_mac.mm.

Referenced by qt_mac_cleanup_menu_event(), and qt_mac_create_menu_event_handler().

menu_events

EventTypeSpec menu_events[]

static

Initial value:

= {
    { kEventClassCommand, kEventCommandProcess },
    { kEventClassMenu, kEventMenuTargetItem },
    { kEventClassMenu, kEventMenuOpening },
    { kEventClassMenu, kEventMenuClosed }
}

Definition at line 385 of file qmenu_mac.mm.

Referenced by qt_mac_create_menu_event_handler().

menu_menu_events

EventTypeSpec menu_menu_events[]

static

Initial value:

= {
    { kEventClassMenu, kEventMenuMatchKey }
}

Definition at line 393 of file qmenu_mac.mm.

Referenced by qt_mac_create_menu().

modal

bool modal

Definition at line 99 of file qmenu_mac.mm.

Referenced by QMessageBox::critical(), QMenuBarPrivate::macUpdateMenuBarImmediatly(), qt_mac_clear_menubar(), qt_mac_mouse_inside_answer_rect(), QWidgetPrivate::setModal_sys(), QSoftKeyManager::softkeySource(), and QAxClientSite::windowActivationChange().

qmenubar

QPointer<QMenuBar> qmenubar

Definition at line 98 of file qmenu_mac.mm.

Referenced by QMenuPrivate::activateCausedStack(), and qt_mac_activate_action().

qt_mac_current_menubar

struct { ... } qt_mac_current_menubar

Referenced by QMenuBarPrivate::macDestroyMenuBar(), QMenuBarPrivate::macUpdateMenuBarImmediatly(), qt_mac_activate_action(), and qt_mac_clear_menubar().

qt_mac_menu_static_cmd_id

uint qt_mac_menu_static_cmd_id = 'QT00'

static

Definition at line 81 of file qmenu_mac.mm.

Referenced by QMenuBarPrivate::QMacMenuBarPrivate::addAction(), and QMenuPrivate::QMacMenuPrivate::addAction().

qt_mac_menus_open_count

int qt_mac_menus_open_count = 0

Definition at line 76 of file qmenu_mac.mm.

Referenced by qt_mac_menu_event(), and qt_mac_menubar_is_open().

qt_mac_no_menubar_merge

bool qt_mac_no_menubar_merge = false

Definition at line 74 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction(), QMenuBarPrivate::macMenu(), qt_mac_menu_merge_action(), and qt_mac_set_menubar_merge().

qt_mac_quit_menu_item_enabled

bool qt_mac_quit_menu_item_enabled = true

Definition at line 75 of file qmenu_mac.mm.

Referenced by QApplicationPrivate::globalAppleEventProcessor(), and qt_mac_command_set_enabled().

widget_in_menu_events

EventTypeSpec widget_in_menu_events[]

static

Initial value:

= {
    { kEventClassMenu, kEventMenuMeasureItemWidth },
    { kEventClassMenu, kEventMenuMeasureItemHeight },
    { kEventClassMenu, kEventMenuDrawItem },
    { kEventClassMenu, kEventMenuCalculateSize }
}

Definition at line 305 of file qmenu_mac.mm.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction().