/****************************************************************************+
−
**+
−
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).+
−
** All rights reserved.+
−
** Contact: Nokia Corporation (qt-info@nokia.com)+
−
**+
−
** This file is part of the QtGui module of the Qt Toolkit.+
−
**+
−
** $QT_BEGIN_LICENSE:LGPL$+
−
** No Commercial Usage+
−
** This file contains pre-release code and may not be distributed.+
−
** You may use this file in accordance with the terms and conditions+
−
** contained in the Technology Preview License Agreement accompanying+
−
** this package.+
−
**+
−
** GNU Lesser General Public License Usage+
−
** Alternatively, this file may be used under the terms of the GNU Lesser+
−
** General Public License version 2.1 as published by the Free Software+
−
** Foundation and appearing in the file LICENSE.LGPL included in the+
−
** packaging of this file.  Please review the following information to+
−
** ensure the GNU Lesser General Public License version 2.1 requirements+
−
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+
−
**+
−
** In addition, as a special exception, Nokia gives you certain additional+
−
** rights.  These rights are described in the Nokia Qt LGPL Exception+
−
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+
−
**+
−
** If you have questions regarding the use of this file, please contact+
−
** Nokia at qt-info@nokia.com.+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
** $QT_END_LICENSE$+
−
**+
−
****************************************************************************/+
−
+
−
#include "qmenu.h"+
−
+
−
#ifndef QT_NO_MENU+
−
+
−
#include "qdebug.h"+
−
#include "qstyle.h"+
−
#include "qevent.h"+
−
#include "qtimer.h"+
−
#include "qlayout.h"+
−
#include "qpainter.h"+
−
#include "qapplication.h"+
−
#include "qdesktopwidget.h"+
−
#ifndef QT_NO_ACCESSIBILITY+
−
# include "qaccessible.h"+
−
#endif+
−
#ifndef QT_NO_EFFECTS+
−
# include <private/qeffects_p.h>+
−
#endif+
−
#ifndef QT_NO_WHATSTHIS+
−
# include <qwhatsthis.h>+
−
#endif+
−
+
−
#include "qmenu_p.h"+
−
#include "qmenubar_p.h"+
−
#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>+
−
#endif // QT3_SUPPORT+
−
+
−
#ifdef Q_WS_X11+
−
#   include <private/qt_x11_p.h>+
−
#endif+
−
+
−
#if defined(Q_WS_MAC) && !defined(QT_NO_EFFECTS)+
−
#   include <private/qcore_mac_p.h>+
−
#   include <private/qt_cocoa_helpers_mac_p.h>+
−
#endif+
−
+
−
+
−
QT_BEGIN_NAMESPACE+
−
+
−
QPointer<QMenu> QMenuPrivate::mouseDown;+
−
QBasicTimer QMenuPrivate::menuDelayTimer;+
−
QBasicTimer QMenuPrivate::sloppyDelayTimer;+
−
+
−
/* QMenu code */+
−
// internal class used for the torn off popup+
−
class QTornOffMenu : public QMenu+
−
{+
−
    Q_OBJECT+
−
    class QTornOffMenuPrivate : public QMenuPrivate+
−
    {+
−
        Q_DECLARE_PUBLIC(QMenu)+
−
    public:+
−
        QTornOffMenuPrivate(QMenu *p) : causedMenu(p) {+
−
            tornoff = 1;+
−
            causedPopup.widget = 0;+
−
            causedPopup.action = ((QTornOffMenu*)p)->d_func()->causedPopup.action;+
−
            causedStack = ((QTornOffMenu*)p)->d_func()->calcCausedStack();+
−
        }+
−
        QList<QPointer<QWidget> > calcCausedStack() const { return causedStack; }+
−
        QPointer<QMenu> causedMenu;+
−
        QList<QPointer<QWidget> > causedStack;+
−
    };+
−
public:+
−
    QTornOffMenu(QMenu *p) : QMenu(*(new QTornOffMenuPrivate(p)))+
−
    {+
−
        Q_D(QTornOffMenu);+
−
        // make the torn-off menu a sibling of p (instead of a child)+
−
        QWidget *parentWidget = d->causedStack.isEmpty() ? p : d->causedStack.last();+
−
        if (parentWidget->parentWidget())+
−
            parentWidget = parentWidget->parentWidget();+
−
        setParent(parentWidget, Qt::Window | Qt::Tool);+
−
        setAttribute(Qt::WA_DeleteOnClose, true);+
−
        setAttribute(Qt::WA_X11NetWmWindowTypeMenu, true);+
−
        setWindowTitle(p->windowTitle());+
−
        setEnabled(p->isEnabled());+
−
        //QObject::connect(this, SIGNAL(triggered(QAction*)), this, SLOT(onTrigger(QAction*)));+
−
        //QObject::connect(this, SIGNAL(hovered(QAction*)), this, SLOT(onHovered(QAction*)));+
−
        QList<QAction*> items = p->actions();+
−
        for(int i = 0; i < items.count(); i++)+
−
            addAction(items.at(i));+
−
    }+
−
    void syncWithMenu(QMenu *menu, QActionEvent *act)+
−
    {+
−
        Q_D(QTornOffMenu);+
−
        if(menu != d->causedMenu)+
−
            return;+
−
        if (act->type() == QEvent::ActionAdded) {+
−
            insertAction(act->before(), act->action());+
−
        } else if (act->type() == QEvent::ActionRemoved)+
−
            removeAction(act->action());+
−
    }+
−
    void actionEvent(QActionEvent *e)+
−
    {+
−
        QMenu::actionEvent(e);+
−
        setFixedSize(sizeHint());+
−
    }+
−
public slots:+
−
    void onTrigger(QAction *action) { d_func()->activateAction(action, QAction::Trigger, false); }+
−
    void onHovered(QAction *action) { d_func()->activateAction(action, QAction::Hover, false); }+
−
private:+
−
    Q_DECLARE_PRIVATE(QTornOffMenu)+
−
    friend class QMenuPrivate;+
−
};+
−
+
−
void QMenuPrivate::init()+
−
{+
−
    Q_Q(QMenu);+
−
#ifndef QT_NO_WHATSTHIS+
−
    q->setAttribute(Qt::WA_CustomWhatsThis);+
−
#endif+
−
    q->setAttribute(Qt::WA_X11NetWmWindowTypePopupMenu);+
−
    defaultMenuAction = menuAction = new QAction(q);+
−
    menuAction->d_func()->menu = q;+
−
    q->setMouseTracking(q->style()->styleHint(QStyle::SH_Menu_MouseTracking, 0, q));+
−
    if (q->style()->styleHint(QStyle::SH_Menu_Scrollable, 0, q)) {+
−
        scroll = new QMenuPrivate::QMenuScroller;+
−
        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->setPriority(QAction::HighPriority);+
−
    cancelAction->setPriority(QAction::HighPriority);+
−
    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 and KDE allows menus to cover the taskbar, while GNOME and Mac don't+
−
QRect QMenuPrivate::popupGeometry(const QWidget *widget) const+
−
{+
−
#ifdef Q_WS_WIN+
−
    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+
−
}+
−
+
−
//Windows and KDE allows menus to cover the taskbar, while GNOME and Mac don't+
−
QRect QMenuPrivate::popupGeometry(int screen) const+
−
{+
−
#ifdef Q_WS_WIN+
−
    return QApplication::desktop()->screenGeometry(screen);+
−
#elif defined Q_WS_X11+
−
    if (X11->desktopEnvironment == DE_KDE)+
−
        return QApplication::desktop()->screenGeometry(screen);+
−
    else+
−
        return QApplication::desktop()->availableGeometry(screen);+
−
#else+
−
        return QApplication::desktop()->availableGeometry(screen);+
−
#endif+
−
}+
−
+
−
QList<QPointer<QWidget> > QMenuPrivate::calcCausedStack() const+
−
{+
−
    QList<QPointer<QWidget> > ret;+
−
    for(QWidget *widget = causedPopup.widget; widget; ) {+
−
        ret.append(widget);+
−
        if (QTornOffMenu *qtmenu = qobject_cast<QTornOffMenu*>(widget))+
−
            ret += qtmenu->d_func()->causedStack;+
−
        if (QMenu *qmenu = qobject_cast<QMenu*>(widget))+
−
            widget = qmenu->d_func()->causedPopup.widget;+
−
        else+
−
            break;+
−
    }+
−
    return ret;+
−
}+
−
+
−
void QMenuPrivate::updateActionRects() const+
−
{+
−
    Q_Q(const QMenu);+
−
    if (!itemsDirty)+
−
        return;+
−
+
−
    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(q).height(),+
−
        y = 0;+
−
    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 tearoffHeight = tearoff ? style->pixelMetric(QStyle::PM_MenuTearoffHeight, &opt, q) : 0;+
−
+
−
    //for compatability now - will have to refactor this away..+
−
    tabWidth = 0;+
−
    maxIconWidth = 0;+
−
    hasCheckableItems = false;+
−
    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()) {+
−
            maxIconWidth = qMax<uint>(maxIconWidth, icone + 4);+
−
        }+
−
    }+
−
+
−
    //calculate size+
−
    QFontMetrics qfm = q->fontMetrics();+
−
    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);+
−
        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());+
−
        } else {+
−
            //calc what I think the size is..+
−
            if (action->isSeparator()) {+
−
                sz = QSize(2, 2);+
−
            } else {+
−
                QString s = action->text();+
−
                int t = s.indexOf(QLatin1Char('\t'));+
−
                if (t != -1) {+
−
                    tabWidth = qMax(int(tabWidth), qfm.width(s.mid(t+1)));+
−
                    s = s.left(t);+
−
    #ifndef QT_NO_SHORTCUT+
−
                } else {+
−
                    QKeySequence seq = action->shortcut();+
−
                    if (!seq.isEmpty())+
−
                        tabWidth = qMax(int(tabWidth), qfm.width(seq));+
−
    #endif+
−
                }+
−
                sz.setWidth(fm.boundingRect(QRect(), Qt::TextSingleLine | Qt::TextShowMnemonic, s).width());+
−
                sz.setHeight(qMax(fm.height(), qfm.height()));+
−
+
−
                QIcon is = action->icon();+
−
                if (!is.isNull()) {+
−
                    QSize is_sz = QSize(icone, icone);+
−
                    if (is_sz.height() > sz.height())+
−
                        sz.setHeight(is_sz.height());+
−
                }+
−
            }+
−
            sz = style->sizeFromContents(QStyle::CT_MenuItem, &opt, sz, q);+
−
        }+
−
+
−
+
−
        if (!sz.isEmpty()) {+
−
            max_column_width = qMax(max_column_width, sz.width());+
−
            //wrapping+
−
            if (!scroll &&+
−
               y+sz.height()+vmargin > dh - (deskFw * 2)) {+
−
                ncols++;+
−
                y = vmargin;+
−
            }+
−
            y += sz.height();+
−
            //update the item+
−
            actionRects[i] = QRect(0, 0, sz.width(), sz.height());+
−
        }+
−
    }+
−
+
−
    max_column_width += tabWidth; //finally add in the tab width+
−
    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));+
−
    max_column_width = qMax(min_column_width, max_column_width);+
−
+
−
+
−
    //calculate position+
−
    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 - deskFw * 2) {+
−
            x += max_column_width + hmargin;+
−
            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();+
−
    }+
−
    itemsDirty = 0;+
−
}+
−
+
−
QRect QMenuPrivate::actionRect(QAction *act) const+
−
{+
−
    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;+
−
        hideMenu(q); //hide after getting causedPopup+
−
        while(caused) {+
−
#ifndef QT_NO_MENUBAR+
−
            if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) {+
−
                mb->d_func()->setCurrentAction(0);+
−
                mb->d_func()->setKeyboardMode(false);+
−
                caused = 0;+
−
            } else+
−
#endif+
−
            if (QMenu *m = qobject_cast<QMenu*>(caused)) {+
−
                caused = m->d_func()->causedPopup.widget;+
−
                if (!m->d_func()->tornoff)+
−
                    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, bool justRegister)+
−
{+
−
    if (!menu)+
−
        return;+
−
#if !defined(QT_NO_EFFECTS)+
−
    menu->blockSignals(true);+
−
    aboutToHide = true;+
−
    // Flash item which is about to trigger (if any).+
−
    if (menu->style()->styleHint(QStyle::SH_Menu_FlashTriggeredItem)+
−
        && currentAction && currentAction == actionAboutToTrigger+
−
        && menu->actions().contains(currentAction)) {+
−
        QEventLoop eventLoop;+
−
        QAction *activeAction = currentAction;+
−
+
−
        menu->setActiveAction(0);+
−
        QTimer::singleShot(60, &eventLoop, SLOT(quit()));+
−
        eventLoop.exec();+
−
+
−
        // Select and wait 20 ms.+
−
        menu->setActiveAction(activeAction);+
−
        QTimer::singleShot(20, &eventLoop, SLOT(quit()));+
−
        eventLoop.exec();+
−
    }+
−
+
−
    // Fade out.+
−
    if (menu->style()->styleHint(QStyle::SH_Menu_FadeOutOnHide)) {+
−
        // ### Qt 4.4:+
−
        // 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)+
−
        if (justRegister) {+
−
            QMacWindowFader::currentFader()->setFadeDuration(MenuFadeTimeInSec);+
−
            QMacWindowFader::currentFader()->registerWindowToFade(menu);+
−
        } else {+
−
            macWindowFade(qt_mac_window_for(menu), MenuFadeTimeInSec);+
−
        }+
−
+
−
#endif // Q_WS_MAC+
−
    }+
−
    aboutToHide = false;+
−
    menu->blockSignals(false);+
−
#endif // QT_NO_EFFECTS+
−
    if (!justRegister)+
−
        menu->hide();+
−
}+
−
+
−
void QMenuPrivate::popupAction(QAction *action, int delay, bool activateFirst)+
−
{+
−
    Q_Q(QMenu);+
−
    if (action && action->isEnabled()) {+
−
        if (!delay)+
−
            q->internalDelayedPopup();+
−
        else+
−
            QMenuPrivate::menuDelayTimer.start(delay, q);+
−
        if (activateFirst && action->menu())+
−
            action->menu()->d_func()->setFirstActionActive();+
−
    } else if (QMenu *menu = activeMenu) {  //hide the current item+
−
        activeMenu = 0;+
−
        hideMenu(menu);+
−
    }+
−
}+
−
+
−
void QMenuPrivate::setSyncAction()+
−
{+
−
    Q_Q(QMenu);+
−
    QAction *current = currentAction;+
−
    if(current && (!current->isEnabled() || current->menu() || current->isSeparator()))+
−
        current = 0;+
−
    for(QWidget *caused = q; caused;) {+
−
        if (QMenu *m = qobject_cast<QMenu*>(caused)) {+
−
            caused = m->d_func()->causedPopup.widget;+
−
            if (m->d_func()->eventLoop)+
−
                m->d_func()->syncAction = current; // synchronous operation+
−
        } else {+
−
            break;+
−
        }+
−
    }+
−
}+
−
+
−
+
−
void QMenuPrivate::setFirstActionActive()+
−
{+
−
    Q_Q(QMenu);+
−
    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 -= 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)+
−
            || act->isEnabled())) {+
−
            setCurrentAction(act);+
−
            break;+
−
        }+
