diff options
Diffstat (limited to 'src/gui/widgets/qmenu.cpp')
| -rw-r--r-- | src/gui/widgets/qmenu.cpp | 3467 |
1 files changed, 3467 insertions, 0 deletions
diff --git a/src/gui/widgets/qmenu.cpp b/src/gui/widgets/qmenu.cpp new file mode 100644 index 0000000..ed3e338 --- /dev/null +++ b/src/gui/widgets/qmenu.cpp @@ -0,0 +1,3467 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@nokia.com. +** $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 <private/qaction_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); + activationRecursionGuard = false; +#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; + } +} + +//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::calcActionRects(QMap<QAction*, QRect> &actionRects, QList<QAction*> &actionList) const +{ + Q_Q(const QMenu); + if (!itemsDirty) { + actionRects = this->actionRects; + actionList = this->actionList; + return; + } + + actionRects.clear(); + actionList.clear(); + QList<QAction*> items = filterActions(q->actions()); + int max_column_width = 0, + dh = popupGeometry(QApplication::desktop()->screenNumber(q)).height(), + ncols = 1, + y = 0; + const int hmargin = q->style()->pixelMetric(QStyle::PM_MenuHMargin, 0, q), + vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q), + icone = q->style()->pixelMetric(QStyle::PM_SmallIconSize, 0, q); + + //for compatability now - will have to refactor this away.. + tabWidth = 0; + maxIconWidth = 0; + hasCheckableItems = false; + for(int i = 0; i < items.count(); i++) { + QAction *action = items.at(i); + if (widgetItems.value(action)) + continue; + hasCheckableItems |= action->isCheckable(); + QIcon is = action->icon(); + if (!is.isNull()) { + uint miw = maxIconWidth; + maxIconWidth = qMax<uint>(miw, icone + 4); + } + } + + //calculate size + QFontMetrics qfm = q->fontMetrics(); + for(int i = 0; i < items.count(); i++) { + QAction *action = items.at(i); + + QFontMetrics fm(action->font().resolve(q->font())); + QSize sz; + + //let the style modify the above size.. + QStyleOptionMenuItem opt; + q->initStyleOption(&opt, action); + opt.rect = q->rect(); + + 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 + } + int w = fm.boundingRect(QRect(), Qt::TextSingleLine, s).width(); + w -= s.count(QLatin1Char('&')) * fm.width(QLatin1Char('&')); + w += s.count(QLatin1String("&&")) * fm.width(QLatin1Char('&')); + sz.setWidth(w); + sz.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 = q->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 - (q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q) * 2)) { + ncols++; + y = vmargin; + } + y += sz.height(); + //append item + actionRects.insert(action, QRect(0, 0, sz.width(), sz.height())); + actionList.append(action); + } + } + + if (tabWidth) + max_column_width += tabWidth; //finally add in the tab width + + //calculate position + int x = hmargin; + y = vmargin; + + for(int i = 0; i < actionList.count(); i++) { + QAction *action = actionList.at(i); + QRect &rect = actionRects[action]; + if (rect.isNull()) + continue; + if (!scroll && + y+rect.height() > dh - (q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q) * 2)) { + ncols--; + if (ncols < 0) + qWarning("QMenu: Column calculation mismatch (%d)", ncols); + x += max_column_width + hmargin; + y = vmargin; + } + rect.translate(x, y); //move + rect.setWidth(max_column_width); //uniform width + y += rect.height(); + } +} + +void QMenuPrivate::updateActions() +{ + Q_Q(const QMenu); + if (!itemsDirty) + return; + sloppyAction = 0; + calcActionRects(actionRects, actionList); + for (QHash<QAction *, QWidget *>::ConstIterator item = widgetItems.constBegin(), + end = widgetItems.constEnd(); item != end; ++item) { + QAction *action = item.key(); + QWidget *widget = item.value(); + widget->setGeometry(actionRect(action)); + widget->setVisible(action->isVisible()); + } + ncols = 1; + int last_left = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q); + if (!scroll) { + for(int i = 0; i < actionList.count(); i++) { + int left = actionRects.value(actionList.at(i)).left(); + if (left > last_left) { + last_left = left; + ncols++; + } + } + } + itemsDirty = 0; +} + +QList<QAction *> QMenuPrivate::filterActions(const QList<QAction *> &actions) const +{ + QList<QAction *> visibleActions; + int i = 0; + while (i < actions.count()) { + QAction *action = actions.at(i); + if (!action->isVisible()) { + ++i; + continue; + } + if (!action->isSeparator() || !collapsibleSeparators) { + visibleActions.append(action); + ++i; + continue; + } + + // no leading separators + if (!visibleActions.isEmpty()) + visibleActions.append(action); + + // skip double/tripple/etc. separators + while (i < actions.count() + && (!actions.at(i)->isVisible() || actions.at(i)->isSeparator())) + ++i; + } + + if (collapsibleSeparators) { + // remove trailing separators + while (!visibleActions.isEmpty() && visibleActions.last()->isSeparator()) + visibleActions.removeLast(); + } + + return visibleActions; +} + +QRect QMenuPrivate::actionRect(QAction *act) const +{ + Q_Q(const QMenu); + QRect ret = actionRects.value(act); + if (ret.isNull()) + return ret; + if (scroll) + ret.translate(0, scroll->scrollOffset); + if (tearoff) + ret.translate(0, q->style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, q)); + const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q); + ret.translate(fw+leftmargin, fw+topmargin); + return ret; +} + +void QMenuPrivate::hideUpToMenuBar() +{ + Q_Q(QMenu); + 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); + m->d_func()->setCurrentAction(0); + } else { +#ifndef QT_NO_TOOLBUTTON + if (qobject_cast<QToolButton*>(caused) == 0) +#endif + qWarning("QMenu: Internal error"); + caused = 0; + } + } + } + setCurrentAction(0); +} + +void QMenuPrivate::hideMenu(QMenu *menu) +{ + 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) { + + QEventLoop eventLoop; + QAction *activeAction = currentAction; + + // Deselect and wait 60 ms. + 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, 150); + // Hopefully we'll integrate qt/research/windowtransitions into main before 4.4. + // Talk to Richard, Trenton or Bjoern. +#if defined(Q_WS_MAC) + macWindowFade(qt_mac_window_for(menu)); // FIXME - what is the default duration for view animations + + // Wait for the transition to complete. + QEventLoop eventLoop; + QTimer::singleShot(150, &eventLoop, SLOT(quit())); + eventLoop.exec(); +#endif // Q_WS_MAC + } + aboutToHide = false; + menu->blockSignals(false); +#endif // QT_NO_EFFECTS + 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); + const int scrollerHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q); + for(int i = 0, saccum = 0; i < actionList.count(); i++) { + QAction *act = actionList[i]; + if (scroll && scroll->scrollFlags & QMenuScroller::ScrollUp) { + saccum -= actionRects.value(act).height(); + if (saccum > scroll->scrollOffset-scrollerHeight) + continue; + } + 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 && !(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 && action != currentAction); +#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)); + QWidget *widget = widgetItems.value(action); + + if (reason == SelectedFromKeyboard) { + 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) { + QWidget *w = causedPopup.widget; + while (QMenu *m = qobject_cast<QMenu*>(w)) + w = m->d_func()->causedPopup.widget; + if (w) { + QString empty; + QStatusTipEvent tip(empty); + QApplication::sendEvent(w, &tip); + } +#endif + } + if (hideActiveMenu) { + activeMenu = 0; +#ifndef QT_NO_EFFECTS + // kill any running effect + qFadeEffect(0); + qScrollEffect(0); +#endif + hideMenu(hideActiveMenu); + } +} + +QAction *QMenuPrivate::actionAt(QPoint p) const +{ + if (!q_func()->rect().contains(p)) //sanity check + return 0; + + for(int i = 0; i < actionList.count(); i++) { + QAction *act = actionList[i]; + if (actionRect(act).contains(p)) + return act; + } + 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; +} + +/*! + 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; + int newOffset = 0; + const int scrollHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q); + const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp) ? scrollHeight : 0; + const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollHeight : 0; + const int vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q); + const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q); + + if (location == QMenuScroller::ScrollTop) { + for(int i = 0, saccum = 0; i < actionList.count(); i++) { + QAction *act = actionList.at(i); + if (act == action) { + newOffset = topScroll - saccum; + break; + } + saccum += actionRects.value(act).height(); + } + } else { + for(int i = 0, saccum = 0; i < actionList.count(); i++) { + QAction *act = actionList.at(i); + saccum += actionRects.value(act).height(); + if (act == action) { + 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 < actionList.count(); i++) { + saccum += actionRects.value(actionList.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(QApplication::desktop()->screenNumber(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 + scroll->scrollOffset = newOffset; + if (scroll->scrollOffset > 0) + scroll->scrollOffset = 0; + 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); + if(location == QMenuScroller::ScrollBottom) { + for(int i = actionList.size()-1; i >= 0; --i) { + QAction *act = actionList.at(i); + 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 < actionList.size(); ++i) { + QAction *act = actionList.at(i); + 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; + const int scrollHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q); + const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp) ? scrollHeight : 0; + const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollHeight : 0; + const int vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q); + const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q); + const int offset = topScroll ? topScroll-vmargin : 0; + if (direction == QMenuScroller::ScrollUp) { + for(int i = 0, saccum = 0; i < actionList.count(); i++) { + QAction *act = actionList.at(i); + const int iHeight = actionRects.value(act).height(); + saccum -= iHeight; + if (saccum <= scroll->scrollOffset-offset) { + scrollMenu(act, page ? QMenuScroller::ScrollBottom : QMenuScroller::ScrollTop, active); + break; + } + } + } else if (direction == QMenuScroller::ScrollDown) { + bool scrolled = false; + for(int i = 0, saccum = 0; i < actionList.count(); i++) { + QAction *act = actionList.at(i); + const int iHeight = actionRects.value(act).height(); + saccum -= iHeight; + if (saccum <= scroll->scrollOffset-offset) { + const int scrollerArea = q->height() - botScroll - fw*2; + int visible = (scroll->scrollOffset-offset) - saccum; + for(i++ ; i < actionList.count(); i++) { + act = actionList.at(i); + const int iHeight = actionRects.value(act).height(); + visible += iHeight; + if (visible > scrollerArea - topScroll) { + scrolled = true; + scrollMenu(act, 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()) { + const int scrollerHeight = q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q); + for(int dir = QMenuScroller::ScrollUp; dir <= QMenuScroller::ScrollDown; dir = dir << 1) { + if (scroll->scrollFlags & dir) { + if (dir == QMenuScroller::ScrollUp) + isScroll = (pos.y() <= scrollerHeight); + else if (dir == QMenuScroller::ScrollDown) + isScroll = (pos.y() >= q->height()-scrollerHeight); + if (isScroll) { + scroll->scrollDirection = dir; + break; + } + } + } + } + if (isScroll) { + if (!scroll->scrollTimer) + scroll->scrollTimer = new QBasicTimer; + scroll->scrollTimer->start(50, q); + return true; + } else if (scroll->scrollTimer && scroll->scrollTimer->isActive()) { + 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, q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q)); + 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; +} + +void QMenuPrivate::activateCausedStack(const QList<QPointer<QWidget> > &causedStack, QAction *action, QAction::ActionEvent action_e, bool self) +{ + Q_ASSERT(!activationRecursionGuard); + activationRecursionGuard = true; +#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 + } + } + activationRecursionGuard = false; +} + +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 = qApp->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 + QWidget *w = causedPopup.widget; + while (QMenu *m = qobject_cast<QMenu*>(w)) + w = m->d_func()->causedPopup.widget; + action->showStatusText(w); + } else { + actionAboutToTrigger = 0; + } +} + +void QMenuPrivate::_q_actionTriggered() +{ + 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->triggered(action); +#ifdef QT3_SUPPORT + emit q->activated(id); +#endif + + if (!activationRecursionGuard) { + //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(); + + 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 application + \ingroup basicwidgets + \mainclass + + 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. + + 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); + for (QHash<QAction *, QWidget *>::ConstIterator item = d->widgetItems.constBegin(), + end = d->widgetItems.constEnd(); item != end; ++item) { + QWidgetAction *action = static_cast<QWidgetAction *>(item.key()); + QWidget *widget = item.value(); + if (action && widget) + action->releaseWidget(widget); + } + d->widgetItems.clear(); + + if (d->eventLoop) + d->eventLoop->exit(); + if (d->tornPopup) + d->tornPopup->close(); +} + +/*! + \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 will set the default action to \a act. The default action may + have a visual queue depending on the current QStyle. A default + action is usually meant to indicate what will defaultly happen on a + drop, as shown in a context menu. + + \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 && d->tornPopup) + d->tornPopup->close(); + 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 (d_func()->tornPopup) + d_func()->tornPopup->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++) { + 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); + ensurePolished(); + QMap<QAction*, QRect> actionRects; + QList<QAction*> actionList; + d->calcActionRects(actionRects, actionList); + + QSize s; + QStyleOption opt(0); + opt.rect = rect(); + opt.palette = palette(); + opt.state = QStyle::State_None; + for (QMap<QAction*, QRect>::const_iterator i = actionRects.constBegin(); + i != actionRects.constEnd(); ++i) { + if (i.value().bottom() > s.height()) + s.setHeight(i.value().y()+i.value().height()); + if (i.value().right() > s.width()) + s.setWidth(i.value().right()); + } + if (d->tearoff) + s.rheight() += style()->pixelMetric(QStyle::PM_MenuTearoffHeight, &opt, this); + if (const int fw = style()->pixelMetric(QStyle::PM_MenuPanelWidth, &opt, this)) { + s.rwidth() += fw*2; + s.rheight() += fw*2; + } + // Note that the action rects calculated above already include + // the top and left margins, so we only need to add margins for + // the bottom and right. + s.rwidth() += style()->pixelMetric(QStyle::PM_MenuHMargin, &opt, this); + s.rheight() += style()->pixelMetric(QStyle::PM_MenuVMargin, &opt, this); + + s += QSize(d->leftmargin + d->rightmargin, d->topmargin + d->bottommargin); + + 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; + +#ifndef QT_NO_MENUBAR + // if this menu is part of a chain attached to a QMenuBar, set the + // _NET_WM_WINDOW_TYPE_DROPDOWN_MENU X11 window type + QWidget* top = this; + while (QMenu* m = qobject_cast<QMenu *>(top)) + top = m->d_func()->causedPopup.widget; + setAttribute(Qt::WA_X11NetWmWindowTypeDropDownMenu, qobject_cast<QMenuBar *>(top) != 0); +#endif + + ensurePolished(); // Get the right font + emit aboutToShow(); + d->updateActions(); + QPoint pos = p; + QSize size = sizeHint(); + QRect screen = d->popupGeometry(QApplication::desktop()->screenNumber(p)); + const int desktopFrame = style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, this); + bool adjustToDesktop = !window()->testAttribute(Qt::WA_DontShowOnScreen); + if (d->ncols > 1) { + pos.setY(screen.top()+desktopFrame); + } else if (atAction) { + for(int i=0, above_height=0; i<(int)d->actionList.count(); i++) { + QAction *action = d->actionList.at(i); + 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 < (int)d->actionList.count(); i2++) + below_height += d->actionRects.value(d->actionList.at(i2)).height(); + size.setHeight(below_height); + } + break; + } else { + above_height += d->actionRects.value(action).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 (qApp->layoutDirection() == Qt::RightToLeft) { + if(snapToMouse) //position flowing left from the mouse + pos.setX(mouse.x()-size.width()); + + 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(qMin(p.x()+size.width(), screen.right()-desktopFrame-size.width()+1)); + if (pos.x() < screen.left()+desktopFrame) + pos.setX(qMax(p.x(), 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 = qApp->layoutDirection() == Qt::RightToLeft ? QEffects::LeftScroll : QEffects::RightScroll; + int vGuess = QEffects::DownScroll; + if (qApp->layoutDirection() == Qt::RightToLeft) { + 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); + for(QList<QAction*>::ConstIterator it = actions.constBegin(); it != actions.constEnd(); ++it) + menu.addAction((*it)); + 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; +} + +/*! + \reimp +*/ +void QMenu::paintEvent(QPaintEvent *e) +{ + Q_D(QMenu); + 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->actionList.count(); ++i) { + QAction *action = d->actionList.at(i); + QRect adjustedActionRect = d->actionRect(action); + 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) { + const int scrollerHeight = style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this); + menuOpt.menuItemType = QStyleOptionMenuItem::Scroller; + menuOpt.state |= QStyle::State_Enabled; + if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp) { + menuOpt.rect.setRect(fw, fw, width() - (fw * 2), scrollerHeight); + 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() - scrollerHeight - fw, width() - (fw * 2), + 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, style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this)); + 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) && !defined(QT_NO_MENUBAR) + //On Windows only context menus can be activated with the right button + bool isContextMenu = true; + const QWidget *cause = d->causedPopup.widget; + while (cause) { + //if the popup was caused by either QMenuBar or a QToolButton, it is not a context menu + if (qobject_cast<const QMenuBar *>(cause) || qobject_cast<const QToolButton *>(cause)) { + isContextMenu = false; + break; + } else if (const QMenu *menu = qobject_cast<const QMenu *>(cause)) { + cause = menu->d_func()->causedPopup.widget; + } else { + break; + } + } + if (e->button() == Qt::LeftButton || (e->button() == Qt::RightButton && isContextMenu)) +#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::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->updateActions(); + break; } + case QEvent::Show: + d->mouseDown = 0; + d->updateActions(); + 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 + 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); + 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->actionList.size(); ++i) { + QAction *act = d->actionList.at(i); + if (!act->isSeparator() && + (style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, this) + || act->isEnabled())) { + nextAction = act; + break; + } + } + } else { + for(int i = d->actionList.size()-1; i >= 0; --i) { + QAction *act = d->actionList.at(i); + 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 < (int)d->actionList.count(); i++) { + QAction *act = d->actionList.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->actionList.count()-1; + } + QAction *next = d->actionList.at(next_i); + if (next == d->currentAction) + break; + 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 = style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this); + if (d->tearoff) + topVisible += style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this); + if (((y + d->scroll->scrollOffset) - topVisible) <= d->actionRects.value(nextAction).height()) + scroll_loc = QMenuPrivate::QMenuScroller::ScrollTop; + } + break; + } + if (!nextAction && d->tearoff) + d->tearoffHighlighted = 1; + } else { + y += d->actionRects.value(act).height(); + for(int next_i = i+1; true; next_i++) { + if (next_i == d->actionList.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->actionList.at(next_i); + if (next == d->currentAction) + break; + 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)) { + const int scrollerHeight = style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, this); + int bottomVisible = height()-scrollerHeight; + if (d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp) + bottomVisible -= scrollerHeight; + if (d->tearoff) + bottomVisible -= style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, this); + if ((y + d->scroll->scrollOffset + d->actionRects.value(nextAction).height()) > bottomVisible) + scroll_loc = QMenuPrivate::QMenuScroller::ScrollBottom; + } + break; + } + } + break; + } + y += d->actionRects.value(act).height(); + } + } + if (nextAction) { + if (d->scroll && scroll_loc != QMenuPrivate::QMenuScroller::ScrollStay) { + if (d->scroll->scrollTimer) + 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*>(qApp->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->actionList.size(); ++i) { + int match_count = 0; + register QAction *act = d->actionList.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->actionList.size(); ++i) { + register QAction *act = d->actionList.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) { + if (QWidget *caused = d->causedPopup.widget) { + while(QMenu *m = qobject_cast<QMenu*>(caused)) + caused = m->d_func()->causedPopup.widget; +#ifndef QT_NO_MENUBAR + if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) { + QAction *oldAct = mb->d_func()->currentAction; + QApplication::sendEvent(mb, e); + if (mb->d_func()->currentAction != oldAct) + key_consumed = true; + } +#endif + } + } + +#ifdef Q_OS_WIN32 + if (key_consumed && (e->key() == Qt::Key_Control || e->key() == Qt::Key_Shift || e->key() == Qt::Key_Meta)) + qApp->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 |= rect().contains(e->pos()); + + QAction *action = d->actionAt(e->pos()); + if (!action) { + if (d->hasHadMouse && !rect().contains(e->pos())) + d->setCurrentAction(0); + return; + } else if(e->buttons() & (Qt::LeftButton | Qt::RightButton)) { + 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(); +} + +/*! + \reimp +*/ +void +QMenu::timerEvent(QTimerEvent *e) +{ + Q_D(QMenu); + if (d->scroll && d->scroll->scrollTimer && 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) { + d->actionRects.clear(); + d->actionList.clear(); + e->action()->disconnect(this); + if (e->action() == d->currentAction) + d->currentAction = 0; + if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action())) { + QWidget *widget = d->widgetItems.take(wa); + if (widget) + wa->releaseWidget(widget); + } else { + // If this is called from the QAction destructor, the + // previous call to qobject_cast will fail because the + // QWidgetAction has been destroyed already. We need to + // remove it from the hash anyway or it might crash later + // the widget itself has been already destroyed in + // ~QWidgetAction + d->widgetItems.remove(e->action()); + } + } + +#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_OS_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 + + if (isVisible()) { + d->updateActions(); + 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(rect().right() + subMenuOffset + 1, actionRect.top()))); + const QPoint leftPos(mapToGlobal(QPoint(rect().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(QApplication::desktop()->screenNumber(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); + d->collapsibleSeparators = collapse; + d->itemsDirty = 1; + if (isVisible()) { + d->updateActions(); + update(); + } +} + +#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 +{ + QList<QAction *> list = actions(); + for (int i = 0; i < list.size(); ++i) { + QAction *act = list.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 |