Changeset 561 for trunk/src/gui/widgets/qmenu.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/widgets/qmenu.cpp (modified) (88 diffs)

trunk/src/gui/widgets/qmenu.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** 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.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -66 +66 @@
 #include "qwidgetaction.h"
 #include "qtoolbutton.h"
+#include "qpushbutton.h"
+#include <private/qpushbutton_p.h>
 #include <private/qaction_p.h>
+#include <private/qsoftkeymanager_p.h>
 #ifdef QT3_SUPPORT
 #include <qmenudata.h>
@@ -151 +154 @@
 {
     Q_Q(QMenu);
-    activationRecursionGuard = false;
 #ifndef QT_NO_WHATSTHIS
     q->setAttribute(Qt::WA_CustomWhatsThis);
@@ -163 +165 @@
         scroll->scrollFlags = QMenuPrivate::QMenuScroller::ScrollNone;
     }
+
+#ifdef QT_SOFTKEYS_ENABLED
+    selectAction = QSoftKeyManager::createKeyedAction(QSoftKeyManager::SelectSoftKey, Qt::Key_Select, q);
+    cancelAction = QSoftKeyManager::createKeyedAction(QSoftKeyManager::CancelSoftKey, Qt::Key_Back, q);
+    selectAction->setVisible(false); // Don't show these in the menu
+    cancelAction->setVisible(false);
+    q->addAction(selectAction);
+    q->addAction(cancelAction);
+#endif
+}
+
+int QMenuPrivate::scrollerHeight() const
+{
+    Q_Q(const QMenu);
+    return qMax(QApplication::globalStrut().height(), q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q));
+}
+
+// Windows, OS/2 and KDE allows menus to cover the taskbar, while GNOME and Mac don't
+QRect QMenuPrivate::popupGeometry(const QWidget *widget) const
+{
+#if defined(Q_WS_WIN) || defined(Q_WS_PM)
+    return QApplication::desktop()->screenGeometry(widget);
+#elif defined Q_WS_X11
+    if (X11->desktopEnvironment == DE_KDE)
+        return QApplication::desktop()->screenGeometry(widget);
+    else
+        return QApplication::desktop()->availableGeometry(widget);
+#else
+        return QApplication::desktop()->availableGeometry(widget);
+#endif
 }
 
@@ -195 +227 @@
 }
 
-void QMenuPrivate::calcActionRects(QMap<QAction*, QRect> &actionRects, QList<QAction*> &actionList) const
+void QMenuPrivate::updateActionRects() const
 {
     Q_Q(const QMenu);
-    if (!itemsDirty) {
-        actionRects = this->actionRects;
-        actionList = this->actionList;
+    if (!itemsDirty)
         return;
-    }
-
-    actionRects.clear();
-    actionList.clear();
-    QList<QAction*> items = filterActions(q->actions());
+
+    q->ensurePolished();
+
+    //let's reinitialize the buffer
+    actionRects.resize(actions.count());
+    actionRects.fill(QRect());
+
+    //let's try to get the last visible action
+    int lastVisibleAction = actions.count() - 1;
+    for(;lastVisibleAction >= 0; --lastVisibleAction) {
+        const QAction *action = actions.at(lastVisibleAction);
+        if (action->isVisible()) {
+            //removing trailing separators
+            if (action->isSeparator() && collapsibleSeparators)
+                continue;
+            break;
+        }
+    }
+
     int max_column_width = 0,
-        dh = popupGeometry(QApplication::desktop()->screenNumber(q)).height(),
-        ncols = 1,
+        dh = popupGeometry(q).height(),
         y = 0;
-    const int hmargin = q->style()->pixelMetric(QStyle::PM_MenuHMargin, 0, q),
-              vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q),
-              icone = q->style()->pixelMetric(QStyle::PM_SmallIconSize, 0, q);
+    QStyle *style = q->style();
+    QStyleOption opt;
+    opt.init(q);
+    const int hmargin = style->pixelMetric(QStyle::PM_MenuHMargin, &opt, q),
+              vmargin = style->pixelMetric(QStyle::PM_MenuVMargin, &opt, q),
+              icone = style->pixelMetric(QStyle::PM_SmallIconSize, &opt, q);
+    const int fw = style->pixelMetric(QStyle::PM_MenuPanelWidth, &opt, q);
+    const int deskFw = style->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, &opt, q);
+
+    const int sfcMargin = style->sizeFromContents(QStyle::CT_Menu, &opt, QApplication::globalStrut(), q).width() - QApplication::globalStrut().width();
+    const int min_column_width = q->minimumWidth() - (sfcMargin + leftmargin + rightmargin + 2 * (fw + hmargin));
+    const int tearoffHeight = tearoff ? style->pixelMetric(QStyle::PM_MenuTearoffHeight, &opt, q) : 0;
 
     //for compatability now - will have to refactor this away..
@@ -219 +271 @@
     maxIconWidth = 0;
     hasCheckableItems = false;
-    for(int i = 0; i < items.count(); i++) {
-        QAction *action = items.at(i);
-        if (widgetItems.value(action))
+    ncols = 1;
+    sloppyAction = 0;
+
+    for (int i = 0; i < actions.count(); ++i) {
+        QAction *action = actions.at(i);
+        if (action->isSeparator() || !action->isVisible() || widgetItems.contains(action))
             continue;
+        //..and some members
         hasCheckableItems |= action->isCheckable();
         QIcon is = action->icon();
         if (!is.isNull()) {
-            uint miw = maxIconWidth;
-            maxIconWidth = qMax<uint>(miw, icone + 4);
+            maxIconWidth = qMax<uint>(maxIconWidth, icone + 4);
         }
     }
@@ -233 +288 @@
     //calculate size
     QFontMetrics qfm = q->fontMetrics();
-    for(int i = 0; i < items.count(); i++) {
-        QAction *action = items.at(i);
-
-        QFontMetrics fm(action->font().resolve(q->font()));
-        QSize sz;
+    bool previousWasSeparator = true; // this is true to allow removing the leading separators
+    for(int i = 0; i <= lastVisibleAction; i++) {
+        QAction *action = actions.at(i);
+
+        if (!action->isVisible() ||
+            (collapsibleSeparators && previousWasSeparator && action->isSeparator()))
+            continue; // we continue, this action will get an empty QRect
+
+        previousWasSeparator = action->isSeparator();
 
         //let the style modify the above size..
         QStyleOptionMenuItem opt;
         q->initStyleOption(&opt, action);
-        opt.rect = q->rect();
-
+        const QFontMetrics &fm = opt.fontMetrics;
+
+        QSize sz;
         if (QWidget *w = widgetItems.value(action)) {
-          sz=w->sizeHint().expandedTo(w->minimumSize()).expandedTo(w->minimumSizeHint()).boundedTo(w->maximumSize());
+          sz = w->sizeHint().expandedTo(w->minimumSize()).expandedTo(w->minimumSizeHint()).boundedTo(w->maximumSize());
         } else {
             //calc what I think the size is..
@@ -263 +323 @@
     #endif
                 }
-                int w = fm.boundingRect(QRect(), Qt::TextSingleLine, s).width();
-                w -= s.count(QLatin1Char('&')) * fm.width(QLatin1Char('&'));
-                w += s.count(QLatin1String("&&")) * fm.width(QLatin1Char('&'));
-                sz.setWidth(w);
+                sz.setWidth(fm.boundingRect(QRect(), Qt::TextSingleLine | Qt::TextShowMnemonic, s).width());
                 sz.setHeight(qMax(fm.height(), qfm.height()));
 
@@ -276 +333 @@
                 }
             }
-          sz = q->style()->sizeFromContents(QStyle::CT_MenuItem, &opt, sz, q);
+            sz = style->sizeFromContents(QStyle::CT_MenuItem, &opt, sz, q);
         }
 
 
         if (!sz.isEmpty()) {
-            max_column_width = qMax(max_column_width, sz.width());
+            max_column_width = qMax(min_column_width, qMax(max_column_width, sz.width()));
             //wrapping
             if (!scroll &&
-               y+sz.height()+vmargin > dh - (q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q) * 2)) {
+               y+sz.height()+vmargin > dh - (deskFw * 2)) {
                 ncols++;
                 y = vmargin;
             }
             y += sz.height();