−
    }+
−
}+
−
+
−
// popup == -1 means do not popup, 0 means immediately, others mean use a timer+
−
void QMenuPrivate::setCurrentAction(QAction *action, int popup, SelectionReason reason, bool activateFirst)+
−
{+
−
    Q_Q(QMenu);+
−
    tearoffHighlighted = 0;+
−
    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;+
−
    }+
−
    if (currentAction)+
−
        q->update(actionRect(currentAction));+
−
+
−
    sloppyAction = 0;+
−
    if (!sloppyRegion.isEmpty())+
−
        sloppyRegion = QRegion();+
−
    QMenu *hideActiveMenu = activeMenu;+
−
#ifndef QT_NO_STATUSTIP+
−
    QAction *previousAction = currentAction;+
−
#endif+
−
#ifdef QT3_SUPPORT+
−
    emitHighlighted = action;+
−
#endif+
−
    currentAction = action;+
−
    if (action) {+
−
        if (!action->isSeparator()) {+
−
            activateAction(action, QAction::Hover);+
−
            if (popup != -1) {+
−
                hideActiveMenu = 0; //will be done "later"+
−
                // if the menu is visible then activate the required action,+
−
                // otherwise we just mark the action as currentAction+
−
                // and activate it when the menu will be popuped.+
−
                if (q->isVisible())+
−
                    popupAction(currentAction, popup, activateFirst);+
−
            }+
−
            q->update(actionRect(action));+
−
+
−
            if (reason == SelectedFromKeyboard) {+
−
                QWidget *widget = widgetItems.value(action);+
−
                if (widget) {+
−
                    if (widget->focusPolicy() != Qt::NoFocus)+
−
                        widget->setFocus(Qt::TabFocusReason);+
−
                } else {+
−
                    //when the action has no QWidget, the QMenu itself should+
−
                    // get the focus+
−
                    // Since the menu is a pop-up, it uses the popup reason.+
−
                    if (!q->hasFocus()) {+
−
                        q->setFocus(Qt::PopupFocusReason);+
−
                    }+
−
                }+
−
            }+
−
        } else { //action is a separator+
−
            if (popup != -1)+
−
                hideActiveMenu = 0; //will be done "later"+
−
        }+
−
#ifndef QT_NO_STATUSTIP+
−
    }  else if (previousAction) {+
−
        previousAction->d_func()->showStatusText(topCausedWidget(), QString());+
−
#endif+
−
    }+
−
    if (hideActiveMenu) {+
−
        activeMenu = 0;+
−
#ifndef QT_NO_EFFECTS+
−
        // kill any running effect+
−
        qFadeEffect(0);+
−
        qScrollEffect(0);+
−
#endif+
−
        hideMenu(hideActiveMenu);+
−
    }+
−
}+
−
+
−
//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+
−
{+
−
    if (!q_func()->rect().contains(p))     //sanity check+
−
       return 0;+
−
+
−
    for(int i = 0; i < actionRects.count(); i++) {+
−
        if (actionRects.at(i).contains(p))+
−
            return actions.at(i);+
−
    }+
−
    return 0;+
−
}+
−
+
−
void QMenuPrivate::setOverrideMenuAction(QAction *a)+
−
{+
−
    Q_Q(QMenu);+
−
    QObject::disconnect(menuAction, SIGNAL(destroyed()), q, SLOT(_q_overrideMenuActionDestroyed()));+
−
    if (a) {+
−
        menuAction = a;+
−
        QObject::connect(a, SIGNAL(destroyed()), q, SLOT(_q_overrideMenuActionDestroyed()));+
−
    } else { //we revert back to the default action created by the QMenu itself+
−
        menuAction = defaultMenuAction;+
−
    }+
−
}+
−
+
−
void QMenuPrivate::_q_overrideMenuActionDestroyed()+
−
{+
−
    menuAction=defaultMenuAction;+
−
}+
−
+
−
+
−
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.+
−
*/+
−
QAction *QMenu::menuAction() const+
−
{+
−
    return d_func()->menuAction;+
−
}+
−
+
−
/*!+
−
  \property QMenu::title+
−
  \brief The title of the menu+
−
+
−
  This is equivalent to the QAction::text property of the menuAction().+
−
+
−
  By default, this property contains an empty string.+
−
*/+
−
QString QMenu::title() const+
−
{+
−
    return d_func()->menuAction->text();+
−
}+
−
+
−
void QMenu::setTitle(const QString &text)+
−
{+
−
    d_func()->menuAction->setText(text);+
−
}+
−
+
−
/*!+
−
  \property QMenu::icon+
−
+
−
  \brief The icon of the menu+
−
+
−
  This is equivalent to the QAction::icon property of the menuAction().+
−
+
−
  By default, if no icon is explicitly set, this property contains a null icon.+
−
*/+
−
QIcon QMenu::icon() const+
−
{+
−
    return d_func()->menuAction->icon();+
−
}+
−
+
−
void QMenu::setIcon(const QIcon &icon)+
−
{+
−
    d_func()->menuAction->setIcon(icon);+
−
}+
−
+
−
+
−
//actually performs the scrolling+
−
void QMenuPrivate::scrollMenu(QAction *action, QMenuScroller::ScrollLocation location, bool active)+
−
{+
−
    Q_Q(QMenu);+
−
    if (!scroll || !scroll->scrollFlags)+
−
        return;+
−
    updateActionRects();+
−
    int newOffset = 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 < actions.count(); i++) {+
−
            if (actions.at(i) == action) {+
−
                newOffset = topScroll - saccum;+
−
                break;+
−
            }+
−
            saccum += actionRects.at(i).height();+
−
        }+
−
    } else {+
−
        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);+
−
                else+
−
                    newOffset = (q->height() - botScroll) - saccum;+
−
                break;+
−
            }+
−
        }+
−
        if(newOffset)+
−
            newOffset -= fw * 2;+
−
    }+
−
+
−
    //figure out which scroll flags+
−
    uint newScrollFlags = QMenuScroller::ScrollNone;+
−
    if (newOffset < 0) //easy and cheap one+
−
        newScrollFlags |= QMenuScroller::ScrollUp;+
−
    int saccum = newOffset;+
−
    for(int i = 0; i < actionRects.count(); i++) {+
−
        saccum += actionRects.at(i).height();+
−
        if (saccum > q->height()) {+
−
            newScrollFlags |= QMenuScroller::ScrollDown;+
−
            break;+
−
        }+
−
    }+
−
+
−
    if (!(newScrollFlags & QMenuScroller::ScrollDown) && (scroll->scrollFlags & QMenuScroller::ScrollDown)) {+
−
        newOffset = q->height() - (saccum - newOffset) - fw*2 - vmargin;    //last item at bottom+
−
    }+
−
+
−
    if (!(newScrollFlags & QMenuScroller::ScrollUp) && (scroll->scrollFlags & QMenuScroller::ScrollUp)) {+
−
        newOffset = 0;  //first item at top+
−
    }+
−
+
−
    if (newScrollFlags & QMenuScroller::ScrollUp)+
−
        newOffset -= vmargin;+
−
+
−
    QRect screen = popupGeometry(q);+
−
    const int desktopFrame = q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q);+
−
    if (q->height() < screen.height()-(desktopFrame*2)-1) {+
−
        QRect geom = q->geometry();+
−
        if (newOffset > scroll->scrollOffset && (scroll->scrollFlags & newScrollFlags & QMenuScroller::ScrollUp)) { //scroll up+
−
            const int newHeight = geom.height()-(newOffset-scroll->scrollOffset);+
−
            if(newHeight > geom.height())+
−
                geom.setHeight(newHeight);+
−
        } else if(scroll->scrollFlags & newScrollFlags & QMenuScroller::ScrollDown) {+
−
            int newTop = geom.top() + (newOffset-scroll->scrollOffset);+
−
            if (newTop < desktopFrame+screen.top())+
−
                newTop = desktopFrame+screen.top();+
−
            if (newTop < geom.top()) {+
−
                geom.setTop(newTop);+
−
                newOffset = 0;+
−
                newScrollFlags &= ~QMenuScroller::ScrollUp;+
−
            }+
−
        }+
−
        if (geom.bottom() > screen.bottom() - desktopFrame)+
−
            geom.setBottom(screen.bottom() - desktopFrame);+
−
        if (geom.top() < desktopFrame+screen.top())+
−
            geom.setTop(desktopFrame+screen.top());+
−
        if (geom != q->geometry()) {+
−
#if 0+
−
            if (newScrollFlags & QMenuScroller::ScrollDown &&+
−
               q->geometry().top() - geom.top() >= -newOffset)+
−
                newScrollFlags &= ~QMenuScroller::ScrollDown;+
−
#endif+
−
            q->setGeometry(geom);+
−
        }+
−
    }+
−
+
−
    //actually update flags+
−
    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)+
−
        setCurrentAction(action);+
−
+
−
    q->update();     //issue an update so we see all the new state..+
−
}+
−
+
−
void QMenuPrivate::scrollMenu(QMenuScroller::ScrollLocation location, bool active)+
−
{+
−
    Q_Q(QMenu);+
−
    updateActionRects();+
−
    if(location == QMenuScroller::ScrollBottom) {+
−
        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)+
−
                 || act->isEnabled())) {+
−
                if(scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown)+
−
                    scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollBottom, active);+
−
                else if(active)+
−
                    setCurrentAction(act, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);+
−
                break;+
−
            }+
−
        }+
−
    } else if(location == QMenuScroller::ScrollTop) {+
−
        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)+
−
                 || act->isEnabled())) {+
−
                if(scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)+
−
                    scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollTop, active);+
−
                else if(active)+
−
                    setCurrentAction(act, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);+
−
                break;+
−
            }+
−
        }+
−
    }+
−
}+
−
+
−
//only directional+
−
void QMenuPrivate::scrollMenu(QMenuScroller::ScrollDirection direction, bool page, bool active)+
−
{+
−
    Q_Q(QMenu);+
−
    if (!scroll || !(scroll->scrollFlags & direction)) //not really possible...+
−
        return;+
−
    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 < actions.count(); i++) {+
−
            saccum -= actionRects.at(i).height();+
−
            if (saccum <= scroll->scrollOffset-offset) {+
−
                scrollMenu(actions.at(i), page ? QMenuScroller::ScrollBottom : QMenuScroller::ScrollTop, active);+
−
                break;+
−
            }+
−
        }+
−
    } else if (direction == QMenuScroller::ScrollDown) {+
−
        bool scrolled = false;+
−
        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 < actions.count(); i++) {+
−
                    visible += actionRects.at(i).height();+
−
                    if (visible > scrollerArea - topScroll) {+
−
                        scrolled = true;+
−
                        scrollMenu(actions.at(i), page ? QMenuScroller::ScrollTop : QMenuScroller::ScrollBottom, active);+
−
                        break;+
−
                    }+
−
                }+
−
                break;+
−
            }+
−
        }+
−
        if(!scrolled) {+
−
            scroll->scrollFlags &= ~QMenuScroller::ScrollDown;+
−
            q->update();+
−
        }+
−
    }+
−
}+
−
+
−
/* This is poor-mans eventfilters. This avoids the use of+
−
   eventFilter (which can be nasty for users of QMenuBar's). */+
−
bool QMenuPrivate::mouseEventTaken(QMouseEvent *e)+
−
{+
−
    Q_Q(QMenu);+
−
    QPoint pos = q->mapFromGlobal(e->globalPos());+
−
    if (scroll && !activeMenu) { //let the scroller "steal" the event+
−
        bool isScroll = false;+
−
        if (pos.x() >= 0 && pos.x() < q->width()) {+
−
            for(int dir = QMenuScroller::ScrollUp; dir <= QMenuScroller::ScrollDown; dir = dir << 1) {+
−
                if (scroll->scrollFlags & dir) {+
−
                    if (dir == QMenuScroller::ScrollUp)+
−
                        isScroll = (pos.y() <= scrollerHeight());+
−
                    else if (dir == QMenuScroller::ScrollDown)+
−
                        isScroll = (pos.y() >= q->height() - scrollerHeight());+
−
                    if (isScroll) {+
−
                        scroll->scrollDirection = dir;+
−
                        break;+
−
                    }+
−
                }+
−
            }+
−
        }+
−
        if (isScroll) {+
−
            scroll->scrollTimer.start(50, q);+
−
            return true;+
−
        } else {+
−
            scroll->scrollTimer.stop();+
−
        }+
−
    }+
−
+
−
    if (tearoff) { //let the tear off thingie "steal" the event..+
−
        QRect tearRect(0, 0, q->width(), q->style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, q));+
−
        if (scroll && scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)+
−
            tearRect.translate(0, scrollerHeight());+
−
        q->update(tearRect);+
−
        if (tearRect.contains(pos) && hasMouseMoved(e->globalPos())) {+
−
            setCurrentAction(0);+
−
            tearoffHighlighted = 1;+
−
            if (e->type() == QEvent::MouseButtonRelease) {+
−
                if (!tornPopup)+
−
                    tornPopup = new QTornOffMenu(q);+
−
                tornPopup->setGeometry(q->geometry());+
−
                tornPopup->show();+
−
                hideUpToMenuBar();+
−
            }+
−
            return true;+
−
        }+
−
        tearoffHighlighted = 0;+
−
    }+
−
+
−
    if (q->frameGeometry().contains(e->globalPos())) //otherwise if the event is in our rect we want it..+
−
        return false;+
−
+
−
    for(QWidget *caused = causedPopup.widget; caused;) {+
−
        bool passOnEvent = false;+
−
        QWidget *next_widget = 0;+
−
        QPoint cpos = caused->mapFromGlobal(e->globalPos());+
−
#ifndef QT_NO_MENUBAR+
−
        if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) {+
−
            passOnEvent = mb->rect().contains(cpos);+
−
        } else+
−
#endif+
−
        if (QMenu *m = qobject_cast<QMenu*>(caused)) {+
−
            passOnEvent = m->rect().contains(cpos);+
−
            next_widget = m->d_func()->causedPopup.widget;+
−
        }+
−
        if (passOnEvent) {+
−
            if(e->type() != QEvent::MouseButtonRelease || mouseDown == caused) {+
−
            QMouseEvent new_e(e->type(), cpos, e->button(), e->buttons(), e->modifiers());+
−
            QApplication::sendEvent(caused, &new_e);+
−
            return true;+
−
        }+
−
        }+
−
        if (!next_widget)+
−
            break;+
−
        caused = next_widget;+
−
    }+
−
    return false;+
−
}+
−
+
−
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)+
−
{+
−
    ExceptionGuard guard(&activationRecursionGuard);+
−
#ifdef QT3_SUPPORT+
−
    const int actionId = q_func()->findIdForAction(action);+
−
#endif+
−
    if(self)+
−
        action->activate(action_e);+
−
+
−
    for(int i = 0; i < causedStack.size(); ++i) {+
−
        QPointer<QWidget> widget = causedStack.at(i);+
−
        if (!widget)+
−
            continue;+
−
        //fire+
−
        if (QMenu *qmenu = qobject_cast<QMenu*>(widget)) {+
−
            widget = qmenu->d_func()->causedPopup.widget;+
−
            if (action_e == QAction::Trigger) {+
−
                emit qmenu->triggered(action);+
−
           } else if (action_e == QAction::Hover) {+
−
                emit qmenu->hovered(action);+
−
#ifdef QT3_SUPPORT+
−
                if (emitHighlighted) {+
−
                    emit qmenu->highlighted(actionId);+
−
                    emitHighlighted = false;+
−
                }+
−
#endif+
−
            }+
−
#ifndef QT_NO_MENUBAR+
−
        } else if (QMenuBar *qmenubar = qobject_cast<QMenuBar*>(widget)) {+
−
            if (action_e == QAction::Trigger) {+
−
                emit qmenubar->triggered(action);+
−
#ifdef QT3_SUPPORT+
−
                emit qmenubar->activated(actionId);+
−
#endif+
−
            } else if (action_e == QAction::Hover) {+
−
                emit qmenubar->hovered(action);+
−
#ifdef QT3_SUPPORT+
−
                if (emitHighlighted) {+
−
                    emit qmenubar->highlighted(actionId);+
−
                    emitHighlighted = false;+
−
                }+
−
#endif+
−
            }+
−
            break; //nothing more..+
−
#endif+
−
        }+
−
    }+
−
}+
−
+
−
void QMenuPrivate::activateAction(QAction *action, QAction::ActionEvent action_e, bool self)+
−
{+
−
    Q_Q(QMenu);+
−
#ifndef QT_NO_WHATSTHIS+
−
    bool inWhatsThisMode = QWhatsThis::inWhatsThisMode();+
−
#endif+
−
    if (!action || !q->isEnabled()+
−
        || (action_e == QAction::Trigger+
−
#ifndef QT_NO_WHATSTHIS+
−
            && !inWhatsThisMode+
−
#endif+
−
            && (action->isSeparator() ||!action->isEnabled())))+
−
        return;+
−
+
−
    /* I have to save the caused stack here because it will be undone after popup execution (ie in the hide).+
−
       Then I iterate over the list to actually send the events. --Sam+
−
    */+
−
    const QList<QPointer<QWidget> > causedStack = calcCausedStack();+
−
    if (action_e == QAction::Trigger) {+
−
#ifndef QT_NO_WHATSTHIS+
−
        if (!inWhatsThisMode)+
−
            actionAboutToTrigger = action;+
−
#endif+
−
+
−
        if (q->testAttribute(Qt::WA_DontShowOnScreen)) {+
−
            hideUpToMenuBar();+
−
        } else {+
−
            for(QWidget *widget = QApplication::activePopupWidget(); widget; ) {+
−
                if (QMenu *qmenu = qobject_cast<QMenu*>(widget)) {+
−
                    if(qmenu == q)+
−
                        hideUpToMenuBar();+
−
                    widget = qmenu->d_func()->causedPopup.widget;+
−
                } else {+
−
                    break;+
−
                }+
−
            }+
−
        }+
−
+
−
#ifndef QT_NO_WHATSTHIS+
−
        if (inWhatsThisMode) {+
−
            QString s = action->whatsThis();+
−
            if (s.isEmpty())+
−
                s = whatsThis;+
−
            QWhatsThis::showText(q->mapToGlobal(actionRect(action).center()), s, q);+
−
            return;+
−
        }+
−
#endif+
−
    }+
−
+
−
+
−
    activateCausedStack(causedStack, action, action_e, self);+
−
+
−
+
−
    if (action_e == QAction::Hover) {+
−
#ifndef QT_NO_ACCESSIBILITY+
−
        if (QAccessible::isActive()) {+
−
            int actionIndex = indexOf(action) + 1;+
−
            QAccessible::updateAccessibility(q, actionIndex, QAccessible::Focus);+
−
            QAccessible::updateAccessibility(q, actionIndex, QAccessible::Selection);+
−
        }+
−
#endif+
−
        action->showStatusText(topCausedWidget());+
−
    } else {+
−
        actionAboutToTrigger = 0;+
−
    }+
−
}+
−
+
−
void QMenuPrivate::_q_actionTriggered()+
−
{+
−
    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+
−
        const int id = q->findIdForAction(action);+
−
#endif+
−
        emit q->triggered(action);+
−
#ifdef QT3_SUPPORT+
−
        emit q->activated(id);+
−
#endif+
−
+
−
        if (!activationRecursionGuard && actionGuard) {+
−
            //in case the action has not been activated by the mouse+
−
            //we check the parent hierarchy+
−
            QList< QPointer<QWidget> > list;+
−
            for(QWidget *widget = q->parentWidget(); widget; ) {+
−
                if (qobject_cast<QMenu*>(widget)+
−
#ifndef QT_NO_MENUBAR+
−
                    || qobject_cast<QMenuBar*>(widget)+
−
#endif+
−
                    ) {+
−
                    list.append(widget);+
−
                    widget = widget->parentWidget();+
−
                } else {+
−
                    break;+
−
                }+
−
            }+
−
            activateCausedStack(list, action, QAction::Trigger, false);+
−
        }+
−
    }+
−
}+
−
+
−
void QMenuPrivate::_q_actionHovered()+
−
{+
−
    Q_Q(QMenu);+
−
    if (QAction * action = qobject_cast<QAction *>(q->sender())) {+
−
#ifdef QT3_SUPPORT+
−
        //we store it here because the action might be deleted/changed by connected slots+
−
        const int id = q->findIdForAction(action);+
−
#endif+
−
        emit q->hovered(action);+
−
#ifdef QT3_SUPPORT+
−
        if (emitHighlighted) {+
−
            emit q->highlighted(id);+
−
            emitHighlighted = false;+
−
        }+
−
#endif+
−
    }+
−
}+
−
+
−
bool QMenuPrivate::hasMouseMoved(const QPoint &globalPos)+
−
{+
−
    //determines if the mouse has moved (ie its intial position has+
−
    //changed by more than QApplication::startDragDistance()+
−
    //or if there were at least 6 mouse motions)+
−
    return motions > 6 ||+
−
        QApplication::startDragDistance() < (mousePopupPos - globalPos).manhattanLength();+
−
}+
−
+
−
+
−
/*!+
−
    Initialize \a option with the values from this menu and information from \a action. This method+
−
    is useful for subclasses when they need a QStyleOptionMenuItem, but don't want+
−
    to fill in all the information themselves.+
−
+
−
    \sa QStyleOption::initFrom() QMenuBar::initStyleOption()+
−
*/+
−
void QMenu::initStyleOption(QStyleOptionMenuItem *option, const QAction *action) const+
−
{+
−
    if (!option || !action)+
−
        return;+
−
+
−
    Q_D(const QMenu);+
−
    option->initFrom(this);+
−
    option->palette = palette();+
−
    option->state = QStyle::State_None;+
−
+
−
    if (window()->isActiveWindow())+
−
        option->state |= QStyle::State_Active;+
−
    if (isEnabled() && action->isEnabled()+
−
            && (!action->menu() || action->menu()->isEnabled()))+
−
        option->state |= QStyle::State_Enabled;+
−
    else+
−
        option->palette.setCurrentColorGroup(QPalette::Disabled);+
−
+
−
    option->font = action->font().resolve(font());+
−
    option->fontMetrics = QFontMetrics(option->font);+
−
+
−
    if (d->currentAction && d->currentAction == action && !d->currentAction->isSeparator()) {+
−
        option->state |= QStyle::State_Selected+
−
                     | (d->mouseDown ? QStyle::State_Sunken : QStyle::State_None);+
−
    }+
−
+
−
    option->menuHasCheckableItems = d->hasCheckableItems;+
−
    if (!action->isCheckable()) {+
−
        option->checkType = QStyleOptionMenuItem::NotCheckable;+
−
    } else {+
−
        option->checkType = (action->actionGroup() && action->actionGroup()->isExclusive())+
−
                            ? QStyleOptionMenuItem::Exclusive : QStyleOptionMenuItem::NonExclusive;+
−
        option->checked = action->isChecked();+
−
    }+
−
    if (action->menu())+
−
        option->menuItemType = QStyleOptionMenuItem::SubMenu;+
−
    else if (action->isSeparator())+
−
        option->menuItemType = QStyleOptionMenuItem::Separator;+
−
    else if (d->defaultAction == action)+
−
        option->menuItemType = QStyleOptionMenuItem::DefaultItem;+
−
    else+
−
        option->menuItemType = QStyleOptionMenuItem::Normal;+
−
    if (action->isIconVisibleInMenu())+
−
        option->icon = action->icon();+
−
    QString textAndAccel = action->text();+
−
#ifndef QT_NO_SHORTCUT+
−
    if (textAndAccel.indexOf(QLatin1Char('\t')) == -1) {+
−
        QKeySequence seq = action->shortcut();+
−
        if (!seq.isEmpty())+
−
            textAndAccel += QLatin1Char('\t') + QString(seq);+
−
    }+
−
#endif+
−
    option->text = textAndAccel;+
−
    option->tabWidth = d->tabWidth;+
−
    option->maxIconWidth = d->maxIconWidth;+
−
    option->menuRect = rect();+
−
}+
−
+
−
/*!+
−
    \class QMenu+
−
    \brief The QMenu class provides a menu widget for use in menu+
−
    bars, context menus, and other popup menus.+
−
+
−
    \ingroup mainwindow-classes+
−
    \ingroup basicwidgets+
−
+
−
+
−
    A menu widget is a selection menu. It can be either a pull-down+
−
    menu in a menu bar or a standalone context menu. Pull-down menus+
−
    are shown by the menu bar when the user clicks on the respective+
−
    item or presses the specified shortcut key. Use+
−
    QMenuBar::addMenu() to insert a menu into a menu bar. Context+
−
    menus are usually invoked by some special keyboard key or by+
−
    right-clicking. They can be executed either asynchronously with+
−
    popup() or synchronously with exec(). Menus can also be invoked in+
−
    response to button presses; these are just like context menus+
−
    except for how they are invoked.+
−
+
−
    \raw HTML+
−
    <table align="center" cellpadding="0">+
−
    <tr>+
−
        <td>+
−
            \endraw+
−
            \inlineimage plastique-menu.png+
−
            \raw HTML+
−
        </td>+
−
        <td>+
−
            \endraw+
−
            \inlineimage windowsxp-menu.png+
−
            \raw HTML+
−
        </td>+
−
        <td>+
−
            \endraw+
−
            \inlineimage macintosh-menu.png+
−
            \raw HTML+
−
        </td>+
−
+
−
    </tr>+
−
    <tr>+
−
        <td colspan="3">+
−
           \endraw+
−
           A menu shown in \l{Plastique Style Widget Gallery}{Plastique widget style},+
−
           \l{Windows XP Style Widget Gallery}{Windows XP widget style},+
−
           and \l{Macintosh Style Widget Gallery}{Macintosh widget style}.+
−
           \raw HTML+
−
        </td>+
−
    </tr>+
−
    </table>+
−
    \endraw+
−
+
−
    \section1 Actions+
−
+
−
    A menu consists of a list of action items. Actions are added with+
−
    the addAction(), addActions() and insertAction() functions. An action+
−
    is represented vertically and rendered by QStyle. In addition, actions+
−
    can have a text label, an optional icon drawn on the very left side,+
−
    and shortcut key sequence such as "Ctrl+X".+
−
+
−
    The existing actions held by a menu can be found with actions().+
−
+
−
    There are four kinds of action items: separators, actions that+
−
    show a submenu, widgets, and actions that perform an action.+
−
    Separators are inserted with addSeparator(), submenus with addMenu(),+
−
    and all other items are considered action items.+
−
+
−
    When inserting action items you usually specify a receiver and a+
−
    slot. The receiver will be notifed whenever the item is+
−
    \l{QAction::triggered()}{triggered()}. In addition, QMenu provides+
−
    two signals, activated() and highlighted(), which signal the+
−
    QAction that was triggered from the menu.+
−
+
−
    You clear a menu with clear() and remove individual action items+
−
    with removeAction().+
−
+
−
    A QMenu can also provide a tear-off menu. A tear-off menu is a+
−
    top-level window that contains a copy of the menu. This makes it+
−
    possible for the user to "tear off" frequently used menus and+
−
    position them in a convenient place on the screen. If you want+
−
    this functionality for a particular menu, insert a tear-off handle+
−
    with setTearOffEnabled(). When using tear-off menus, bear in mind+
−
    that the concept isn't typically used on Microsoft Windows so+
−
    some users may not be familiar with it. Consider using a QToolBar+
−
    instead.+
−
+
−
    Widgets can be inserted into menus with the QWidgetAction class.+
−
    Instances of this class are used to hold widgets, and are inserted+
−
    into menus with the addAction() overload that takes a QAction.+
−
+
−
    Conversely, actions can be added to widgets with the addAction(),+
−
    addActions() and insertAction() functions.+
−
+
−
    \section1 QMenu on Qt for Windows CE+
−
+
−
    If a menu is integrated into the native menubar on Windows Mobile we+
−
    do not support the signals: aboutToHide (), aboutToShow () and hovered ().+
−
    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.+
−
+
−
    \bold{Important inherited functions:} addAction(), removeAction(), clear(),+
−
    addSeparator(), and addMenu().+
−
+
−
    \sa QMenuBar, {fowler}{GUI Design Handbook: Menu, Drop-Down and Pop-Up},+
−
        {Application Example}, {Menus Example}, {Recent Files Example}+
−
*/+
−
+
−
+
−
/*!+
−
    Constructs a menu with parent \a parent.+
−
+
−
    Although a popup menu is always a top-level widget, if a parent is+
−
    passed the popup menu will be deleted when that parent is+
−
    destroyed (as with any other QObject).+
−
*/+
−
QMenu::QMenu(QWidget *parent)+
−
    : QWidget(*new QMenuPrivate, parent, Qt::Popup)+