-            //append item
-            actionRects.insert(action, QRect(0, 0, sz.width(), sz.height()));
-            actionList.append(action);
-        }
-    }
-
-    if (tabWidth)
-        max_column_width += tabWidth; //finally add in the tab width
+            //update the item
+            actionRects[i] = QRect(0, 0, sz.width(), sz.height());
+        }
+    }
+
+    max_column_width += tabWidth; //finally add in the tab width
 
     //calculate position
-    int x = hmargin;
-    y = vmargin;
-
-    for(int i = 0; i < actionList.count(); i++) {
-        QAction *action = actionList.at(i);
-        QRect &rect = actionRects[action];
+    const int base_y = vmargin + fw + topmargin +
+        (scroll ? scroll->scrollOffset : 0) +
+        tearoffHeight;
+    int x = hmargin + fw + leftmargin;
+    y = base_y;
+
+    for(int i = 0; i < actions.count(); i++) {
+        QRect &rect = actionRects[i];
         if (rect.isNull())
             continue;
         if (!scroll &&
-           y+rect.height() > dh - (q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q) * 2)) {
-            ncols--;
-            if (ncols < 0)
-                qWarning("QMenu: Column calculation mismatch (%d)", ncols);
+           y+rect.height() > dh - deskFw * 2) {
             x += max_column_width + hmargin;
-            y = vmargin;
+            y = base_y;
         }
         rect.translate(x, y);                        //move
         rect.setWidth(max_column_width); //uniform width
+
+        //we need to update the widgets geometry
+        if (QWidget *widget = widgetItems.value(actions.at(i))) {
+            widget->setGeometry(rect);
+            widget->setVisible(actions.at(i)->isVisible());
+        }
+
         y += rect.height();
     }
-}
-
-void QMenuPrivate::updateActions()
-{
-    Q_Q(const QMenu);
-    if (!itemsDirty)
-        return;
-    sloppyAction = 0;
-    calcActionRects(actionRects, actionList);
-    for (QHash<QAction *, QWidget *>::ConstIterator item = widgetItems.constBegin(),
-         end = widgetItems.constEnd(); item != end; ++item) {
-        QAction *action = item.key();
-        QWidget *widget = item.value();
-        widget->setGeometry(actionRect(action));
-        widget->setVisible(action->isVisible());
-    }
-    ncols = 1;
-    int last_left = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q);
-    if (!scroll) {
-        for(int i = 0; i < actionList.count(); i++) {
-            int left = actionRects.value(actionList.at(i)).left();
-            if (left > last_left) {
-                last_left = left;
-                ncols++;
-            }
-        }
-    }
     itemsDirty = 0;
 }
 
-QList<QAction *> QMenuPrivate::filterActions(const QList<QAction *> &actions) const
-{
-    QList<QAction *> visibleActions;
-    int i = 0;
-    while (i < actions.count()) {
-        QAction *action = actions.at(i);
-        if (!action->isVisible()) {
-            ++i;
-            continue;
-        }
-        if (!action->isSeparator() || !collapsibleSeparators) {
-            visibleActions.append(action);
-            ++i;
-            continue;
-        }
-
-        // no leading separators
-        if (!visibleActions.isEmpty())
-            visibleActions.append(action);
-
-        // skip double/tripple/etc. separators
-        while (i < actions.count()
-               && (!actions.at(i)->isVisible() || actions.at(i)->isSeparator()))
-            ++i;
-    }
-
-    if (collapsibleSeparators) {
-        // remove trailing separators
-        while (!visibleActions.isEmpty() && visibleActions.last()->isSeparator())
-            visibleActions.removeLast();
-    }
-
-    return visibleActions;
-}
-
 QRect QMenuPrivate::actionRect(QAction *act) const
 {
-    Q_Q(const QMenu);
-    QRect ret = actionRects.value(act);
-    if (ret.isNull())
-        return ret;
-    if (scroll)
-        ret.translate(0, scroll->scrollOffset);
-    if (tearoff)
-        ret.translate(0, q->style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, q));
-    const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q);
-    ret.translate(fw+leftmargin, fw+topmargin);
-    return ret;
-}
+    int index = actions.indexOf(act);
+    if (index == -1)
+        return QRect();
+
+    updateActionRects();
+
+    //we found the action
+    return actionRects.at(index);
+}
+
+#if defined(Q_WS_MAC)
+static const qreal MenuFadeTimeInSec = 0.150;
+#endif
 
 void QMenuPrivate::hideUpToMenuBar()
 {
     Q_Q(QMenu);
+    bool fadeMenus = q->style()->styleHint(QStyle::SH_Menu_FadeOutOnHide);
     if (!tornoff) {
         QWidget *caused = causedPopup.widget;
@@ -416 +417 @@
                 caused = m->d_func()->causedPopup.widget;
                 if (!m->d_func()->tornoff)
-                    hideMenu(m);
-                m->d_func()->setCurrentAction(0);
-            } else {
-#ifndef QT_NO_TOOLBUTTON
-                if (qobject_cast<QToolButton*>(caused) == 0)
-#endif
-                    qWarning("QMenu: Internal error");
-                caused = 0;
+                    hideMenu(m, fadeMenus);
+                if (!fadeMenus) // Mac doesn't clear the action until after hidden.
+                    m->d_func()->setCurrentAction(0);
+            } else {                caused = 0;
             }
         }
+#if defined(Q_WS_MAC)
+        if (fadeMenus) {
+            QEventLoop eventLoop;
+            QTimer::singleShot(int(MenuFadeTimeInSec * 1000), &eventLoop, SLOT(quit()));
+            QMacWindowFader::currentFader()->performFade();
+            eventLoop.exec();
+        }
+#endif
     }
     setCurrentAction(0);
 }
 