−
{+
−
    Q_D(QMenu);+
−
    d->init();+
−
}+
−
+
−
/*!+
−
    Constructs a menu with a \a title and a \a parent.+
−
+
−
    Although a popup menu is always a top-level widget, if a parent is+
−
    passed the popup menu will be deleted when that parent is+
−
    destroyed (as with any other QObject).+
−
+
−
    \sa title+
−
*/+
−
QMenu::QMenu(const QString &title, QWidget *parent)+
−
    : QWidget(*new QMenuPrivate, parent, Qt::Popup)+
−
{+
−
    Q_D(QMenu);+
−
    d->init();+
−
    d->menuAction->setText(title);+
−
}+
−
+
−
/*! \internal+
−
 */+
−
QMenu::QMenu(QMenuPrivate &dd, QWidget *parent)+
−
    : QWidget(dd, parent, Qt::Popup)+
−
{+
−
    Q_D(QMenu);+
−
    d->init();+
−
}+
−
+
−
/*!+
−
    Destroys the menu.+
−
*/+
−
QMenu::~QMenu()+
−
{+
−
    Q_D(QMenu);+
−
    if (!d->widgetItems.isEmpty()) {  // avoid detach on shared null hash+
−
        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);+
−
                *it = 0;+
−
            }+
−
        }+
−
    }+
−
+
−
    if (d->eventLoop)+
−
        d->eventLoop->exit();+
−
    hideTearOffMenu();+
−
}+
−
+
−
/*!+
−
    \overload+
−
+
−
    This convenience function creates a new action with \a text.+
−
    The function adds the newly created action to the menu's+
−
    list of actions, and returns it.+
−
+
−
    \sa QWidget::addAction()+
−
*/+
−
QAction *QMenu::addAction(const QString &text)+
−
{+
−
    QAction *ret = new QAction(text, this);+
−
    addAction(ret);+
−
    return ret;+
−
}+
−
+
−
/*!+
−
    \overload+
−
+
−
    This convenience function creates a new action with an \a icon+
−
    and some \a text. The function adds the newly created action to+
−
    the menu's list of actions, and returns it.+
−
+
−
    \sa QWidget::addAction()+
−
*/+
−
QAction *QMenu::addAction(const QIcon &icon, const QString &text)+
−
{+
−
    QAction *ret = new QAction(icon, text, this);+
−
    addAction(ret);+
−
    return ret;+
−
}+
−
+
−
/*!+
−
    \overload+
−
+
−
    This convenience function creates a new action with the text \a+
−
    text and an optional shortcut \a shortcut. The action's+
−
    \l{QAction::triggered()}{triggered()} signal is connected to the+
−
    \a receiver's \a member slot. The function adds the newly created+
−
    action to the menu's list of actions and returns it.+
−
+
−
    \sa QWidget::addAction()+
−
*/+
−
QAction *QMenu::addAction(const QString &text, const QObject *receiver, const char* member, const QKeySequence &shortcut)+
−
{+
−
    QAction *action = new QAction(text, this);+
−
#ifdef QT_NO_SHORTCUT+
−
    Q_UNUSED(shortcut);+
−
#else+
−
    action->setShortcut(shortcut);+
−
#endif+
−
    QObject::connect(action, SIGNAL(triggered(bool)), receiver, member);+
−
    addAction(action);+
−
    return action;+
−
}+
−
+
−
/*!+
−
    \overload+
−
+
−
    This convenience function creates a new action with an \a icon and+
−
    some \a text and an optional shortcut \a shortcut. The action's+
−
    \l{QAction::triggered()}{triggered()} signal is connected to the+
−
    \a member slot of the \a receiver object. The function adds the+
−
    newly created action to the menu's list of actions, and returns it.+
−
+
−
    \sa QWidget::addAction()+
−
*/+
−
QAction *QMenu::addAction(const QIcon &icon, const QString &text, const QObject *receiver,+
−
                          const char* member, const QKeySequence &shortcut)+
−
{+
−
    QAction *action = new QAction(icon, text, this);+
−
#ifdef QT_NO_SHORTCUT+
−
    Q_UNUSED(shortcut);+
−
#else+
−
    action->setShortcut(shortcut);+
−
#endif+
−
    QObject::connect(action, SIGNAL(triggered(bool)), receiver, member);+
−
    addAction(action);+
−
    return action;+
−
}+
−
+
−
/*!+
−
    This convenience function adds \a menu as a submenu to this menu.+
−
    It returns \a menu's menuAction(). This menu does not take+
−
    ownership of \a menu.+
−
+
−
    \sa QWidget::addAction() QMenu::menuAction()+
−
*/+
−
QAction *QMenu::addMenu(QMenu *menu)+
−
{+
−
    QAction *action = menu->menuAction();+
−
    addAction(action);+
−
    return action;+
−
}+
−
+
−
/*!+
−
  Appends a new QMenu with \a title to the menu. The menu+
−
  takes ownership of the menu. Returns the new menu.+
−
+
−
  \sa QWidget::addAction() QMenu::menuAction()+
−
*/+
−
QMenu *QMenu::addMenu(const QString &title)+
−
{+
−
    QMenu *menu = new QMenu(title, this);+
−
    addAction(menu->menuAction());+
−
    return menu;+
−
}+
−
+
−
/*!+
−
  Appends a new QMenu with \a icon and \a title to the menu. The menu+
−
  takes ownership of the menu. Returns the new menu.+
−
+
−
  \sa QWidget::addAction() QMenu::menuAction()+
−
*/+
−
QMenu *QMenu::addMenu(const QIcon &icon, const QString &title)+
−
{+
−
    QMenu *menu = new QMenu(title, this);+
−
    menu->setIcon(icon);+
−
    addAction(menu->menuAction());+
−
    return menu;+
−
}+
−
+
−
/*!+
−
    This convenience function creates a new separator action, i.e. an+
−
    action with QAction::isSeparator() returning true, and adds the new+
−
    action to this menu's list of actions. It returns the newly+
−
    created action.+
−
+
−
    \sa QWidget::addAction()+
−
*/+
−
QAction *QMenu::addSeparator()+
−
{+
−
    QAction *action = new QAction(this);+
−
    action->setSeparator(true);+
−
    addAction(action);+
−
    return action;+
−
}+
−
+
−
/*!+
−
    This convenience function inserts \a menu before action \a before+
−
    and returns the menus menuAction().+
−
+
−
    \sa QWidget::insertAction(), addMenu()+
−
*/+
−
QAction *QMenu::insertMenu(QAction *before, QMenu *menu)+
−
{+
−
    QAction *action = menu->menuAction();+
−
    insertAction(before, action);+
−
    return action;+
−
}+
−
+
−
/*!+
−
    This convenience function creates a new separator action, i.e. an+
−
    action with QAction::isSeparator() returning true. The function inserts+
−
    the newly created action into this menu's list of actions before+
−
    action \a before and returns it.+
−
+
−
    \sa QWidget::insertAction(), addSeparator()+
−
*/+
−
QAction *QMenu::insertSeparator(QAction *before)+
−
{+
−
    QAction *action = new QAction(this);+
−
    action->setSeparator(true);+
−
    insertAction(before, action);+
−
    return action;+
−
}+
−
+
−
/*!+
−
  This sets the default action to \a act. The default action may have+
−
  a visual cue, depending on the current QStyle. A default action+
−
  usually indicates what will happen by default when a drop occurs.+
−
+
−
  \sa defaultAction()+
−
*/+
−
void QMenu::setDefaultAction(QAction *act)+
−
{+
−
    d_func()->defaultAction = act;+
−
}+
−
+
−
/*!+
−
  Returns the current default action.+
−
+
−
  \sa setDefaultAction()+
−
*/+
−
QAction *QMenu::defaultAction() const+
−
{+
−
    return d_func()->defaultAction;+
−
}+
−
+
−
/*!+
−
    \property QMenu::tearOffEnabled+
−
    \brief whether the menu supports being torn off+
−
+
−
    When true, the menu contains a special tear-off item (often shown as a dashed+
−
    line at the top of the menu) that creates a copy of the menu when it is+
−
    triggered.+
−
+
−
    This "torn-off" copy lives in a separate window. It contains the same menu+
−
    items as the original menu, with the exception of the tear-off handle.+
−
+
−
    By default, this property is false.+
−
*/+
−
void QMenu::setTearOffEnabled(bool b)+
−
{+
−
    Q_D(QMenu);+
−
    if (d->tearoff == b)+
−
        return;+
−
    if (!b)+
−
        hideTearOffMenu();+
−
    d->tearoff = b;+
−
+
−
    d->itemsDirty = true;+
−
    if (isVisible())+
−
        resize(sizeHint());+
−
}+
−
+
−
bool QMenu::isTearOffEnabled() const+
−
{+
−
    return d_func()->tearoff;+
−
}+
−
+
−
/*!+
−
  When a menu is torn off a second menu is shown to display the menu+
−
  contents in a new window. When the menu is in this mode and the menu+
−
  is visible returns true; otherwise false.+
−
+
−
  \sa hideTearOffMenu() isTearOffEnabled()+
−
*/+
−
bool QMenu::isTearOffMenuVisible() const+
−
{+
−
    if (d_func()->tornPopup)+
−
        return d_func()->tornPopup->isVisible();+
−
    return false;+
−
}+
−
+
−
/*!+
−
   This function will forcibly hide the torn off menu making it+
−
   disappear from the users desktop.+
−
+
−
   \sa isTearOffMenuVisible() isTearOffEnabled()+
−
*/+
−
void QMenu::hideTearOffMenu()+
−
{+
−
    if (QWidget *w = d_func()->tornPopup)+
−
        w->close();+
−
}+
−
+
−
+
−
/*!+
−
  Sets the currently highlighted action to \a act.+
−
*/+
−
void QMenu::setActiveAction(QAction *act)+
−
{+
−
    Q_D(QMenu);+
−
    d->setCurrentAction(act, 0);+
−
    if (d->scroll)+
−
        d->scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollCenter);+
−
}+
−
+
−
+
−
/*!+
−
    Returns the currently highlighted action, or 0 if no+
−
    action is currently highlighted.+
−
*/+
−
QAction *QMenu::activeAction() const+
−
{+
−
    return d_func()->currentAction;+
−
}+
−
+
−
/*!+
−
    \since 4.2+
−
+
−
    Returns true if there are no visible actions inserted into the menu, false+
−
    otherwise.+
−
+
−
    \sa QWidget::actions()+
−
*/+
−
+
−
bool QMenu::isEmpty() const+
−
{+
−
    bool ret = true;+
−
    for(int i = 0; ret && i < actions().count(); ++i) {+
−
        const QAction *action = actions().at(i);+
−
        if (!action->isSeparator() && action->isVisible()) {+
−
            ret = false;+
−
        }+
−
    }+
−
    return ret;+
−
}+
−
+
−
/*!+
−
    Removes all the menu's actions. Actions owned by the menu and not+
−
    shown in any other widget are deleted.+
−
+
−
    \sa removeAction()+
−
*/+
−
void QMenu::clear()+
−
{+
−
    QList<QAction*> acts = actions();+
−
+
−
    for(int i = 0; i < acts.size(); i++) {+
−
#ifdef QT_SOFTKEYS_ENABLED+
−
        Q_D(QMenu);+
−
        // Lets not touch to our internal softkey actions+
−
        if(acts[i] == d->selectAction || acts[i] == d->cancelAction)+
−
            continue;+
−
#endif+
−
        removeAction(acts[i]);+
−
        if (acts[i]->parent() == this && acts[i]->d_func()->widgets.isEmpty())+
−
            delete acts[i];+
−
    }+
−
}+
−
+
−
/*!+
−
  If a menu does not fit on the screen it lays itself out so that it+
−
  does fit. It is style dependent what layout means (for example, on+
−
  Windows it will use multiple columns).+
−
+
−
  This functions returns the number of columns necessary.+
−
*/+
−
int QMenu::columnCount() const+
−
{+
−
    return d_func()->ncols;+
−
}+
−
+
−
/*!+
−
  Returns the item at \a pt; returns 0 if there is no item there.+
−
*/+
−
QAction *QMenu::actionAt(const QPoint &pt) const+
−
{+
−
    if (QAction *ret = d_func()->actionAt(pt))+
−
        return ret;+
−
    return 0;+
−
}+
−
+
−
/*!+
−
  Returns the geometry of action \a act.+
−
*/+
−
QRect QMenu::actionGeometry(QAction *act) const+
−
{+
−
    return d_func()->actionRect(act);+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
QSize QMenu::sizeHint() const+
−
{+
−
    Q_D(const QMenu);+
−
    d->updateActionRects();+
−
+
−
    QSize s;+
−
    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.+
−
    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,+
−
                                    s.expandedTo(QApplication::globalStrut()), this);+
−
}+
−
+
−
/*!+
−
    Displays the menu so that the action \a atAction will be at the+
−
    specified \e global position \a p. To translate a widget's local+
−
    coordinates into global coordinates, use QWidget::mapToGlobal().+
−
+
−
    When positioning a menu with exec() or popup(), bear in mind that+
−
    you cannot rely on the menu's current size(). For performance+
−
    reasons, the menu adapts its size only when necessary, so in many+
−
    cases, the size before and after the show is different. Instead,+
−
    use sizeHint() which calculates the proper size depending on the+
−
    menu's current contents.+
−
+
−
    \sa QWidget::mapToGlobal(), exec()+
−
*/+
−
void QMenu::popup(const QPoint &p, QAction *atAction)+
−
{+
−
    Q_D(QMenu);+
−
    if (d->scroll) { //reset scroll state from last popup+
−
        d->scroll->scrollOffset = 0;+
−
        d->scroll->scrollFlags = QMenuPrivate::QMenuScroller::ScrollNone;+
−
    }+
−
    d->tearoffHighlighted = 0;+
−
    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+
−
    setAttribute(Qt::WA_X11NetWmWindowTypeDropDownMenu, qobject_cast<QMenuBar *>(d->topCausedWidget()) != 0);+
−
#endif+
−
+
−
    ensurePolished(); // Get the right font+
−
    emit aboutToShow();+
−
    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;+
−
#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 < d->actions.count(); i++) {+
−
            QAction *action = d->actions.at(i);+
−
            if (action == atAction) {+
−
                int newY = pos.y() - above_height;+
−
                if (d->scroll && newY < desktopFrame) {+
−
                    d->scroll->scrollFlags = d->scroll->scrollFlags+
−
                                             | QMenuPrivate::QMenuScroller::ScrollUp;+
−
                    d->scroll->scrollOffset = newY;+
−
                    newY = desktopFrame;+
−
                }+
−
                pos.setY(newY);+
−
+
−
                if (d->scroll && d->scroll->scrollFlags != QMenuPrivate::QMenuScroller::ScrollNone+
−
                    && !style()->styleHint(QStyle::SH_Menu_FillScreenWithScroll, 0, this)) {+
−
                    int below_height = above_height + d->scroll->scrollOffset;+
−
                    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.at(i).height();+
−
            }+
−
        }+
−
    }+
−
+
−
    QPoint mouse = QCursor::pos();+
−
    d->mousePopupPos = mouse;+
−
    const bool snapToMouse = (QRect(p.x()-3, p.y()-3, 6, 6).contains(mouse));+
−
+
−
    if (adjustToDesktop) {+
−
        //handle popup falling "off screen"+
−
        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)+
−
                pos.setX(qMax(p.x(), screen.left()+desktopFrame));+
−
            if (pos.x()+size.width()-1 > screen.right()-desktopFrame)+
−
                pos.setX(qMax(p.x()-size.width(), screen.right()-desktopFrame-size.width()+1));+
−
        } else {+
−
            if (pos.x()+size.width()-1 > screen.right()-desktopFrame)+
−
                pos.setX(screen.right()-desktopFrame-size.width()+1);+
−
            if (pos.x() < screen.left()+desktopFrame)+
−
                pos.setX(screen.left() + desktopFrame);+
−
        }+
−
        if (pos.y() + size.height() - 1 > screen.bottom() - desktopFrame) {+
−
            if(snapToMouse)+
−
                pos.setY(qMin(mouse.y() - (size.height() + desktopFrame), screen.bottom()-desktopFrame-size.height()+1));+
−
            else+
−
                pos.setY(qMax(p.y() - (size.height() + desktopFrame), screen.bottom()-desktopFrame-size.height()+1));+
−
        } else if (pos.y() < screen.top() + desktopFrame) {+
−
            pos.setY(screen.top() + desktopFrame);+
−
        }+
−
+
−
        if (pos.y() < screen.top() + desktopFrame)+
−
            pos.setY(screen.top() + desktopFrame);+
−
        if (pos.y()+size.height()-1 > screen.bottom() - desktopFrame) {+
−
            if (d->scroll) {+
−
                d->scroll->scrollFlags |= uint(QMenuPrivate::QMenuScroller::ScrollDown);+
−
                int y = qMax(screen.y(),pos.y());+
−
                size.setHeight(screen.bottom()-(desktopFrame*2)-y);+
−
            } else {+
−
                // Too big for screen, bias to see bottom of menu (for some reason)+
−
                pos.setY(screen.bottom()-size.height()+1);+
−
            }+
−
        }+
−
    }+
−
    setGeometry(QRect(pos, size));+
−
#ifndef QT_NO_EFFECTS+
−
    int hGuess = isRightToLeft() ? QEffects::LeftScroll : QEffects::RightScroll;+
−
    int vGuess = QEffects::DownScroll;+
−
    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()))+
−
            hGuess = QEffects::RightScroll;+
−
    } else {+
−
        if ((snapToMouse && (pos.x() + size.width()/2 < mouse.x())) ||+
−
           (qobject_cast<QMenu*>(d->causedPopup.widget) && pos.x() + size.width()/2 < d->causedPopup.widget->x()))+
−
            hGuess = QEffects::LeftScroll;+
−
    }+
−
+
−
#ifndef QT_NO_MENUBAR+
−
    if ((snapToMouse && (pos.y() + size.height()/2 < mouse.y())) ||+
−
       (qobject_cast<QMenuBar*>(d->causedPopup.widget) &&+
−
        pos.y() + size.width()/2 < d->causedPopup.widget->mapToGlobal(d->causedPopup.widget->pos()).y()))+
−
       vGuess = QEffects::UpScroll;+
−
#endif+
−
    if (QApplication::isEffectEnabled(Qt::UI_AnimateMenu)) {+
−
        bool doChildEffects = true;+
−
#ifndef QT_NO_MENUBAR+
−
        if (QMenuBar *mb = qobject_cast<QMenuBar*>(d->causedPopup.widget)) {+
−
            doChildEffects = mb->d_func()->doChildEffects;+
−
            mb->d_func()->doChildEffects = false;+
−
        } else+
−
#endif+
−
        if (QMenu *m = qobject_cast<QMenu*>(d->causedPopup.widget)) {+
−
            doChildEffects = m->d_func()->doChildEffects;+
−
            m->d_func()->doChildEffects = false;+
−
        }+
−
+
−
        if (doChildEffects) {+
−
            if (QApplication::isEffectEnabled(Qt::UI_FadeMenu))+
−
                qFadeEffect(this);+
−
            else if (d->causedPopup.widget)+
−
                qScrollEffect(this, qobject_cast<QMenu*>(d->causedPopup.widget) ? hGuess : vGuess);+
−
            else+
−
                qScrollEffect(this, hGuess | vGuess);+
−
        } else {+
−
            // kill any running effect+
−
            qFadeEffect(0);+
−
            qScrollEffect(0);+
−
+
−
            show();+
−
        }+
−
    } else+
−
#endif+
−
    {+
−
        show();+
−
    }+
−
+
−
#ifndef QT_NO_ACCESSIBILITY+
−
    QAccessible::updateAccessibility(this, 0, QAccessible::PopupMenuStart);+
−
#endif+
−
}+
−
+
−
/*!+
−
    Executes this menu synchronously.+
−
+
−
    This is equivalent to \c{exec(pos())}.+
−
+
−
    This returns the triggered QAction in either the popup menu or one+
−
    of its submenus, or 0 if no item was triggered (normally because+
−
    the user pressed Esc).+
−
+
−
    In most situations you'll want to specify the position yourself,+
−
    for example, the current mouse position:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 0+
−
    or aligned to a widget:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 1+
−
    or in reaction to a QMouseEvent *e:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 2+
−
*/+
−
QAction *QMenu::exec()+
−
{+
−
    return exec(pos());+
−
}+
−
+
−
+
−
/*!+
−
    \overload+
−
+
−
    Executes this menu synchronously.+
−
+
−
    Pops up the menu so that the action \a action will be at the+
−
    specified \e global position \a p. To translate a widget's local+
−
    coordinates into global coordinates, use QWidget::mapToGlobal().+
−
+
−
    This returns the triggered QAction in either the popup menu or one+
−
    of its submenus, or 0 if no item was triggered (normally because+
−
    the user pressed Esc).+
−
+
−
    Note that all signals are emitted as usual. If you connect a+
−
    QAction to a slot and call the menu's exec(), you get the result+
−
    both via the signal-slot connection and in the return value of+
−
    exec().+
−
+
−
    Common usage is to position the menu at the current mouse+
−
    position:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 3+
−
    or aligned to a widget:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 4+
−
    or in reaction to a QMouseEvent *e:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 5+
−
+
−
    When positioning a menu with exec() or popup(), bear in mind that+
−
    you cannot rely on the menu's current size(). For performance+
−
    reasons, the menu adapts its size only when necessary. So in many+
−
    cases, the size before and after the show is different. Instead,+
−
    use sizeHint() which calculates the proper size depending on the+
−
    menu's current contents.+
−
+
−
    \sa popup(), QWidget::mapToGlobal()+
−
*/+
−
QAction *QMenu::exec(const QPoint &p, QAction *action)+
−
{+
−
    Q_D(QMenu);+
−
    createWinId();+
−
    QEventLoop eventLoop;+
−
    d->eventLoop = &eventLoop;+
−
    popup(p, action);+
−
+
−
    QPointer<QObject> guard = this;+
−
    (void) eventLoop.exec();+
−
    if (guard.isNull())+
−
        return 0;+
−
+
−
    action = d->syncAction;+
−
    d->syncAction = 0;+
−
    d->eventLoop = 0;+
−
    return action;+
−
}+
−
+
−
/*!+
−
    \overload+
−
+
−
    Executes a menu synchronously.+
−
+
−
    The menu's actions are specified by the list of \a actions. The menu will+
−
    pop up so that the specified action, \a at, appears at global position \a+
−
    pos. If \a at is not specified then the menu appears at position \a+
−
    pos. \a parent is the menu's parent widget; specifying the parent will+
−
    provide context when \a pos alone is not enough to decide where the menu+
−
    should go (e.g., with multiple desktops or when the parent is embedded in+
−
    QGraphicsView).+
−
+
−
    The function returns the triggered QAction in either the popup+
−
    menu or one of its submenus, or 0 if no item was triggered+
−
    (normally because the user pressed Esc).+
−
+
−
    This is equivalent to:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 6+
−
+
−
    \sa popup(), QWidget::mapToGlobal()+
−
*/+
−
QAction *QMenu::exec(QList<QAction*> actions, const QPoint &pos, QAction *at, QWidget *parent)+
−
{+
−
    QMenu menu(parent);+
−
    menu.addActions(actions);+
−
    return menu.exec(pos, at);+
−
}+
−
+
−
/*!+
−
    \overload+
−
+
−
    Executes a menu synchronously.+
−
+
−
    The menu's actions are specified by the list of \a actions. The menu+
−
    will pop up so that the specified action, \a at, appears at global+
−
    position \a pos. If \a at is not specified then the menu appears+
−
    at position \a pos.+
−
+
−
    The function returns the triggered QAction in either the popup+
−
    menu or one of its submenus, or 0 if no item was triggered+
−
    (normally because the user pressed Esc).+
−
+
−
    This is equivalent to:+
−
    \snippet doc/src/snippets/code/src_gui_widgets_qmenu.cpp 6+
−
+
−
    \sa popup(), QWidget::mapToGlobal()+
−
*/+
−
QAction *QMenu::exec(QList<QAction*> actions, const QPoint &pos, QAction *at)+
−
{+
−
    // ### Qt 5: merge+
−
    return exec(actions, pos, at, 0);+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::hideEvent(QHideEvent *)+
−
{+
−
    Q_D(QMenu);+
−
    emit aboutToHide();+
−
    if (d->eventLoop)+
−
        d->eventLoop->exit();+
−
    d->setCurrentAction(0);+
−
#ifndef QT_NO_ACCESSIBILITY+
−
    QAccessible::updateAccessibility(this, 0, QAccessible::PopupMenuEnd);+
−
#endif+
−
#ifndef QT_NO_MENUBAR+
−
    if (QMenuBar *mb = qobject_cast<QMenuBar*>(d->causedPopup.widget))+
−
        mb->d_func()->setCurrentAction(0);+
−
#endif+
−
    d->mouseDown = 0;+
−
    d->hasHadMouse = false;+
−
    d->causedPopup.widget = 0;+
−
    d->causedPopup.action = 0;+
−
    if (d->scroll)+
−
        d->scroll->scrollTimer.stop(); //make sure the timer stops+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::paintEvent(QPaintEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    d->updateActionRects();+
−
    QPainter p(this);+
−
    QRegion emptyArea = QRegion(rect());+
−
+
−
    QStyleOptionMenuItem menuOpt;+
−
    menuOpt.initFrom(this);+
−
    menuOpt.state = QStyle::State_None;+
−
    menuOpt.checkType = QStyleOptionMenuItem::NotCheckable;+
−
    menuOpt.maxIconWidth = 0;+
−
    menuOpt.tabWidth = 0;+
−
    style()->drawPrimitive(QStyle::PE_PanelMenu, &menuOpt, &p, this);+
−
+
−
    //draw the items that need updating..+
−
    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))+
−
           continue;+
−
        //set the clip region to be extra safe (and adjust for the scrollers)+
−
        QRegion adjustedActionReg(adjustedActionRect);+
−
        emptyArea -= adjustedActionReg;+
−
        p.setClipRegion(adjustedActionReg);+
−
+
−
        QStyleOptionMenuItem opt;+
−
        initStyleOption(&opt, action);+
−
        opt.rect = adjustedActionRect;+
−
        style()->drawControl(QStyle::CE_MenuItem, &opt, &p, this);+
−
    }+
−
+
−
    const int fw = style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, this);+
−
    //draw the scroller regions..+