-void QMenuPrivate::hideMenu(QMenu *menu)
+void QMenuPrivate::hideMenu(QMenu *menu, bool justRegister)
 {
     if (!menu)
         return;
-
 #if !defined(QT_NO_EFFECTS)
     menu->blockSignals(true);
@@ -440 +444 @@
     // Flash item which is about to trigger (if any).
     if (menu->style()->styleHint(QStyle::SH_Menu_FlashTriggeredItem)
-        && currentAction && currentAction == actionAboutToTrigger) {
-
+        && currentAction && currentAction == actionAboutToTrigger
+        && menu->actions().contains(currentAction)) {
         QEventLoop eventLoop;
         QAction *activeAction = currentAction;
 
-        // Deselect and wait 60 ms.
         menu->setActiveAction(0);
         QTimer::singleShot(60, &eventLoop, SLOT(quit()));
@@ -459 +462 @@
     if (menu->style()->styleHint(QStyle::SH_Menu_FadeOutOnHide)) {
         // ### Qt 4.4:
-        // Should be something like: q->transitionWindow(Qt::FadeOutTransition, 150);
+        // Should be something like: q->transitionWindow(Qt::FadeOutTransition, MenuFadeTimeInSec);
         // Hopefully we'll integrate qt/research/windowtransitions into main before 4.4.
         // Talk to Richard, Trenton or Bjoern.
 #if defined(Q_WS_MAC)
-                macWindowFade(qt_mac_window_for(menu));         // FIXME - what is the default duration for view animations
-
-        // Wait for the transition to complete.
-                QEventLoop eventLoop;
-        QTimer::singleShot(150, &eventLoop, SLOT(quit()));
-        eventLoop.exec();
+        if (justRegister) {
+            QMacWindowFader::currentFader()->setFadeDuration(MenuFadeTimeInSec);
+            QMacWindowFader::currentFader()->registerWindowToFade(menu);
+        } else {
+            macWindowFade(qt_mac_window_for(menu), MenuFadeTimeInSec);
+        }
+
 #endif // Q_WS_MAC
     }
@@ -474 +478 @@
     menu->blockSignals(false);
 #endif // QT_NO_EFFECTS
-    menu->hide();
+    if (!justRegister)
+        menu->hide();
 }
 
@@ -514 +519 @@
 {
     Q_Q(QMenu);
-    const int scrollerHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q);
-    for(int i = 0, saccum = 0; i < actionList.count(); i++) {
-        QAction *act = actionList[i];
+    updateActionRects();
+    for(int i = 0, saccum = 0; i < actions.count(); i++) {
+        const QRect &rect = actionRects.at(i);
+        if (rect.isNull())
+            continue;
         if (scroll && scroll->scrollFlags & QMenuScroller::ScrollUp) {
-            saccum -= actionRects.value(act).height();
-            if (saccum > scroll->scrollOffset-scrollerHeight)
+            saccum -= rect.height();
+            if (saccum > scroll->scrollOffset - scrollerHeight())
                 continue;
         }
+        QAction *act = actions.at(i);
         if (!act->isSeparator() &&
            (q->style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, q)
@@ -536 +544 @@
     Q_Q(QMenu);
     tearoffHighlighted = 0;
-    if (action == currentAction && !(action && action->menu() && action->menu() != activeMenu)) {
-        if(QMenu *menu = qobject_cast<QMenu*>(causedPopup.widget)) {
-            if(causedPopup.action && menu->d_func()->activeMenu == q)
-                menu->d_func()->setCurrentAction(causedPopup.action, 0, reason, false);
+    if (action == currentAction) {
+        if (!action || !action->menu() || action->menu() == activeMenu) {
+            if(QMenu *menu = qobject_cast<QMenu*>(causedPopup.widget)) {
+                if(causedPopup.action && menu->d_func()->activeMenu == q)
+                    menu->d_func()->setCurrentAction(causedPopup.action, 0, reason, false);
+            }
         }
         return;
@@ -554 +564 @@
 #endif
 #ifdef QT3_SUPPORT
-    emitHighlighted = (action && action != currentAction);
+    emitHighlighted = action;
 #endif
     currentAction = action;
@@ -569 +579 @@
             }
             q->update(actionRect(action));
-            QWidget *widget = widgetItems.value(action);
 
             if (reason == SelectedFromKeyboard) {
+                QWidget *widget = widgetItems.value(action);
                 if (widget) {
                     if (widget->focusPolicy() != Qt::NoFocus)
@@ -579 +589 @@
                     // get the focus
                     // Since the menu is a pop-up, it uses the popup reason.
-                    if (!q->hasFocus())
+                    if (!q->hasFocus()) {
                         q->setFocus(Qt::PopupFocusReason);
+                    }
                 }
             }
@@ -589 +600 @@
 #ifndef QT_NO_STATUSTIP
     }  else if (previousAction) {
-        QWidget *w = causedPopup.widget;
-        while (QMenu *m = qobject_cast<QMenu*>(w))
-            w = m->d_func()->causedPopup.widget;
-        if (w) {
-            QString empty;
-            QStatusTipEvent tip(empty);
-            QApplication::sendEvent(w, &tip);
-        }
+        previousAction->d_func()->showStatusText(topCausedWidget(), QString());
 #endif
     }
@@ -610 +614 @@
 }
 
+//return the top causedPopup.widget that is not a QMenu
+QWidget *QMenuPrivate::topCausedWidget() const
+{
+    QWidget* top = causedPopup.widget;
+    while (QMenu* m = qobject_cast<QMenu *>(top))
+        top = m->d_func()->causedPopup.widget;
+    return top;
+}
+
 QAction *QMenuPrivate::actionAt(QPoint p) const
 {
@@ -615 +628 @@
        return 0;
 
-    for(int i = 0; i < actionList.count(); i++) {
-        QAction *act = actionList[i];
-        if (actionRect(act).contains(p))
-            return act;
+    for(int i = 0; i < actionRects.count(); i++) {
+        if (actionRects.at(i).contains(p))
+            return actions.at(i);
     }
     return 0;
@@ -640 +652 @@
 }
 
+
+void QMenuPrivate::updateLayoutDirection()
+{
+    Q_Q(QMenu);
+    //we need to mimic the cause of the popup's layout direction
+    //to allow setting it on a mainwindow for example
+    //we call setLayoutDirection_helper to not overwrite a user-defined value
+    if (!q->testAttribute(Qt::WA_SetLayoutDirection)) {
+        if (QWidget *w = causedPopup.widget)
+            setLayoutDirection_helper(w->layoutDirection());
+        else if (QWidget *w = q->parentWidget())
+            setLayoutDirection_helper(w->layoutDirection());
+        else
+            setLayoutDirection_helper(QApplication::layoutDirection());
+    }
+}
+
+
 /*!
     Returns the action associated with this menu.
@@ -692 +722 @@
     if (!scroll || !scroll->scrollFlags)
         return;
+    updateActionRects();
     int newOffset = 0;
-    const int scrollHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q);
-    const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp)   ? scrollHeight : 0;
-    const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollHeight : 0;
+    const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp)   ? scrollerHeight() : 0;
+    const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollerHeight() : 0;
     const int vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q);
     const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q);
 
     if (location == QMenuScroller::ScrollTop) {
-        for(int i = 0, saccum = 0; i < actionList.count(); i++) {
-            QAction *act = actionList.at(i);
-            if (act == action) {
+        for(int i = 0, saccum = 0; i < actions.count(); i++) {
+            if (actions.at(i) == action) {
                 newOffset = topScroll - saccum;
                 break;
             }
-            saccum += actionRects.value(act).height();
+            saccum += actionRects.at(i).height();
         }
     } else {
-        for(int i = 0, saccum = 0; i < actionList.count(); i++) {
-            QAction *act = actionList.at(i);
-            saccum += actionRects.value(act).height();
-            if (act == action) {
+        for(int i = 0, saccum = 0; i < actions.count(); i++) {
+            saccum += actionRects.at(i).height();
+            if (actions.at(i) == action) {
                 if (location == QMenuScroller::ScrollCenter)
                     newOffset = ((q->height() / 2) - botScroll) - (saccum - topScroll);
@@ -721 +749 @@
         }
         if(newOffset)
-            newOffset -= fw*2;
+            newOffset -= fw * 2;
     }
 
@@ -729 +757 @@
         newScrollFlags |= QMenuScroller::ScrollUp;
     int saccum = newOffset;
-    for(int i = 0; i < actionList.count(); i++) {
-        saccum += actionRects.value(actionList.at(i)).height();
+    for(int i = 0; i < actionRects.count(); i++) {
+        saccum += actionRects.at(i).height();
         if (saccum > q->height()) {
             newScrollFlags |= QMenuScroller::ScrollDown;
@@ -748 +776 @@
         newOffset -= vmargin;
 
-    QRect screen = popupGeometry(QApplication::desktop()->screenNumber(q));
+    QRect screen = popupGeometry(q);
     const int desktopFrame = q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q);
     if (q->height() < screen.height()-(desktopFrame*2)-1) {
@@ -781 +809 @@
 
     //actually update flags
-    scroll->scrollOffset = newOffset;
-    if (scroll->scrollOffset > 0)
-        scroll->scrollOffset = 0;
+    const int delta = qMin(0, newOffset) - scroll->scrollOffset; //make sure the new offset is always negative
+    if (!itemsDirty && delta) {
+        //we've scrolled so we need to update the action rects
+        for (int i = 0; i < actionRects.count(); ++i) {
+            QRect &current = actionRects[i];
+            current.moveTop(current.top() + delta);
+
+            //we need to update the widgets geometry
+            if (QWidget *w = widgetItems.value(actions.at(i)))
+                w->setGeometry(current);
+        }
+    }
+    scroll->scrollOffset += delta;
     scroll->scrollFlags = newScrollFlags;
     if (active)
@@ -794 +832 @@
 {
     Q_Q(QMenu);
+    updateActionRects();
     if(location == QMenuScroller::ScrollBottom) {
-        for(int i = actionList.size()-1; i >= 0; --i) {
-            QAction *act = actionList.at(i);
+        for(int i = actions.size()-1; i >= 0; --i) {
+            QAction *act = actions.at(i);
+            if (actionRects.at(i).isNull())
+                continue;
             if (!act->isSeparator() &&
                 (q->style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, q)
@@ -808 +849 @@
         }
     } else if(location == QMenuScroller::ScrollTop) {
-        for(int i = 0; i < actionList.size(); ++i) {
-            QAction *act = actionList.at(i);
+        for(int i = 0; i < actions.size(); ++i) {
+            QAction *act = actions.at(i);
+            if (actionRects.at(i).isNull())
+                continue;
             if (!act->isSeparator() &&
                 (q->style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, q)
@@ -829 +872 @@
     if (!scroll || !(scroll->scrollFlags & direction)) //not really possible...
         return;
-    const int scrollHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q);
-    const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp)   ? scrollHeight : 0;
-    const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollHeight : 0;
+    updateActionRects();
+    const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp)   ? scrollerHeight() : 0;
+    const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollerHeight() : 0;
     const int vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q);
     const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q);
     const int offset = topScroll ? topScroll-vmargin : 0;
     if (direction == QMenuScroller::ScrollUp) {
-        for(int i = 0, saccum = 0; i < actionList.count(); i++) {
-            QAction *act = actionList.at(i);
-            const int iHeight = actionRects.value(act).height();
-            saccum -= iHeight;
+        for(int i = 0, saccum = 0; i < actions.count(); i++) {
+            saccum -= actionRects.at(i).height();
             if (saccum <= scroll->scrollOffset-offset) {
-                scrollMenu(act, page ? QMenuScroller::ScrollBottom : QMenuScroller::ScrollTop, active);
+                scrollMenu(actions.at(i), page ? QMenuScroller::ScrollBottom : QMenuScroller::ScrollTop, active);
                 break;
             }
@@ -847 +888 @@
     } else if (direction == QMenuScroller::ScrollDown) {
         bool scrolled = false;
-        for(int i = 0, saccum = 0; i < actionList.count(); i++) {
-            QAction *act = actionList.at(i);
-            const int iHeight = actionRects.value(act).height();
+        for(int i = 0, saccum = 0; i < actions.count(); i++) {
+            const int iHeight = actionRects.at(i).height();
             saccum -= iHeight;
             if (saccum <= scroll->scrollOffset-offset) {
                 const int scrollerArea = q->height() - botScroll - fw*2;
                 int visible = (scroll->scrollOffset-offset) - saccum;
-                for(i++ ; i < actionList.count(); i++) {
-                    act = actionList.at(i);
-                    const int iHeight = actionRects.value(act).height();
-                    visible += iHeight;
+                for(i++ ; i < actions.count(); i++) {
+                    visible += actionRects.at(i).height();
                     if (visible > scrollerArea - topScroll) {
                         scrolled = true;
-                        scrollMenu(act, page ? QMenuScroller::ScrollTop : QMenuScroller::ScrollBottom, active);
+                        scrollMenu(actions.at(i), page ? QMenuScroller::ScrollTop : QMenuScroller::ScrollBottom, active);
                         break;
                     }
@@ -883 +921 @@
         bool isScroll = false;
         if (pos.x() >= 0 && pos.x() < q->width()) {
-            const int scrollerHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q);
             for(int dir = QMenuScroller::ScrollUp; dir <= QMenuScroller::ScrollDown; dir = dir << 1) {
                 if (scroll->scrollFlags & dir) {
                     if (dir == QMenuScroller::ScrollUp)
-                        isScroll = (pos.y() <= scrollerHeight);
+                        isScroll = (pos.y() <= scrollerHeight());
                     else if (dir == QMenuScroller::ScrollDown)
-                        isScroll = (pos.y() >= q->height()-scrollerHeight);
+                        isScroll = (pos.y() >= q->height() - scrollerHeight());
                     if (isScroll) {
                         scroll->scrollDirection = dir;
@@ -898 +935 @@
         }
         if (isScroll) {
-            if (!scroll->scrollTimer)
-                scroll->scrollTimer = new QBasicTimer;
-            scroll->scrollTimer->start(50, q);
+            scroll->scrollTimer.start(50, q);
             return true;
-        } else if (scroll->scrollTimer && scroll->scrollTimer->isActive()) {
-            scroll->scrollTimer->stop();
+        } else {
+            scroll->scrollTimer.stop();
         }
     }
@@ -910 +945 @@
         QRect tearRect(0, 0, q->width(), q->style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, q));
         if (scroll && scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)
-            tearRect.translate(0, q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q));
+            tearRect.translate(0, scrollerHeight());
         q->update(tearRect);
         if (tearRect.contains(pos) && hasMouseMoved(e->globalPos())) {
@@ -957 +992 @@
 }
 
+class ExceptionGuard
+{
+public:
+    inline ExceptionGuard(bool *w = 0) : watched(w) { Q_ASSERT(!(*watched)); *watched = true; }
+    inline ~ExceptionGuard() { *watched = false; }
+    inline operator bool() { return *watched; }
+private:
+    bool *watched;
+};
+
 void QMenuPrivate::activateCausedStack(const QList<QPointer<QWidget> > &causedStack, QAction *action, QAction::ActionEvent action_e, bool self)
 {
-    Q_ASSERT(!activationRecursionGuard);
-    activationRecursionGuard = true;
+    ExceptionGuard guard(&activationRecursionGuard);
 #ifdef QT3_SUPPORT
     const int actionId = q_func()->findIdForAction(action);
@@ -1005 +1049 @@
         }
     }
-    activationRecursionGuard = false;
 }
 
@@ -1035 +1078 @@
             hideUpToMenuBar();
         } else {
-            for(QWidget *widget = qApp->activePopupWidget(); widget; ) {
+            for(QWidget *widget = QApplication::activePopupWidget(); widget; ) {
                 if (QMenu *qmenu = qobject_cast<QMenu*>(widget)) {
                     if(qmenu == q)
@@ -1069 +1112 @@
         }
 #endif
-        QWidget *w = causedPopup.widget;
-        while (QMenu *m = qobject_cast<QMenu*>(w))
-            w = m->d_func()->causedPopup.widget;
-        action->showStatusText(w);
+        action->showStatusText(topCausedWidget());
     } else {
         actionAboutToTrigger = 0;
@@ -1082 +1122 @@
     Q_Q(QMenu);
     if (QAction *action = qobject_cast<QAction *>(q->sender())) {
+        QWeakPointer<QAction> actionGuard = action;
 #ifdef QT3_SUPPORT
         //we store it here because the action might be deleted/changed by connected slots
@@ -1091 +1132 @@
 #endif
 
-        if (!activationRecursionGuard) {
+        if (!activationRecursionGuard && actionGuard) {
             //in case the action has not been activated by the mouse
             //we check the parent hierarchy
@@ -1165 +1206 @@
         option->palette.setCurrentColorGroup(QPalette::Disabled);
 
-    option->font = action->font();
+    option->font = action->font().resolve(font());
+    option->fontMetrics = QFontMetrics(option->font);
 
     if (d->currentAction && d->currentAction == action && !d->currentAction->isSeparator()) {
@@ -1209 +1251 @@
     bars, context menus, and other popup menus.
 
-    \ingroup application
+    \ingroup mainwindow-classes
     \ingroup basicwidgets
-    \mainclass
+
 
     A menu widget is a selection menu. It can be either a pull-down
@@ -1303 +1345 @@
     It is not possible to display an icon in a native menu on Windows Mobile.
 
+    \section1 QMenu on Mac OS X with Qt build against Cocoa
+
+    QMenu can be inserted only once in a menu/menubar. Subsequent insertions will
+    have no effect or will result in a disabled menu item.
+
     See the \l{mainwindows/menus}{Menus} example for an example of how
     to use QMenuBar and QMenu in your application.
@@ -1360 +1407 @@
 {
     Q_D(QMenu);
-    for (QHash<QAction *, QWidget *>::ConstIterator item = d->widgetItems.constBegin(),
-         end = d->widgetItems.constEnd(); item != end; ++item) {
-        QWidgetAction *action = static_cast<QWidgetAction *>(item.key());
-        QWidget *widget = item.value();
-        if (action && widget)
+    QHash<QAction *, QWidget *>::iterator it = d->widgetItems.begin();
+    for (; it != d->widgetItems.end(); ++it) {
+        if (QWidget *widget = it.value()) {
+            QWidgetAction *action = static_cast<QWidgetAction *>(it.key());
             action->releaseWidget(widget);
-    }
-    d->widgetItems.clear();
+            *it = 0;
+        }
+    }
 
     if (d->eventLoop)
         d->eventLoop->exit();
-    if (d->tornPopup)
-        d->tornPopup->close();
+    hideTearOffMenu();
 }
 
@@ -1583 +1629 @@
     if (d->tearoff == b)
         return;
-    if (!b && d->tornPopup)
-        d->tornPopup->close();
+    if (!b)
+        hideTearOffMenu();
     d->tearoff = b;
 
@@ -1619 +1665 @@
 void QMenu::hideTearOffMenu()
 {
-    if (d_func()->tornPopup)
-        d_func()->tornPopup->close();
+    if (QWidget *w = d_func()->tornPopup)
+        w->close();
 }
 
@@ -1718 +1764 @@
 {
     Q_D(const QMenu);
-    ensurePolished();
-    QMap<QAction*, QRect> actionRects;
-    QList<QAction*> actionList;
-    d->calcActionRects(actionRects, actionList);
+    d->updateActionRects();
 
     QSize s;
-    QStyleOption opt(0);
-    opt.rect = rect();
-    opt.palette = palette();
-    opt.state = QStyle::State_None;
-    for (QMap<QAction*, QRect>::const_iterator i = actionRects.constBegin();
-         i != actionRects.constEnd(); ++i) {
-        if (i.value().bottom() > s.height())
-            s.setHeight(i.value().y()+i.value().height());
-        if (i.value().right() > s.width())
-            s.setWidth(i.value().right());
-    }
-    if (d->tearoff)
-        s.rheight() += style()->pixelMetric(QStyle::PM_MenuTearoffHeight, &opt, this);
-    if (const int fw = style()->pixelMetric(QStyle::PM_MenuPanelWidth, &opt, this)) {
-        s.rwidth() += fw*2;
-        s.rheight() += fw*2;
+    for (int i = 0; i < d->actionRects.count(); ++i) {
+        const QRect &rect = d->actionRects.at(i);
+        if (rect.isNull())
+            continue;
+        if (rect.bottom() >= s.height())
+            s.setHeight(rect.y() + rect.height());
+        if (rect.right() >= s.width())
+            s.setWidth(rect.x() + rect.width());
     }
     // Note that the action rects calculated above already include
     // the top and left margins, so we only need to add margins for
     // the bottom and right.
-    s.rwidth() += style()->pixelMetric(QStyle::PM_MenuHMargin, &opt, this);
-    s.rheight() += style()->pixelMetric(QStyle::PM_MenuVMargin, &opt, this);
-
-    s += QSize(d->leftmargin + d->rightmargin, d->topmargin + d->bottommargin);
+    QStyleOption opt(0);
+    opt.init(this);
+    const int fw = style()->pixelMetric(QStyle::PM_MenuPanelWidth, &opt, this);
+    s.rwidth() += style()->pixelMetric(QStyle::PM_MenuHMargin, &opt, this) + fw + d->rightmargin;
+    s.rheight() += style()->pixelMetric(QStyle::PM_MenuVMargin, &opt, this) + fw + d->bottommargin;
 
     return style()->sizeFromContents(QStyle::CT_Menu, &opt,
@@ -1777 +1813 @@
     d->motions = 0;
     d->doChildEffects = true;
+    d->updateLayoutDirection();
 
 #ifndef QT_NO_MENUBAR
     // if this menu is part of a chain attached to a QMenuBar, set the
     // _NET_WM_WINDOW_TYPE_DROPDOWN_MENU X11 window type
-    QWidget* top = this;
-    while (QMenu* m = qobject_cast<QMenu *>(top))
-        top = m->d_func()->causedPopup.widget;
-    setAttribute(Qt::WA_X11NetWmWindowTypeDropDownMenu, qobject_cast<QMenuBar *>(top) != 0);
+    setAttribute(Qt::WA_X11NetWmWindowTypeDropDownMenu, qobject_cast<QMenuBar *>(d->topCausedWidget()) != 0);
 #endif
 
     ensurePolished(); // Get the right font
     emit aboutToShow();
-    d->updateActions();
-    QPoint pos = p;
+    const bool actionListChanged = d->itemsDirty;
+    d->updateActionRects();
+    QPoint pos;
+    QPushButton *causedButton = qobject_cast<QPushButton*>(d->causedPopup.widget);
+    if (actionListChanged && causedButton)
+        pos = QPushButtonPrivate::get(causedButton)->adjustedMenuPosition();
+    else
+        pos = p;
+
     QSize size = sizeHint();
-    QRect screen = d->popupGeometry(QApplication::desktop()->screenNumber(p));
+    QRect screen;
+#ifndef QT_NO_GRAPHICSVIEW
+    bool isEmbedded = d->nearestGraphicsProxyWidget(this);
+    if (isEmbedded)
+        screen = d->popupGeometry(this);
+    else
+#endif
+    screen = d->popupGeometry(QApplication::desktop()->screenNumber(p));
+
     const int desktopFrame = style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, this);
     bool adjustToDesktop = !window()->testAttribute(Qt::WA_DontShowOnScreen);
+#ifdef QT_KEYPAD_NAVIGATION
+    if (!atAction && QApplication::keypadNavigationEnabled()) {
+        // Try to have one item activated
+        if (d->defaultAction && d->defaultAction->isEnabled()) {
+            atAction = d->defaultAction;
+            // TODO: This works for first level menus, not yet sub menus
+        } else {
+            foreach (QAction *action, d->actions)
+                if (action->isEnabled()) {
+                    atAction = action;
+                    break;
+                }
+        }
+        d->currentAction = atAction;
+    }
+#endif
     if (d->ncols > 1) {
         pos.setY(screen.top()+desktopFrame);
     } else if (atAction) {
-        for(int i=0, above_height=0; i<(int)d->actionList.count(); i++) {
-            QAction *action = d->actionList.at(i);
+        for(int i = 0, above_height = 0; i < d->actions.count(); i++) {
+            QAction *action = d->actions.at(i);
             if (action == atAction) {
-                int newY = pos.y()-above_height;
+                int newY = pos.y() - above_height;
                 if (d->scroll && newY < desktopFrame) {
                     d->scroll->scrollFlags = d->scroll->scrollFlags
@@ -1813 +1878 @@
                     && !style()->styleHint(QStyle::SH_Menu_FillScreenWithScroll, 0, this)) {
                     int below_height = above_height + d->scroll->scrollOffset;
-                    for(int i2 = i; i2 < (int)d->actionList.count(); i2++)
-                        below_height += d->actionRects.value(d->actionList.at(i2)).height();
+                    for(int i2 = i; i2 < d->actionRects.count(); i2++)
+                        below_height += d->actionRects.at(i2).height();
                     size.setHeight(below_height);
                 }
                 break;
             } else {
-                above_height += d->actionRects.value(action).height();
+                above_height += d->actionRects.at(i).height();
             }
         }
@@ -1830 +1895 @@
     if (adjustToDesktop) {
         //handle popup falling "off screen"
-        if (qApp->layoutDirection() == Qt::RightToLeft) {
+        if (isRightToLeft()) {
             if(snapToMouse) //position flowing left from the mouse
                 pos.setX(mouse.x()-size.width());
+
+#ifndef QT_NO_MENUBAR
+            //if in a menubar, it should be right-aligned
+            if (qobject_cast<QMenuBar*>(d->causedPopup.widget))
+                pos.rx() -= size.width();
+#endif //QT_NO_MENUBAR
 
             if (pos.x() < screen.left()+desktopFrame)
@@ -1840 +1911 @@
         } else {
             if (pos.x()+size.width()-1 > screen.right()-desktopFrame)
-                pos.setX(qMin(p.x()+size.width(), screen.right()-desktopFrame-size.width()+1));
+                pos.setX(screen.right()-desktopFrame-size.width()+1);
             if (pos.x() < screen.left()+desktopFrame)
-                pos.setX(qMax(p.x(), screen.left() + desktopFrame));
+                pos.setX(screen.left() + desktopFrame);
         }
         if (pos.y() + size.height() - 1 > screen.bottom() - desktopFrame) {
@@ -1868 +1939 @@
     setGeometry(QRect(pos, size));
 #ifndef QT_NO_EFFECTS
-    int hGuess = qApp->layoutDirection() == Qt::RightToLeft ? QEffects::LeftScroll : QEffects::RightScroll;
+    int hGuess = isRightToLeft() ? QEffects::LeftScroll : QEffects::RightScroll;
     int vGuess = QEffects::DownScroll;
-    if (qApp->layoutDirection() == Qt::RightToLeft) {
+    if (isRightToLeft()) {
         if ((snapToMouse && (pos.x() + size.width()/2 > mouse.x())) ||
            (qobject_cast<QMenu*>(d->causedPopup.widget) && pos.x() + size.width()/2 > d->causedPopup.widget->x()))
@@ -2026 +2097 @@
 {
     QMenu menu(parent);
-    for(QList<QAction*>::ConstIterator it = actions.constBegin(); it != actions.constEnd(); ++it)
-        menu.addAction((*it));
+    menu.addActions(actions);
     return menu.exec(pos, at);
 }
@@ -2077 +2147 @@
     d->causedPopup.widget = 0;
     d->causedPopup.action = 0;
+    if (d->scroll)
+        d->scroll->scrollTimer.stop(); //make sure the timer stops
 }
 
@@ -2085 +2157 @@
 {
     Q_D(QMenu);
+    d->updateActionRects();
     QPainter p(this);
     QRegion emptyArea = QRegion(rect());
@@ -2097 +2170 @@
 
     //draw the items that need updating..
-    for (int i = 0; i < d->actionList.count(); ++i) {
-        QAction *action = d->actionList.at(i);
-        QRect adjustedActionRect = d->actionRect(action);
+    for (int i = 0; i < d->actions.count(); ++i) {
+        QAction *action = d->actions.at(i);
+        QRect adjustedActionRect = d->actionRects.at(i);
         if (!e->rect().intersects(adjustedActionRect)
             || d->widgetItems.value(action))
@@ -2117 +2190 @@
     //draw the scroller regions..
     if (d->scroll) {
-        const int scrollerHeight = style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this);
         menuOpt.menuItemType = QStyleOptionMenuItem::Scroller;
         menuOpt.state |= QStyle::State_Enabled;
         if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp) {
-            menuOpt.rect.setRect(fw, fw, width() - (fw * 2), scrollerHeight);
+            menuOpt.rect.setRect(fw, fw, width() - (fw * 2), d->scrollerHeight());
             emptyArea -= QRegion(menuOpt.rect);
             p.setClipRect(menuOpt.rect);
@@ -2127 +2199 @@
         }
         if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown) {
-            menuOpt.rect.setRect(fw, height() - scrollerHeight - fw, width() - (fw * 2),
-                                     scrollerHeight);
+            menuOpt.rect.setRect(fw, height() - d->scrollerHeight() - fw, width() - (fw * 2),
+                                     d->scrollerHeight());
             emptyArea -= QRegion(menuOpt.rect);
             menuOpt.state |= QStyle::State_DownArrow;
@@ -2141 +2213 @@
                              style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this));
         if (d->scroll && d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)
-            menuOpt.rect.translate(0, style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this));
+            menuOpt.rect.translate(0, d->scrollerHeight());
         emptyArea -= QRegion(menuOpt.rect);
         p.setClipRect(menuOpt.rect);
@@ -2235 +2307 @@
             action->menu()->d_func()->setFirstActionActive();
         else {
-#if defined(Q_WS_WIN) && !defined(QT_NO_MENUBAR)
+#if defined(Q_WS_WIN)
             //On Windows only context menus can be activated with the right button
-            bool isContextMenu = true;
-            const QWidget *cause = d->causedPopup.widget;
-            while (cause) {
-                //if the popup was caused by either QMenuBar or a QToolButton, it is not a context menu
-                if (qobject_cast<const QMenuBar *>(cause) || qobject_cast<const QToolButton *>(cause)) {
-                    isContextMenu = false;
-                    break;
-                } else if (const QMenu *menu = qobject_cast<const QMenu *>(cause)) {
-                    cause = menu->d_func()->causedPopup.widget;
-                } else {
-                    break;
-                }
-            }
-            if (e->button() == Qt::LeftButton || (e->button() == Qt::RightButton && isContextMenu))
+            if (e->button() == Qt::LeftButton || d->topCausedWidget() == 0)
 #endif
                 d->activateAction(action, QAction::Trigger);
@@ -2299 +2358 @@
     Q_D(QMenu);
     switch (e->type()) {
+    case QEvent::Polish:
+        d->updateLayoutDirection();
+        break;
     case QEvent::ShortcutOverride: {
             QKeyEvent *kev = static_cast<QKeyEvent*>(e);
@@ -2331 +2393 @@
         }
         d->itemsDirty = 1;
-        d->updateActions();
+        d->updateActionRects();
         break; }
     case QEvent::Show:
         d->mouseDown = 0;
-        d->updateActions();
+        d->updateActionRects();
         if (d->currentAction)
             d->popupAction(d->currentAction, 0, false);
@@ -2371 +2433 @@
 {
     Q_D(QMenu);
+    d->updateActionRects();
     int key = e->key();
     if (isRightToLeft()) {  // in reverse mode open/close key for submenues are reversed
@@ -2422 +2485 @@
         if (!d->currentAction) {
             if(key == Qt::Key_Down) {
-                for(int i = 0; i < d->actionList.size(); ++i) {
-                    QAction *act = d->actionList.at(i);
+                for(int i = 0; i < d->actions.count(); ++i) {
+                    QAction *act = d->actions.at(i);
+                    if (d->actionRects.at(i).isNull())
+                        continue;
                     if (!act->isSeparator() &&
                         (style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, this)
@@ -2432 +2497 @@
                 }
             } else {
-                for(int i = d->actionList.size()-1; i >= 0; --i) {
-                    QAction *act = d->actionList.at(i);
+                for(int i = d->actions.count()-1; i >= 0; --i) {
+                    QAction *act = d->actions.at(i);
+                    if (d->actionRects.at(i).isNull())
+                        continue;
                     if (!act->isSeparator() &&
                         (style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, this)
@@ -2443 +2510 @@
             }
         } else {
-            for(int i=0, y=0; !nextAction && i < (int)d->actionList.count(); i++) {
-                QAction *act = d->actionList.at(i);
+            for(int i = 0, y = 0; !nextAction && i < d->actions.count(); i++) {
+                QAction *act = d->actions.at(i);
                 if (act == d->currentAction) {
                     if (key == Qt::Key_Up) {
@@ -2453 +2520 @@
                                 if (d->scroll)
                                     scroll_loc = QMenuPrivate::QMenuScroller::ScrollBottom;
-                                next_i = d->actionList.count()-1;
+                                next_i = d->actionRects.count()-1;
                             }
-                            QAction *next = d->actionList.at(next_i);
+                            QAction *next = d->actions.at(next_i);
                             if (next == d->currentAction)
                                 break;
+                            if (d->actionRects.at(next_i).isNull())
+                                continue;
                             if (next->isSeparator() ||
                                (!next->isEnabled() &&
@@ -2464 +2533 @@
                             nextAction = next;
                             if (d->scroll && (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)) {
-                                int topVisible = style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this);
+                                int topVisible = d->scrollerHeight();
                                 if (d->tearoff)
                                     topVisible += style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this);
-                                if (((y + d->scroll->scrollOffset) - topVisible) <= d->actionRects.value(nextAction).height())
+                                if (((y + d->scroll->scrollOffset) - topVisible) <= d->actionRects.at(next_i).height())
                                     scroll_loc = QMenuPrivate::QMenuScroller::ScrollTop;
                             }
@@ -2475 +2544 @@
                             d->tearoffHighlighted = 1;
                     } else {
-                        y += d->actionRects.value(act).height();
+                        y += d->actionRects.at(i).height();
                         for(int next_i = i+1; true; next_i++) {
-                            if (next_i == d->actionList.count()) {
+                            if (next_i == d->actionRects.count()) {
                                 if(!style()->styleHint(QStyle::SH_Menu_SelectionWrap, 0, this))
                                     break;
@@ -2484 +2553 @@
                                 next_i = 0;
                             }
-                            QAction *next = d->actionList.at(next_i);
+                            QAction *next = d->actions.at(next_i);
                             if (next == d->currentAction)
                                 break;
+                            if (d->actionRects.at(next_i).isNull())
+                                continue;
                             if (next->isSeparator() ||
                                (!next->isEnabled() &&
@@ -2493 +2564 @@
                             nextAction = next;
                             if (d->scroll && (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown)) {
-                                const int scrollerHeight = style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this);
-                                int bottomVisible = height()-scrollerHeight;
+                                int bottomVisible = height() - d->scrollerHeight();
                                 if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)
-                                    bottomVisible -= scrollerHeight;
+                                    bottomVisible -= d->scrollerHeight();
                                 if (d->tearoff)
                                     bottomVisible -= style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this);
-                                if ((y + d->scroll->scrollOffset + d->actionRects.value(nextAction).height()) > bottomVisible)
+                                if ((y + d->scroll->scrollOffset + d->actionRects.at(next_i).height()) > bottomVisible)
                                     scroll_loc = QMenuPrivate::QMenuScroller::ScrollBottom;
                             }
@@ -2507 +2577 @@
                     break;
                 }
-                y += d->actionRects.value(act).height();
+                y += d->actionRects.at(i).height();
             }
         }
         if (nextAction) {
             if (d->scroll && scroll_loc != QMenuPrivate::QMenuScroller::ScrollStay) {
-                if (d->scroll->scrollTimer)
-                    d->scroll->scrollTimer->stop();
+                d->scroll->scrollTimer.stop();
                 d->scrollMenu(nextAction, scroll_loc);
             }
@@ -2562 +2631 @@
             d->hideMenu(this);
 #ifndef QT_NO_MENUBAR
-            if (QMenuBar *mb = qobject_cast<QMenuBar*>(qApp->focusWidget())) {
+            if (QMenuBar *mb = qobject_cast<QMenuBar*>(QApplication::focusWidget())) {
                 mb->d_func()->setKeyboardMode(false);
             }
@@ -2635 +2704 @@
                 d->searchBufferTimer.start(2000, this);
                 d->searchBuffer += e->text();
-                for(int i = 0; i < d->actionList.size(); ++i) {
+                for(int i = 0; i < d->actions.size(); ++i) {
                     int match_count = 0;
-                    register QAction *act = d->actionList.at(i);
+                    if (d->actionRects.at(i).isNull())
+                        continue;
+                    QAction *act = d->actions.at(i);
                     const QString act_text = act->text();
                     for(int c = 0; c < d->searchBuffer.size(); ++c) {
@@ -2654 +2725 @@
                 QAction *first = 0, *currentSelected = 0, *firstAfterCurrent = 0;
                 QChar c = e->text().at(0).toUpper();
-                for(int i = 0; i < d->actionList.size(); ++i) {
-                    register QAction *act = d->actionList.at(i);
+                for(int i = 0; i < d->actions.size(); ++i) {
+                    if (d->actionRects.at(i).isNull())
+                        continue;
+                    QAction *act = d->actions.at(i);
                     QKeySequence sequence = QKeySequence::mnemonic(act->text());
                     int key = sequence[0] & 0xffff;
@@ -2690 +2763 @@
         }
         if (!key_consumed) {
-            if (QWidget *caused = d->causedPopup.widget) {
-                while(QMenu *m = qobject_cast<QMenu*>(caused))
-                    caused = m->d_func()->causedPopup.widget;
 #ifndef QT_NO_MENUBAR
-                if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) {
-                    QAction *oldAct = mb->d_func()->currentAction;
-                    QApplication::sendEvent(mb, e);
-                    if (mb->d_func()->currentAction != oldAct)
-                        key_consumed = true;
-                }
-#endif
+            if (QMenuBar *mb = qobject_cast<QMenuBar*>(d->topCausedWidget())) {
+                QAction *oldAct = mb->d_func()->currentAction;
+                QApplication::sendEvent(mb, e);
+                if (mb->d_func()->currentAction != oldAct)
+                    key_consumed = true;
             }
+#endif
         }
 
 #ifdef Q_OS_WIN32
         if (key_consumed && (e->key() == Qt::Key_Control || e->key() == Qt::Key_Shift || e->key() == Qt::Key_Meta))
-            qApp->beep();
+            QApplication::beep();
 #endif // Q_OS_WIN32
     }
@@ -2726 +2795 @@
     if (d->motions == 0) // ignore first mouse move event (see enterEvent())
         return;
-    d->hasHadMouse |= rect().contains(e->pos());
+    d->hasHadMouse = d->hasHadMouse || rect().contains(e->pos());
 
     QAction *action = d->actionAt(e->pos());
     if (!action) {
-        if (d->hasHadMouse && !rect().contains(e->pos()))
+        if (d->hasHadMouse)
             d->setCurrentAction(0);
         return;
-    } else if(e->buttons() & (Qt::LeftButton | Qt::RightButton)) {
+    } else if(e->buttons()) {
         d->mouseDown = this;
     }
@@ -2761 +2830 @@
     if (!d->sloppyRegion.isEmpty())
         d->sloppyRegion = QRegion();
+    if (!d->activeMenu && d->currentAction)
+        setActiveAction(0);
 }
 
@@ -2770 +2841 @@
 {
     Q_D(QMenu);
-    if (d->scroll && d->scroll->scrollTimer && d->scroll->scrollTimer->timerId() == e->timerId()) {
+    if (d->scroll && d->scroll->scrollTimer.timerId() == e->timerId()) {
         d->scrollMenu((QMenuPrivate::QMenuScroller::ScrollDirection)d->scroll->scrollDirection);
         if (d->scroll->scrollFlags == QMenuPrivate::QMenuScroller::ScrollNone)
-            d->scroll->scrollTimer->stop();
+            d->scroll->scrollTimer.stop();
     } else if(QMenuPrivate::menuDelayTimer.timerId() == e->timerId()) {
         QMenuPrivate::menuDelayTimer.stop();
@@ -2800 +2871 @@
             connect(e->action(), SIGNAL(hovered()), this, SLOT(_q_actionHovered()));
         }
-
         if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action())) {
             QWidget *widget = wa->requestWidget(this);
@@ -2807 +2877 @@
         }
     } else if (e->type() == QEvent::ActionRemoved) {
-        d->actionRects.clear();
-        d->actionList.clear();
         e->action()->disconnect(this);
         if (e->action() == d->currentAction)
             d->currentAction = 0;
         if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action())) {
-            QWidget *widget = d->widgetItems.take(wa);
-            if (widget)
+            if (QWidget *widget = d->widgetItems.value(wa))
                 wa->releaseWidget(widget);
-        } else {
-            // If this is called from the QAction destructor, the
-            // previous call to qobject_cast will fail because the
-            // QWidgetAction has been destroyed already. We need to
-            // remove it from the hash anyway or it might crash later
-            // the widget itself has been already destroyed in
-            // ~QWidgetAction
-            d->widgetItems.remove(e->action());
-        }
+        }
+        d->widgetItems.remove(e->action());
     }
 
@@ -2838 +2898 @@
 #endif
 
-#if defined(Q_OS_WINCE) && !defined(QT_NO_MENUBAR)
+#if defined(Q_WS_WINCE) && !defined(QT_NO_MENUBAR)
     if (!d->wce_menu)
         d->wce_menu = new QMenuPrivate::QWceMenuPrivate;
@@ -2849 +2909 @@
 #endif
 
+#ifdef Q_WS_S60
+    if (!d->symbian_menu)
+        d->symbian_menu = new QMenuPrivate::QSymbianMenuPrivate;
+    if (e->type() == QEvent::ActionAdded)
+        d->symbian_menu->addAction(e->action(), d->symbian_menu->findAction(e->before()));
+    else if (e->type() == QEvent::ActionRemoved)
+        d->symbian_menu->removeAction(e->action());
+    else if (e->type() == QEvent::ActionChanged)
+        d->symbian_menu->syncAction(e->action());
+#endif
     if (isVisible()) {
-        d->updateActions();
+        d->updateActionRects();
         resize(sizeHint());
         update();
@@ -2896 +2966 @@
     QMenu *caused = qobject_cast<QMenu*>(d->activeMenu->d_func()->causedPopup.widget);
 
-    const QRect availGeometry(d->popupGeometry(QApplication::desktop()->screenNumber(caused)));
+    const QRect availGeometry(d->popupGeometry(caused));
     if (isRightToLeft()) {
         pos = leftPos;
@@ -3028 +3098 @@
 {
     Q_D(QMenu);
+    if (d->collapsibleSeparators == collapse)
+        return;
+
     d->collapsibleSeparators = collapse;
     d->itemsDirty = 1;
     if (isVisible()) {
-        d->updateActions();
+        d->updateActionRects();
         update();
     }
+#ifdef Q_WS_MAC
+    if (d->mac_menu)
+        d->syncSeparatorsCollapsible(collapse);
+#endif
 }
 
@@ -3090 +3167 @@
 QAction *QMenu::findActionForId(int id) const
 {
-    QList<QAction *> list = actions();
-    for (int i = 0; i < list.size(); ++i) {
-        QAction *act = list.at(i);
+    Q_D(const QMenu);
+    for (int i = 0; i < d->actions.size(); ++i) {
+        QAction *act = d->actions.at(i);
         if (findIdForAction(act)== id)
             return act;