−
    if (d->scroll) {+
−
        menuOpt.menuItemType = QStyleOptionMenuItem::Scroller;+
−
        menuOpt.state |= QStyle::State_Enabled;+
−
        if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp) {+
−
            menuOpt.rect.setRect(fw, fw, width() - (fw * 2), d->scrollerHeight());+
−
            emptyArea -= QRegion(menuOpt.rect);+
−
            p.setClipRect(menuOpt.rect);+
−
            style()->drawControl(QStyle::CE_MenuScroller, &menuOpt, &p, this);+
−
        }+
−
        if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown) {+
−
            menuOpt.rect.setRect(fw, height() - d->scrollerHeight() - fw, width() - (fw * 2),+
−
                                     d->scrollerHeight());+
−
            emptyArea -= QRegion(menuOpt.rect);+
−
            menuOpt.state |= QStyle::State_DownArrow;+
−
            p.setClipRect(menuOpt.rect);+
−
            style()->drawControl(QStyle::CE_MenuScroller, &menuOpt, &p, this);+
−
        }+
−
    }+
−
    //paint the tear off..+
−
    if (d->tearoff) {+
−
        menuOpt.menuItemType = QStyleOptionMenuItem::TearOff;+
−
        menuOpt.rect.setRect(fw, fw, width() - (fw * 2),+
−
                             style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this));+
−
        if (d->scroll && d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)+
−
            menuOpt.rect.translate(0, d->scrollerHeight());+
−
        emptyArea -= QRegion(menuOpt.rect);+
−
        p.setClipRect(menuOpt.rect);+
−
        menuOpt.state = QStyle::State_None;+
−
        if (d->tearoffHighlighted)+
−
            menuOpt.state |= QStyle::State_Selected;+
−
        style()->drawControl(QStyle::CE_MenuTearoff, &menuOpt, &p, this);+
−
    }+
−
    //draw border+
−
    if (fw) {+
−
        QRegion borderReg;+
−
        borderReg += QRect(0, 0, fw, height()); //left+
−
        borderReg += QRect(width()-fw, 0, fw, height()); //right+
−
        borderReg += QRect(0, 0, width(), fw); //top+
−
        borderReg += QRect(0, height()-fw, width(), fw); //bottom+
−
        p.setClipRegion(borderReg);+
−
        emptyArea -= borderReg;+
−
        QStyleOptionFrame frame;+
−
        frame.rect = rect();+
−
        frame.palette = palette();+
−
        frame.state = QStyle::State_None;+
−
        frame.lineWidth = style()->pixelMetric(QStyle::PM_MenuPanelWidth);+
−
        frame.midLineWidth = 0;+
−
        style()->drawPrimitive(QStyle::PE_FrameMenu, &frame, &p, this);+
−
    }+
−
+
−
    //finally the rest of the space+
−
    p.setClipRegion(emptyArea);+
−
    menuOpt.state = QStyle::State_None;+
−
    menuOpt.menuItemType = QStyleOptionMenuItem::EmptyArea;+
−
    menuOpt.checkType = QStyleOptionMenuItem::NotCheckable;+
−
    menuOpt.rect = rect();+
−
    menuOpt.menuRect = rect();+
−
    style()->drawControl(QStyle::CE_MenuEmptyArea, &menuOpt, &p, this);+
−
}+
−
+
−
#ifndef QT_NO_WHEELEVENT+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::wheelEvent(QWheelEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    if (d->scroll && rect().contains(e->pos()))+
−
        d->scrollMenu(e->delta() > 0 ?+
−
                      QMenuPrivate::QMenuScroller::ScrollUp : QMenuPrivate::QMenuScroller::ScrollDown);+
−
}+
−
#endif+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::mousePressEvent(QMouseEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    if (d->aboutToHide || d->mouseEventTaken(e))+
−
        return;+
−
    if (!rect().contains(e->pos())) {+
−
         if (d->noReplayFor+
−
             && QRect(d->noReplayFor->mapToGlobal(QPoint()), d->noReplayFor->size()).contains(e->globalPos()))+
−
             setAttribute(Qt::WA_NoMouseReplay);+
−
         if (d->eventLoop) // synchronous operation+
−
             d->syncAction = 0;+
−
        d->hideUpToMenuBar();+
−
        return;+
−
    }+
−
    d->mouseDown = this;+
−
+
−
    QAction *action = d->actionAt(e->pos());+
−
    d->setCurrentAction(action, 20);+
−
    update();+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::mouseReleaseEvent(QMouseEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    if (d->aboutToHide || d->mouseEventTaken(e))+
−
        return;+
−
    if(d->mouseDown != this) {+
−
        d->mouseDown = 0;+
−
        return;+
−
    }+
−
+
−
    d->mouseDown = 0;+
−
    d->setSyncAction();+
−
    QAction *action = d->actionAt(e->pos());+
−
+
−
    if (action && action == d->currentAction) {+
−
        if (action->menu())+
−
            action->menu()->d_func()->setFirstActionActive();+
−
        else {+
−
#if defined(Q_WS_WIN)+
−
            //On Windows only context menus can be activated with the right button+
−
            if (e->button() == Qt::LeftButton || d->topCausedWidget() == 0)+
−
#endif+
−
                d->activateAction(action, QAction::Trigger);+
−
        }+
−
    } else if (d->hasMouseMoved(e->globalPos())) {+
−
        d->hideUpToMenuBar();+
−
    }+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::changeEvent(QEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    if (e->type() == QEvent::StyleChange || e->type() == QEvent::FontChange ||+
−
        e->type() == QEvent::LayoutDirectionChange) {+
−
        d->itemsDirty = 1;+
−
        setMouseTracking(style()->styleHint(QStyle::SH_Menu_MouseTracking, 0, this));+
−
        if (isVisible())+
−
            resize(sizeHint());+
−
        if (!style()->styleHint(QStyle::SH_Menu_Scrollable, 0, this)) {+
−
            delete d->scroll;+
−
            d->scroll = 0;+
−
        } else if (!d->scroll) {+
−
            d->scroll = new QMenuPrivate::QMenuScroller;+
−
            d->scroll->scrollFlags = QMenuPrivate::QMenuScroller::ScrollNone;+
−
        }+
−
    } else if (e->type() == QEvent::EnabledChange) {+
−
        if (d->tornPopup) // torn-off menu+
−
            d->tornPopup->setEnabled(isEnabled());+
−
        d->menuAction->setEnabled(isEnabled());+
−
#ifdef Q_WS_MAC+
−
        if (d->mac_menu)+
−
            d->setMacMenuEnabled(isEnabled());+
−
#endif+
−
    }+
−
    QWidget::changeEvent(e);+
−
}+
−
+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
bool+
−
QMenu::event(QEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    switch (e->type()) {+
−
    case QEvent::Polish:+
−
        d->updateLayoutDirection();+
−
        break;+
−
    case QEvent::ShortcutOverride: {+
−
            QKeyEvent *kev = static_cast<QKeyEvent*>(e);+
−
            if (kev->key() == Qt::Key_Up || kev->key() == Qt::Key_Down+
−
                || kev->key() == Qt::Key_Left || kev->key() == Qt::Key_Right+
−
                || kev->key() == Qt::Key_Enter || kev->key() == Qt::Key_Return+
−
                || kev->key() == Qt::Key_Escape) {+
−
                e->accept();+
−
                return true;+
−
            }+
−
        }+
−
        break;+
−
    case QEvent::KeyPress: {+
−
        QKeyEvent *ke = (QKeyEvent*)e;+
−
        if (ke->key() == Qt::Key_Tab || ke->key() == Qt::Key_Backtab) {+
−
            keyPressEvent(ke);+
−
            return true;+
−
        }+
−
    } break;+
−
    case QEvent::ContextMenu:+
−
        if(QMenuPrivate::menuDelayTimer.isActive()) {+
−
            QMenuPrivate::menuDelayTimer.stop();+
−
            internalDelayedPopup();+
−
        }+
−
        break;+
−
    case QEvent::Resize: {+
−
        QStyleHintReturnMask menuMask;+
−
        QStyleOption option;+
−
        option.initFrom(this);+
−
        if (style()->styleHint(QStyle::SH_Menu_Mask, &option, this, &menuMask)) {+
−
            setMask(menuMask.region);+
−
        }+
−
        d->itemsDirty = 1;+
−
        d->updateActionRects();+
−
        break; }+
−
    case QEvent::Show:+
−
        d->mouseDown = 0;+
−
        d->updateActionRects();+
−
        if (d->currentAction)+
−
            d->popupAction(d->currentAction, 0, false);+
−
        break;+
−
#ifndef QT_NO_WHATSTHIS+
−
    case QEvent::QueryWhatsThis:+
−
        e->setAccepted(d->whatsThis.size());+
−
        if (QAction *action = d->actionAt(static_cast<QHelpEvent*>(e)->pos())) {+
−
            if (action->whatsThis().size() || action->menu())+
−
                e->accept();+
−
        }+
−
        return true;+
−
#endif+
−
#ifdef QT_SOFTKEYS_ENABLED+
−
    case QEvent::LanguageChange: {+
−
        d->selectAction->setText(QSoftKeyManager::standardSoftKeyText(QSoftKeyManager::SelectSoftKey));+
−
        d->cancelAction->setText(QSoftKeyManager::standardSoftKeyText(QSoftKeyManager::CancelSoftKey));+
−
        }+
−
        break;+
−
#endif+
−
    default:+
−
        break;+
−
    }+
−
    return QWidget::event(e);+
−
}+
−
+
−
/*!+
−
    \reimp+
−
*/+
−
bool QMenu::focusNextPrevChild(bool next)+
−
{+
−
    setFocus();+
−
    QKeyEvent ev(QEvent::KeyPress, next ? Qt::Key_Tab : Qt::Key_Backtab, Qt::NoModifier);+
−
    keyPressEvent(&ev);+
−
    return true;+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::keyPressEvent(QKeyEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    d->updateActionRects();+
−
    int key = e->key();+
−
    if (isRightToLeft()) {  // in reverse mode open/close key for submenues are reversed+
−
        if (key == Qt::Key_Left)+
−
            key = Qt::Key_Right;+
−
        else if (key == Qt::Key_Right)+
−
            key = Qt::Key_Left;+
−
    }+
−
#ifndef Q_WS_MAC+
−
    if (key == Qt::Key_Tab) //means down+
−
        key = Qt::Key_Down;+
−
    if (key == Qt::Key_Backtab) //means up+
−
        key = Qt::Key_Up;+
−
#endif+
−
+
−
    bool key_consumed = false;+
−
    switch(key) {+
−
    case Qt::Key_Home:+
−
        key_consumed = true;+
−
        if (d->scroll)+
−
            d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollTop, true);+
−
        break;+
−
    case Qt::Key_End:+
−
        key_consumed = true;+
−
        if (d->scroll)+
−
            d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollBottom, true);+
−
        break;+
−
    case Qt::Key_PageUp:+
−
        key_consumed = true;+
−
        if (d->currentAction && d->scroll) {+
−
            if(d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)+
−
                d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollUp, true, true);+
−
            else+
−
                d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollTop, true);+
−
        }+
−
        break;+
−
    case Qt::Key_PageDown:+
−
        key_consumed = true;+
−
        if (d->currentAction && d->scroll) {+
−
            if(d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown)+
−
                d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollDown, true, true);+
−
            else+
−
                d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollBottom, true);+
−
        }+
−
        break;+
−
    case Qt::Key_Up:+
−
    case Qt::Key_Down: {+
−
        key_consumed = true;+
−
        QAction *nextAction = 0;+
−
        QMenuPrivate::QMenuScroller::ScrollLocation scroll_loc = QMenuPrivate::QMenuScroller::ScrollStay;+
−
        if (!d->currentAction) {+
−
            if(key == Qt::Key_Down) {+
−
                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)+
−
                         || act->isEnabled())) {+
−
                        nextAction = act;+
−
                        break;+
−
                    }+
−
                }+
−
            } else {+
−
                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)+
−
                         || act->isEnabled())) {+
−
                        nextAction = act;+
−
                        break;+
−
                    }+
−
                }+
−
            }+
−
        } else {+
−
            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) {+
−
                        for(int next_i = i-1; true; next_i--) {+
−
                            if (next_i == -1) {+
−
                                if(!style()->styleHint(QStyle::SH_Menu_SelectionWrap, 0, this))+
−
                                    break;+
−
                                if (d->scroll)+
−
                                    scroll_loc = QMenuPrivate::QMenuScroller::ScrollBottom;+
−
                                next_i = d->actionRects.count()-1;+
−
                            }+
−
                            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() &&+
−
                                !style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, this)))+
−
                                continue;+
−
                            nextAction = next;+
−
                            if (d->scroll && (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)) {+
−
                                int topVisible = d->scrollerHeight();+
−
                                if (d->tearoff)+
−
                                    topVisible += style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this);+
−
                                if (((y + d->scroll->scrollOffset) - topVisible) <= d->actionRects.at(next_i).height())+
−
                                    scroll_loc = QMenuPrivate::QMenuScroller::ScrollTop;+
−
                            }+
−
                            break;+
−
                        }+
−
                        if (!nextAction && d->tearoff)+
−
                            d->tearoffHighlighted = 1;+
−
                    } else {+
−
                        y += d->actionRects.at(i).height();+
−
                        for(int next_i = i+1; true; next_i++) {+
−
                            if (next_i == d->actionRects.count()) {+
−
                                if(!style()->styleHint(QStyle::SH_Menu_SelectionWrap, 0, this))+
−
                                    break;+
−
                                if (d->scroll)+
−
                                    scroll_loc = QMenuPrivate::QMenuScroller::ScrollTop;+
−
                                next_i = 0;+
−
                            }+
−
                            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() &&+
−
                                !style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, this)))+
−
                                continue;+
−
                            nextAction = next;+
−
                            if (d->scroll && (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown)) {+
−
                                int bottomVisible = height() - d->scrollerHeight();+
−
                                if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)+
−
                                    bottomVisible -= d->scrollerHeight();+
−
                                if (d->tearoff)+
−
                                    bottomVisible -= style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this);+
−
                                if ((y + d->scroll->scrollOffset + d->actionRects.at(next_i).height()) > bottomVisible)+
−
                                    scroll_loc = QMenuPrivate::QMenuScroller::ScrollBottom;+
−
                            }+
−
                            break;+
−
                        }+
−
                    }+
−
                    break;+
−
                }+
−
                y += d->actionRects.at(i).height();+
−
            }+
−
        }+
−
        if (nextAction) {+
−
            if (d->scroll && scroll_loc != QMenuPrivate::QMenuScroller::ScrollStay) {+
−
                d->scroll->scrollTimer.stop();+
−
                d->scrollMenu(nextAction, scroll_loc);+
−
            }+
−
            d->setCurrentAction(nextAction, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);+
−
        }+
−
        break; }+
−
+
−
    case Qt::Key_Right:+
−
        if (d->currentAction && d->currentAction->isEnabled() && d->currentAction->menu()) {+
−
            d->popupAction(d->currentAction, 0, true);+
−
            key_consumed = true;+
−
            break;+
−
        }+
−
        //FALL THROUGH+
−
    case Qt::Key_Left: {+
−
        if (d->currentAction && !d->scroll) {+
−
            QAction *nextAction = 0;+
−
            if (key == Qt::Key_Left) {+
−
                QRect actionR = d->actionRect(d->currentAction);+
−
                for(int x = actionR.left()-1; !nextAction && x >= 0; x--)+
−
                    nextAction = d->actionAt(QPoint(x, actionR.center().y()));+
−
            } else {+
−
                QRect actionR = d->actionRect(d->currentAction);+
−
                for(int x = actionR.right()+1; !nextAction && x < width(); x++)+
−
                    nextAction = d->actionAt(QPoint(x, actionR.center().y()));+
−
            }+
−
            if (nextAction) {+
−
                d->setCurrentAction(nextAction, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);+
−
                key_consumed = true;+
−
            }+
−
        }+
−
        if (!key_consumed && key == Qt::Key_Left && qobject_cast<QMenu*>(d->causedPopup.widget)) {+
−
            QPointer<QWidget> caused = d->causedPopup.widget;+
−
            d->hideMenu(this);+
−
            if (caused)+
−
                caused->setFocus();+
−
            key_consumed = true;+
−
        }+
−
        break; }+
−
+
−
    case Qt::Key_Alt:+
−
        if (d->tornoff)+
−
            break;+
−
+
−
        key_consumed = true;+
−
        if (style()->styleHint(QStyle::SH_MenuBar_AltKeyNavigation, 0, this))+
−
        {+
−
            d->hideMenu(this);+
−
#ifndef QT_NO_MENUBAR+
−
            if (QMenuBar *mb = qobject_cast<QMenuBar*>(QApplication::focusWidget())) {+
−
                mb->d_func()->setKeyboardMode(false);+
−
            }+
−
#endif+
−
        }+
−
        break;+
−
+
−
    case Qt::Key_Escape:+
−
#ifdef QT_KEYPAD_NAVIGATION+
−
    case Qt::Key_Back:+
−
#endif+
−
        key_consumed = true;+
−
        if (d->tornoff) {+
−
            close();+
−
            return;+
−
        }+
−
        {+
−
            QPointer<QWidget> caused = d->causedPopup.widget;+
−
            d->hideMenu(this); // hide after getting causedPopup+
−
#ifndef QT_NO_MENUBAR+
−
            if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) {+
−
                mb->d_func()->setCurrentAction(d->menuAction);+
−
                mb->d_func()->setKeyboardMode(true);+
−
            }+
−
#endif+
−
        }+
−
        break;+
−
+
−
    case Qt::Key_Space:+
−
        if (!style()->styleHint(QStyle::SH_Menu_SpaceActivatesItem, 0, this))+
−
            break;+
−
        // for motif, fall through+
−
#ifdef QT_KEYPAD_NAVIGATION+
−
    case Qt::Key_Select:+
−
#endif+
−
    case Qt::Key_Return:+
−
    case Qt::Key_Enter: {+
−
        if (!d->currentAction) {+
−
            d->setFirstActionActive();+
−
            key_consumed = true;+
−
            break;+
−
        }+
−
+
−
        d->setSyncAction();+
−
+
−
        if (d->currentAction->menu())+
−
            d->popupAction(d->currentAction, 0, true);+
−
        else+
−
            d->activateAction(d->currentAction, QAction::Trigger);+
−
        key_consumed = true;+
−
        break; }+
−
+
−
#ifndef QT_NO_WHATSTHIS+
−
    case Qt::Key_F1:+
−
        if (!d->currentAction || d->currentAction->whatsThis().isNull())+
−
            break;+
−
        QWhatsThis::enterWhatsThisMode();+
−
        d->activateAction(d->currentAction, QAction::Trigger);+
−
        return;+
−
#endif+
−
    default:+
−
        key_consumed = false;+
−
    }+
−
+
−
    if (!key_consumed) {                                // send to menu bar+
−
        if ((!e->modifiers() || e->modifiers() == Qt::AltModifier || e->modifiers() == Qt::ShiftModifier) &&+
−
           e->text().length()==1) {+
−
            bool activateAction = false;+
−
            QAction *nextAction = 0;+
−
            if (style()->styleHint(QStyle::SH_Menu_KeyboardSearch, 0, this) && !e->modifiers()) {+
−
                int best_match_count = 0;+
−
                d->searchBufferTimer.start(2000, this);+
−
                d->searchBuffer += e->text();+
−
                for(int i = 0; i < d->actions.size(); ++i) {+
−
                    int match_count = 0;+
−
                    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) {+
−
                        if(act_text.indexOf(d->searchBuffer.at(c), 0, Qt::CaseInsensitive) != -1)+
−
                            ++match_count;+
−
                    }+
−
                    if(match_count > best_match_count) {+
−
                        best_match_count = match_count;+
−
                        nextAction = act;+
−
                    }+
−
                }+
−
            }+
−
#ifndef QT_NO_SHORTCUT+
−
            else {+
−
                int clashCount = 0;+
−
                QAction *first = 0, *currentSelected = 0, *firstAfterCurrent = 0;+
−
                QChar c = e->text().at(0).toUpper();+
−
                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;+
−
                    if (key == c.unicode()) {+
−
                        clashCount++;+
−
                        if (!first)+
−
                            first = act;+
−
                        if (act == d->currentAction)+
−
                            currentSelected = act;+
−
                        else if (!firstAfterCurrent && currentSelected)+
−
                            firstAfterCurrent = act;+
−
                    }+
−
                }+
−
                if (clashCount == 1)+
−
                    activateAction = true;+
−
                if (clashCount >= 1) {+
−
                    if (clashCount == 1 || !currentSelected || !firstAfterCurrent)+
−
                        nextAction = first;+
−
                    else+
−
                        nextAction = firstAfterCurrent;+
−
                }+
−
            }+
−
#endif+
−
            if (nextAction) {+
−
                key_consumed = true;+
−
                if(d->scroll)+
−
                    d->scrollMenu(nextAction, QMenuPrivate::QMenuScroller::ScrollCenter, false);+
−
                d->setCurrentAction(nextAction, 20, QMenuPrivate::SelectedFromElsewhere, true);+
−
                if (!nextAction->menu() && activateAction) {+
−
                    d->setSyncAction();+
−
                    d->activateAction(nextAction, QAction::Trigger);+
−
                }+
−
            }+
−
        }+
−
        if (!key_consumed) {+
−
#ifndef QT_NO_MENUBAR+
−
            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))+
−
            QApplication::beep();+
−
#endif // Q_OS_WIN32+
−
    }+
−
    if (key_consumed)+
−
        e->accept();+
−
    else+
−
        e->ignore();+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::mouseMoveEvent(QMouseEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    if (!isVisible() || d->aboutToHide || d->mouseEventTaken(e))+
−
        return;+
−
    d->motions++;+
−
    if (d->motions == 0) // ignore first mouse move event (see enterEvent())+
−
        return;+
−
    d->hasHadMouse = d->hasHadMouse || rect().contains(e->pos());+
−
+
−
    QAction *action = d->actionAt(e->pos());+
−
    if (!action) {+
−
        if (d->hasHadMouse+
−
            && (!d->currentAction+
−
                || !(d->currentAction->menu() && d->currentAction->menu()->isVisible())))+
−
            d->setCurrentAction(0);+
−
        return;+
−
    } else if(e->buttons()) {+
−
        d->mouseDown = this;+
−
    }+
−
    if (d->sloppyRegion.contains(e->pos())) {+
−
        d->sloppyAction = action;+
−
        QMenuPrivate::sloppyDelayTimer.start(style()->styleHint(QStyle::SH_Menu_SubMenuPopupDelay, 0, this)*6, this);+
−
    } else {+
−
        d->setCurrentAction(action, style()->styleHint(QStyle::SH_Menu_SubMenuPopupDelay, 0, this));+
−
    }+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::enterEvent(QEvent *)+
−
{+
−
    d_func()->motions = -1; // force us to ignore the generate mouse move in mouseMoveEvent()+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::leaveEvent(QEvent *)+
−
{+
−
    Q_D(QMenu);+
−
    d->sloppyAction = 0;+
−
    if (!d->sloppyRegion.isEmpty())+
−
        d->sloppyRegion = QRegion();+
−
    if (!d->activeMenu && d->currentAction)+
−
        setActiveAction(0);+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void+
−
QMenu::timerEvent(QTimerEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    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();+
−
    } else if(QMenuPrivate::menuDelayTimer.timerId() == e->timerId()) {+
−
        QMenuPrivate::menuDelayTimer.stop();+
−
        internalDelayedPopup();+
−
    } else if(QMenuPrivate::sloppyDelayTimer.timerId() == e->timerId()) {+
−
        QMenuPrivate::sloppyDelayTimer.stop();+
−
        internalSetSloppyAction();+
−
    } else if(d->searchBufferTimer.timerId() == e->timerId()) {+
−
        d->searchBuffer.clear();+
−
    }+
−
}+
−
+
−
/*!+
−
  \reimp+
−
*/+
−
void QMenu::actionEvent(QActionEvent *e)+
−
{+
−
    Q_D(QMenu);+
−
    d->itemsDirty = 1;+
−
    setAttribute(Qt::WA_Resized, false);+
−
    if (d->tornPopup)+
−
        d->tornPopup->syncWithMenu(this, e);+
−
    if (e->type() == QEvent::ActionAdded) {+
−
        if(!d->tornoff) {+
−
            connect(e->action(), SIGNAL(triggered()), this, SLOT(_q_actionTriggered()));+
−
            connect(e->action(), SIGNAL(hovered()), this, SLOT(_q_actionHovered()));+
−
        }+
−
        if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action())) {+
−
            QWidget *widget = wa->requestWidget(this);+
−
            if (widget)+
−
                d->widgetItems.insert(wa, widget);+
−
        }+
−
    } else if (e->type() == QEvent::ActionRemoved) {+
−
        e->action()->disconnect(this);+
−
        if (e->action() == d->currentAction)+
−
            d->currentAction = 0;+
−
        if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action())) {+
−
            if (QWidget *widget = d->widgetItems.value(wa))+
−
                wa->releaseWidget(widget);+
−
        }+
−
        d->widgetItems.remove(e->action());+
−
    }+
−
+
−
#ifdef Q_WS_MAC+
−
    if (d->mac_menu) {+
−
        if (e->type() == QEvent::ActionAdded)+
−
            d->mac_menu->addAction(e->action(), d->mac_menu->findAction(e->before()), d);+
−
        else if (e->type() == QEvent::ActionRemoved)+
−
            d->mac_menu->removeAction(e->action());+
−
        else if (e->type() == QEvent::ActionChanged)+
−
            d->mac_menu->syncAction(e->action());+
−
    }+
−
#endif+
−
+
−
#if defined(Q_WS_WINCE) && !defined(QT_NO_MENUBAR)+
−
    if (!d->wce_menu)+
−
        d->wce_menu = new QMenuPrivate::QWceMenuPrivate;+
−
    if (e->type() == QEvent::ActionAdded)+
−
        d->wce_menu->addAction(e->action(), d->wce_menu->findAction(e->before()));+
−
    else if (e->type() == QEvent::ActionRemoved)+
−
        d->wce_menu->removeAction(e->action());+
−
    else if (e->type() == QEvent::ActionChanged)+
−
        d->wce_menu->syncAction(e->action());+
−
#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->updateActionRects();+
−
        resize(sizeHint());+
−
        update();+
−
    }+
−
}+
−
+
−
/*!+
−
  \internal+
−
*/+
−
void QMenu::internalSetSloppyAction()+
−
{+
−
    if (d_func()->sloppyAction)+
−
        d_func()->setCurrentAction(d_func()->sloppyAction, 0);+
−
}+
−
+
−
/*!+
−
  \internal+
−
*/+
−
void QMenu::internalDelayedPopup()+
−
{+
−
    Q_D(QMenu);+
−
+
−
    //hide the current item+
−
    if (QMenu *menu = d->activeMenu) {+
−
        d->activeMenu = 0;+
−
        d->hideMenu(menu);+
−
    }+
−
+
−
    if (!d->currentAction || !d->currentAction->isEnabled() || !d->currentAction->menu() ||+
−
        !d->currentAction->menu()->isEnabled() || d->currentAction->menu()->isVisible())+
−
        return;+
−
+
−
    //setup+
−
    d->activeMenu = d->currentAction->menu();+
−
    d->activeMenu->d_func()->causedPopup.widget = this;+
−
    d->activeMenu->d_func()->causedPopup.action = d->currentAction;+
−
+
−
    int subMenuOffset = style()->pixelMetric(QStyle::PM_SubMenuOverlap, 0, this);+
−
    const QRect actionRect(d->actionRect(d->currentAction));+
−
    const QSize menuSize(d->activeMenu->sizeHint());+
−
    const QPoint rightPos(mapToGlobal(QPoint(actionRect.right() + subMenuOffset + 1, actionRect.top())));+
−
    const QPoint leftPos(mapToGlobal(QPoint(actionRect.left() - subMenuOffset - menuSize.width(), actionRect.top())));+
−
+
−
    QPoint pos(rightPos);+
−
    QMenu *caused = qobject_cast<QMenu*>(d->activeMenu->d_func()->causedPopup.widget);+
−
+
−
    const QRect availGeometry(d->popupGeometry(caused));+
−
    if (isRightToLeft()) {+
−
        pos = leftPos;+
−
        if ((caused && caused->x() < x()) || pos.x() < availGeometry.left()) {+
−
            if(rightPos.x() + menuSize.width() < availGeometry.right())+
−
                pos = rightPos;+
−
            else+
−
                pos.rx() = availGeometry.left();+
−
        }+
−
    } else {+
−
        if ((caused && caused->x() > x()) || pos.x() + menuSize.width() > availGeometry.right()) {+
−
            if(leftPos.x() < availGeometry.left())+
−
                pos.rx() = availGeometry.right() - menuSize.width();+
−
            else+
−
                pos = leftPos;+
−
        }+
−
    }+
−
+
−
    //calc sloppy focus buffer+
−
    if (style()->styleHint(QStyle::SH_Menu_SloppySubMenus, 0, this)) {+
−
        QPoint cur = QCursor::pos();+
−
        if (actionRect.contains(mapFromGlobal(cur))) {+
−
            QPoint pts[4];+
−
            pts[0] = QPoint(cur.x(), cur.y() - 2);+
−
            pts[3] = QPoint(cur.x(), cur.y() + 2);+
−
            if (pos.x() >= cur.x())        {+
−
                pts[1] = QPoint(geometry().right(), pos.y());+
−
                pts[2] = QPoint(geometry().right(), pos.y() + menuSize.height());+
−
            } else {+
−
                pts[1] = QPoint(pos.x() + menuSize.width(), pos.y());+
−
                pts[2] = QPoint(pos.x() + menuSize.width(), pos.y() + menuSize.height());+
−
            }+
−
            QPolygon points(4);+
−
            for(int i = 0; i < 4; i++)+
−
                points.setPoint(i, mapFromGlobal(pts[i]));+
−
            d->sloppyRegion = QRegion(points);+
−
        }+
−
    }+
−
+
−
    //do the popup+
−
    d->activeMenu->popup(pos);+
−
}+
−
+
−
/*!+
−
    \fn void QMenu::addAction(QAction *action)+
−
    \overload+
−
+
−
    Appends the action \a action to the menu's list of actions.+
−
+
−
    \sa QMenuBar::addAction(), QWidget::addAction()+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::aboutToHide()+
−
    \since 4.2+
−
+
−
    This signal is emitted just before the menu is hidden from the user.+
−
+
−
    \sa aboutToShow(), hide()+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::aboutToShow()+
−
+
−
    This signal is emitted just before the menu is shown to the user.+
−
+
−
    \sa aboutToHide(), show()+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::triggered(QAction *action)+
−
+
−
    This signal is emitted when an action in this menu is triggered.+
−
+
−
    \a action is the action that caused the signal to be emitted.+
−
+
−
    Normally, you connect each menu action's \l{QAction::}{triggered()} signal+
−
    to its own custom slot, but sometimes you will want to connect several+
−
    actions to a single slot, for example, when you have a group of closely+
−
    related actions, such as "left justify", "center", "right justify".+
−
+
−
    \note This signal is emitted for the main parent menu in a hierarchy.+
−
    Hence, only the parent menu needs to be connected to a slot; sub-menus need+
−
    not be connected.+
−
+
−
    \sa hovered(), QAction::triggered()+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::hovered(QAction *action)+
−
+
−
    This signal is emitted when a menu action is highlighted; \a action+
−
    is the action that caused the signal to be emitted.+
−
+
−
    Often this is used to update status information.+
−
+
−
    \sa triggered(), QAction::hovered()+
−
*/+
−
+
−
+
−
/*!\internal+
−
*/+
−
void QMenu::setNoReplayFor(QWidget *noReplayFor)+
−
{+
−
#ifdef Q_WS_WIN+
−
    d_func()->noReplayFor = noReplayFor;+
−
#else+
−
    Q_UNUSED(noReplayFor);+
−
#endif+
−
}+
−
+
−
/*!+
−
  \property QMenu::separatorsCollapsible+
−
  \since 4.2+
−
+
−
  \brief whether consecutive separators should be collapsed+
−
+
−
  This property specifies whether consecutive separators in the menu+
−
  should be visually collapsed to a single one. Separators at the+
−
  beginning or the end of the menu are also hidden.+
−
+
−
  By default, this property is true.+
−
*/+
−
bool QMenu::separatorsCollapsible() const+
−
{+
−
    Q_D(const QMenu);+
−
    return d->collapsibleSeparators;+
−
}+
−
+
−
void QMenu::setSeparatorsCollapsible(bool collapse)+
−
{+
−
    Q_D(QMenu);+
−
    if (d->collapsibleSeparators == collapse)+
−
        return;+
−
+
−
    d->collapsibleSeparators = collapse;+
−
    d->itemsDirty = 1;+
−
    if (isVisible()) {+
−
        d->updateActionRects();+
−
        update();+
−
    }+
−
#ifdef Q_WS_MAC+
−
    if (d->mac_menu)+
−
        d->syncSeparatorsCollapsible(collapse);+
−
#endif+
−
}+
−
+
−
#ifdef QT3_SUPPORT+
−
+
−
int QMenu::insertAny(const QIcon *icon, const QString *text, const QObject *receiver, const char *member,+
−
                          const QKeySequence *shortcut, const QMenu *popup, int id, int index)+
−
{+
−
    QAction *act = popup ? popup->menuAction() : new QAction(this);+
−
    if (id != -1)+
−
        static_cast<QMenuItem*>(act)->setId(id);+
−
    if (icon)+
−
        act->setIcon(*icon);+
−
    if (text)+
−
        act->setText(*text);+
−
    if (shortcut)+
−
        act->setShortcut(*shortcut);+
−
    if (receiver && member)+
−
        QObject::connect(act, SIGNAL(activated(int)), receiver, member);+
−
    if (index == -1 || index >= actions().count())+
−
        addAction(act);+
−
    else+
−
        insertAction(actions().value(index), act);+
−
    return findIdForAction(act);+
−
}+
−
+
−
/*!+
−
    Use insertAction() or one of the addAction() overloads instead.+
−
*/+
−
int QMenu::insertItem(QMenuItem *item, int id, int index)+
−
{+
−
    if (index == -1 || index >= actions().count())+
−
        addAction(item);+
−
    else+
−
        insertAction(actions().value(index), item);+
−
    if (id > -1)+
−
        item->d_func()->id = id;+
−
    return findIdForAction(item);+
−
}+
−
+
−
/*!+
−
    Use the insertSeparator() overload that takes a QAction *+
−
    parameter instead.+
−
*/+
−
int QMenu::insertSeparator(int index)+
−
{+
−
    QAction *act = new QAction(this);+
−
    act->setSeparator(true);+
−
    if (index == -1 || index >= actions().count())+
−
        addAction(act);+
−
    else+
−
        insertAction(actions().value(index), act);+
−
    return findIdForAction(act);+
−
}+
−
+
−
QAction *QMenu::findActionForId(int id) const+
−
{+
−
    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;+
−
    }+
−
    return 0;+
−
}+
−
+
−
/*!+
−
    Use QAction and actions() instead.+
−
*/+
−
QMenuItem *QMenu::findPopup( QMenu *popup, int *index )+
−
{+
−
   QList<QAction *> list = actions();+
−
    for (int i = 0; i < list.size(); ++i) {+
−
        QAction *act = list.at(i);+
−
        if (act->menu() == popup) {+
−
            QMenuItem *item = static_cast<QMenuItem *>(act);+
−
            if (index)+
−
                *index = act->d_func()->id;+
−
            return item;+
−
        }+
−
    }+
−
    return 0;+
−
}+
−
+
−
+
−
/*!+
−
    Use QAction::setData() instead.+
−
*/+
−
bool QMenu::setItemParameter(int id, int param)+
−
{+
−
    if (QAction *act = findActionForId(id)) {+
−
        act->d_func()->param = param;+
−
        return true;+
−
    }+
−
    return false;+
−
}+
−
+
−
/*!+
−
    Use QAction::data() instead.+
−
*/+
−
int QMenu::itemParameter(int id) const+
−
{+
−
    if (QAction *act = findActionForId(id))+
−
        return act->d_func()->param;+
−
    return id;+
−
}+
−
+
−
/*!+
−
    Use actions instead.+
−
*/+
−
void QMenu::setId(int index, int id)+
−
{+
−
    if(QAction *act = actions().value(index))+
−
        act->d_func()->id = id;+
−
}+
−
+
−
/*!+
−
    Use style()->pixelMetric(QStyle::PM_MenuPanelWidth, this) instead.+
−
*/+
−
int QMenu::frameWidth() const+
−
{+
−
    return style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, this);+
−
}+
−
+
−
int QMenu::findIdForAction(QAction *act) const+
−
{+
−
    if (!act)+
−
        return -1;+
−
    return act->d_func()->id;+
−
}+
−
#endif // QT3_SUPPORT+
−
+
−
/*!+
−
    \fn uint QMenu::count() const+
−
+
−
    Use actions().count() instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QString &text, const QObject *receiver, const char* member, const QKeySequence& shortcut, int id, int index)+
−
+
−
    Use insertAction() or one of the addAction() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QIcon& icon, const QString &text, const QObject *receiver, const char* member, const QKeySequence& shortcut, int id, int index)+
−
+
−
    Use insertAction() or one of the addAction() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QPixmap &pixmap, const QObject *receiver, const char* member, const QKeySequence& shortcut, int id, int index)+
−
+
−
    Use insertAction() or one of the addAction() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QString &text, int id, int index)+
−
+
−
    Use insertAction() or one of the addAction() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QIcon& icon, const QString &text, int id, int index)+
−
+
−
    Use insertAction() or one of the addAction() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QString &text, QMenu *popup, int id, int index)+
−
+
−
    Use insertMenu() or one of the addMenu() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QIcon& icon, const QString &text, QMenu *popup, int id, int index)+
−
+
−
    Use insertMenu() or one of the addMenu() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QPixmap &pixmap, int id, int index)+
−
+
−
    Use insertAction() or one of the addAction() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertItem(const QPixmap &pixmap, QMenu *popup, int id, int index)+
−
+
−
    Use insertMenu() or one of the addMenu() overloads instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::removeItem(int id)+
−
+
−
    Use removeAction() instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::removeItemAt(int index)+
−
+
−
    Use removeAction() instead.+
−
*/+
−
+
−
/*!+
−
    \fn QKeySequence QMenu::accel(int id) const+
−
+
−
    Use shortcut() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setAccel(const QKeySequence& key, int id)+
−
+
−
    Use setShortcut() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn QIcon QMenu::iconSet(int id) const+
−
+
−
    Use icon() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn QString QMenu::text(int id) const+
−
+
−
    Use text() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn QPixmap QMenu::pixmap(int id) const+
−
+
−
    Use QPixmap(icon()) on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setWhatsThis(int id, const QString &w)+
−
+
−
    Use setWhatsThis() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn QString QMenu::whatsThis(int id) const+
−
+
−
    Use whatsThis() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::changeItem(int id, const QString &text)+
−
+
−
    Use setText() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::changeItem(int id, const QPixmap &pixmap)+
−
+
−
    Use setText() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::changeItem(int id, const QIcon &icon, const QString &text)+
−
+
−
    Use setIcon() and setText() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn bool QMenu::isItemActive(int id) const+
−
+
−
    Use activeAction() instead.+
−
*/+
−
+
−
/*!+
−
    \fn bool QMenu::isItemEnabled(int id) const+
−
+
−
    Use isEnabled() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setItemEnabled(int id, bool enable)+
−
+
−
    Use setEnabled() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn bool QMenu::isItemChecked(int id) const+
−
+
−
    Use isChecked() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setItemChecked(int id, bool check)+
−
+
−
    Use setChecked() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn bool QMenu::isItemVisible(int id) const+
−
+
−
    Use isVisible() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setItemVisible(int id, bool visible)+
−
+
−
    Use setVisible() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn QRect QMenu::itemGeometry(int index)+
−
+
−
    Use actionGeometry() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn QFont QMenu::itemFont(int id) const+
−
+
−
    Use font() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setItemFont(int id, const QFont &font)+
−
+
−
    Use setFont() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::indexOf(int id) const+
−
+
−
    Use actions().indexOf(action) on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::idAt(int index) const+
−
+
−
    Use actions instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::activateItemAt(int index)+
−
+
−
    Use activate() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn bool QMenu::connectItem(int id, const QObject *receiver, const char* member)+
−
+
−
    Use connect() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn bool QMenu::disconnectItem(int id,const QObject *receiver, const char* member)+
−
    Use disconnect() on the relevant QAction instead.+
−
+
−
*/+
−
+
−
/*!+
−
    \fn QMenuItem *QMenu::findItem(int id) const+
−
+
−
    Use actions instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::popup(const QPoint & pos, int indexAtPoint)+
−
+
−
    Use popup() on the relevant QAction instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::insertTearOffHandle(int a, int b)+
−
+
−
    Use setTearOffEnabled() instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::itemAtPos(const QPoint &p, bool ignoreSeparator)+
−
+
−
    Use actions instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::columns() const+
−
+
−
    Use columnCount() instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::itemHeight(int index)+
−
+
−
    Use actionGeometry(actions().value(index)).height() instead.+
−
*/+
−
+
−
/*!+
−
    \fn int QMenu::itemHeight(QMenuItem *mi)+
−
+
−
    Use actionGeometry() instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::activated(int itemId);+
−
+
−
    Use triggered() instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::highlighted(int itemId);+
−
+
−
    Use hovered() instead.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setCheckable(bool checkable)+
−
+
−
    Not necessary anymore. The \a checkable parameter is ignored.+
−
*/+
−
+
−
/*!+
−
    \fn bool QMenu::isCheckable() const+
−
+
−
    Not necessary anymore. Always returns true.+
−
*/+
−
+
−
/*!+
−
    \fn void QMenu::setActiveItem(int id)+
−
+
−
    Use setActiveAction() instead.+
−
*/+
−
+
−
QT_END_NAMESPACE+
−
+
−
// for private slots+
−
#include "moc_qmenu.cpp"+
−
#include "qmenu.moc"+
−
+
−
#endif // QT_NO_MENU+
−