QMenu Class Reference

#include <qmenu.h>

Inheritance diagram for QMenu:

[legend]Collaboration diagram for QMenu:

[legend]List of all members.

---

Detailed Description

The QMenu class provides a menu widget for use in menu bars, context menus, and other popup menus.

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.

A menu consists of a list of action items. Actions are added with addAction(). 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".

There are three kinds of action items: separators, actions that show a submenu, and actions that perform an action. Separators are inserted with addSeparator(). For submenus use addMenu(). 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 {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.

See the {mainwindows/menus}{Menus} example for an example of how to use QMenuBar and QMenu in your application.

Important inherited functions: addAction(), removeAction(), clear(), addSeparator(), and addMenu().

See also:

QMenuBar, {fowler}{GUI Design Handbook: Menu, Drop-Down and Pop-Up}, {Application Example}, {Menus Example}, {Recent Files Example}

Definition at line 44 of file qmenu.h.

Signals
void	aboutToShow ()
void	aboutToHide ()
void	triggered (QAction *action)
void	hovered (QAction *action)
Public Member Functions
	QMenu (QWidget *parent=0)
	QMenu (const QString &title, QWidget *parent=0)
	~QMenu ()
QAction *	addAction (const QString &text)
QAction *	addAction (const QIcon &icon, const QString &text)
QAction *	addAction (const QString &text, const QObject *receiver, const char *member, const QKeySequence &shortcut=0)
QAction *	addAction (const QIcon &icon, const QString &text, const QObject *receiver, const char *member, const QKeySequence &shortcut=0)
QAction *	addMenu (QMenu *menu)
QMenu *	addMenu (const QString &title)
QMenu *	addMenu (const QIcon &icon, const QString &title)
QAction *	addSeparator ()
QAction *	insertMenu (QAction *before, QMenu *menu)
QAction *	insertSeparator (QAction *before)
bool	isEmpty () const
void	clear ()
void	setTearOffEnabled (bool)
bool	isTearOffEnabled () const
bool	isTearOffMenuVisible () const
void	hideTearOffMenu ()
void	setDefaultAction (QAction *)
QAction *	defaultAction () const
void	setActiveAction (QAction *act)
QAction *	activeAction () const
void	popup (const QPoint &pos, QAction *at=0)
QAction *	exec ()
QAction *	exec (const QPoint &pos, QAction *at=0)
QSize	sizeHint () const
QRect	actionGeometry (QAction *) const
QAction *	actionAt (const QPoint &) const
QAction *	menuAction () const
QString	title () const
void	setTitle (const QString &title)
QIcon	icon () const
void	setIcon (const QIcon &icon)
void	setNoReplayFor (QWidget *widget)
bool	separatorsCollapsible () const
void	setSeparatorsCollapsible (bool collapse)
Static Public Member Functions
static QAction *	exec (QList< QAction * > actions, const QPoint &pos, QAction *at=0)
Protected Member Functions
int	columnCount () const
void	changeEvent (QEvent *)
void	keyPressEvent (QKeyEvent *)
void	mouseReleaseEvent (QMouseEvent *)
void	mousePressEvent (QMouseEvent *)
void	mouseMoveEvent (QMouseEvent *)
void	wheelEvent (QWheelEvent *)
void	enterEvent (QEvent *)
void	leaveEvent (QEvent *)
void	hideEvent (QHideEvent *)
void	paintEvent (QPaintEvent *)
void	actionEvent (QActionEvent *)
void	timerEvent (QTimerEvent *)
bool	event (QEvent *)
bool	focusNextPrevChild (bool next)
Private Slots
void	internalSetSloppyAction ()
void	internalDelayedPopup ()
Private Member Functions
	Q_PRIVATE_SLOT (d_func(), void _q_actionTriggered()) Q_PRIVATE_SLOT(d_func()
Private Attributes
void friend class()) private	QMenuBarPrivate
Friends
class	QTornOffMenu
class	Q3PopupMenu
class	QComboBox

---

Constructor & Destructor Documentation

QMenu::QMenu

(

QWidget *

parent = 0

)

[explicit]

Constructs a menu with parent 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).

Definition at line 947 of file qmenu.cpp.

References d, QMenuPrivate::QMenuScroller::ScrollNone, QWidget::setAttribute(), QWidget::setMouseTracking(), QStyle::SH_Menu_MouseTracking, QStyle::SH_Menu_Scrollable, QWidget::style(), styleHint(), and Qt::WA_CustomWhatsThis.

Referenced by addMenu().

    : QWidget(*new QMenuPrivate, parent, Qt::Popup)
{
    Q_D(QMenu);
#ifndef QT_NO_WHATSTHIS
    setAttribute(Qt::WA_CustomWhatsThis);
#endif
    setMouseTracking(style()->styleHint(QStyle::SH_Menu_MouseTracking, 0, this));
    if (style()->styleHint(QStyle::SH_Menu_Scrollable, 0, this)) {
        d->scroll = new QMenuPrivate::QMenuScroller;
        d->scroll->scrollFlags = QMenuPrivate::QMenuScroller::ScrollNone;
    }
    d->menuAction = new QAction(this);
    d->menuAction->d_func()->menu = this;
}

Here is the call graph for this function:

QMenu::QMenu	(	const QString &	title,
		QWidget *	parent = 0
	)			[explicit]

Constructs a menu with a title and 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).

See also:

title

Definition at line 972 of file qmenu.cpp.

References d, QMenuPrivate::QMenuScroller::ScrollNone, QWidget::setAttribute(), QWidget::setMouseTracking(), QStyle::SH_Menu_MouseTracking, QStyle::SH_Menu_Scrollable, QWidget::style(), styleHint(), title(), and Qt::WA_CustomWhatsThis.

    : QWidget(*new QMenuPrivate, parent, Qt::Popup)
{
    Q_D(QMenu);
#ifndef QT_NO_WHATSTHIS
    setAttribute(Qt::WA_CustomWhatsThis);
#endif
    setMouseTracking(style()->styleHint(QStyle::SH_Menu_MouseTracking));
    if (style()->styleHint(QStyle::SH_Menu_Scrollable, 0, this)) {
        d->scroll = new QMenuPrivate::QMenuScroller;
        d->scroll->scrollFlags = QMenuPrivate::QMenuScroller::ScrollNone;
    }
    d->menuAction = new QAction(title, this);
    d->menuAction->d_func()->menu = this;
}

Here is the call graph for this function:

QMenu::~QMenu

(

)

Destroys the menu.

Definition at line 991 of file qmenu.cpp.

References d.

{
    Q_D(QMenu);
    if (d->eventLoop)
        d->eventLoop->exit();
    if (d->tornPopup)
        d->tornPopup->close();
}

---

Member Function Documentation

QAction * QMenu::addAction

(

const QString &

text

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This convenience function creates a new action with text. The function adds the newly created action to the menu's list of actions, and returns it.

See also:

QWidget::addAction()

Definition at line 1009 of file qmenu.cpp.

Referenced by QFileDialogPrivate::_q_showContextMenu(), addAction(), addAction(), QDesignerWorkbench::addFormWindow(), addMenu(), addSeparator(), MainWindow::addToMenu(), QtWindowListMenu::addWindow(), QDesignerMenu::adjustSpecialActions(), ColorSwatch::ColorSwatch(), MainWindow::contextMenuEvent(), SourceTextEdit::contextMenuEvent(), qdesigner_internal::QtBrushEditor::contextMenuEvent(), QScrollBar::contextMenuEvent(), qdesigner_internal::WidgetBoxTreeView::contextMenuEvent(), QPixelTool::contextMenuEvent(), qdesigner_internal::QtGradientStopsWidget::contextMenuEvent(), MainWindow::createDockWindows(), QVFb::createFileMenu(), QCalendarWidgetPrivate::createHeader(), MainWindow::createMenu(), Dialog::createMenu(), ImageViewer::createMenus(), MainWindow::createMenus(), qdesigner_internal::FormWindow::createPopupMenu(), QMainWindow::createPopupMenu(), Window::createPushButtonGroup(), QTextControl::createStandardContextMenu(), QLineEdit::createStandardContextMenu(), Window::createTrayIcon(), QVFb::createViewMenu(), exec(), QDesignerToolBar::handleContextMenuEvent(), QDesignerMenuBar::handleContextMenuEvent(), QDesignerMenu::handleContextMenuEvent(), QWorkspacePrivate::init(), QDesignerWorkbench::initialize(), HelpDialog::initialize(), Main::Main(), main(), MainWindow::MainWindow(), Q3MainWindow::menuAboutToShow(), QMultiInputContext::QMultiInputContext(), QTornOffMenu::QTornOffMenu(), QtWindowListMenu::QtWindowListMenu(), QUnicodeControlCharacterMenu::QUnicodeControlCharacterMenu(), QToolBar::resizeEvent(), MainWindow::setupDockWidgets(), TextEdit::setupEditActions(), TextEdit::setupFileActions(), MainWindow::setupFileMenu(), MainWindow::setupHelpMenu(), MainWindow::setupMenuBar(), TrWindow::setupMenuBar(), SpreadSheet::setupMenuBar(), MainWindow::setupMenus(), TextEdit::setupTextActions(), QDBusViewer::showContextMenu(), TextEdit::TextEdit(), ToolBar::ToolBar(), ColorSwatch::updateContextMenu(), and MainWindow::updateWindowMenu().

{
    QAction *ret = new QAction(text, this);
    addAction(ret);
    return ret;
}

QAction * QMenu::addAction	(	const QIcon &	icon,
		const QString &	text
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This convenience function creates a new action with an icon and some text. The function adds the newly created action to the menu's list of actions, and returns it.

See also:

QWidget::addAction()

Definition at line 1025 of file qmenu.cpp.

References addAction(), and icon().

{
    QAction *ret = new QAction(icon, text, this);
    addAction(ret);
    return ret;
}

Here is the call graph for this function:

QAction * QMenu::addAction	(	const QString &	text,
		const QObject *	receiver,
		const char *	member,
		const QKeySequence &	shortcut = 0
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This convenience function creates a new action with the text text and an optional shortcut shortcut. The action's {QAction::triggered()}{triggered()} signal is connected to the receiver's member slot. The function adds the newly created action to the menu's list of actions and returns it.

See also:

QWidget::addAction()

Definition at line 1043 of file qmenu.cpp.

References addAction(), QObject::connect(), QAction::setShortcut(), SIGNAL, and triggered().

{
    QAction *action = new QAction(text, this);
#ifdef QT_NO_SHORTCUT
    Q_UNUSED(shortcut);
#else
    action->setShortcut(shortcut);
#endif
    QObject::connect(action, SIGNAL(triggered()), receiver, member);
    addAction(action);
    return action;
}

Here is the call graph for this function:

QAction * QMenu::addAction	(	const QIcon &	icon,
		const QString &	text,
		const QObject *	receiver,
		const char *	member,
		const QKeySequence &	shortcut = 0
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This convenience function creates a new action with an icon and some text and an optional shortcut shortcut. The action's {QAction::triggered()}{triggered()} signal is connected to the member slot of the receiver object. The function adds the newly created action to the menu's list of actions, and returns it.

See also:

QWidget::addAction()

Definition at line 1067 of file qmenu.cpp.

References addAction(), QObject::connect(), icon(), QAction::setShortcut(), SIGNAL, and triggered().

{
    QAction *action = new QAction(icon, text, this);
#ifdef QT_NO_SHORTCUT
    Q_UNUSED(shortcut);
#else
    action->setShortcut(shortcut);
#endif
    QObject::connect(action, SIGNAL(triggered()), receiver, member);
    addAction(action);
    return action;
}

Here is the call graph for this function:

QAction * QMenu::addMenu

(

QMenu *

menu

)

This convenience function adds menu as a submenu to this menu. It returns the menus menuAction().

See also:

QWidget::addAction() QMenu::menuAction()

Definition at line 1086 of file qmenu.cpp.

References addAction(), and menuAction().

Referenced by QFileDialogPrivate::_q_showContextMenu(), ColorSwatch::ColorSwatch(), QTextControl::createStandardContextMenu(), QLineEdit::createStandardContextMenu(), QDesignerWorkbench::initialize(), QToolBar::resizeEvent(), and MainWindow::setupDockWidgets().

{
    QAction *action = menu->menuAction();
    addAction(action);
    return action;
}

Here is the call graph for this function:

QMenu * QMenu::addMenu

(

const QString &

title

)

Appends a new QMenu with title to the menu. The menu takes ownership of the menu. Returns the new menu.

See also:

QWidget::addAction() QMenu::menuAction()

Definition at line 1099 of file qmenu.cpp.

References addAction(), menuAction(), QMenu(), and title().

{
    QMenu *menu = new QMenu(title, this);
    addAction(menu->menuAction());
    return menu;
}

Here is the call graph for this function:

QMenu * QMenu::addMenu	(	const QIcon &	icon,
		const QString &	title
	)

Appends a new QMenu with icon and title to the menu. The menu takes ownership of the menu. Returns the new menu.

See also:

QWidget::addAction() QMenu::menuAction()

Definition at line 1112 of file qmenu.cpp.

References addAction(), icon(), menuAction(), QMenu(), setIcon(), and title().

{
    QMenu *menu = new QMenu(title, this);
    menu->setIcon(icon);
    addAction(menu->menuAction());
    return menu;
}

Here is the call graph for this function:

QAction * QMenu::addSeparator

(

)

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.

See also:

QWidget::addAction()

Definition at line 1128 of file qmenu.cpp.

References addAction(), and QAction::setSeparator().

Referenced by QFileDialogPrivate::_q_showContextMenu(), QDesignerWorkbench::addFormWindow(), ColorSwatch::ColorSwatch(), QScrollBar::contextMenuEvent(), QPixelTool::contextMenuEvent(), QVFb::createFileMenu(), MainWindow::createMenu(), ImageViewer::createMenus(), MainWindow::createMenus(), QMainWindow::createPopupMenu(), QTextControl::createStandardContextMenu(), QLineEdit::createStandardContextMenu(), Window::createTrayIcon(), QVFb::createViewMenu(), QDesignerToolBar::handleContextMenuEvent(), QDesignerMenuBar::handleContextMenuEvent(), QWorkspacePrivate::init(), QDesignerWorkbench::initialize(), Main::Main(), main(), Q3MainWindow::menuAboutToShow(), QtWindowListMenu::QtWindowListMenu(), MainWindow::setupDockWidgets(), TextEdit::setupEditActions(), TextEdit::setupFileActions(), MainWindow::setupMenuBar(), SpreadSheet::setupMenuBar(), TextEdit::setupTextActions(), ToolBar::ToolBar(), and MainWindow::updateWindowMenu().

{
    QAction *action = new QAction(this);
    action->setSeparator(true);
    addAction(action);
    return action;
}

Here is the call graph for this function:

QAction * QMenu::insertMenu	(	QAction *	before,
		QMenu *	menu
	)

This convenience function inserts menu before action before and returns the menus menuAction().

See also:

QWidget::insertAction(), addMenu()

Definition at line 1142 of file qmenu.cpp.

References QWidget::insertAction(), and menuAction().

Referenced by QDesignerWorkbench::initialize().

{
    QAction *action = menu->menuAction();
    insertAction(before, action);
    return action;
}

Here is the call graph for this function:

QAction * QMenu::insertSeparator

(

QAction *

before

)

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 before and returns it.

See also:

QWidget::insertAction(), addSeparator()

Definition at line 1157 of file qmenu.cpp.

References QWidget::insertAction(), and QAction::setSeparator().

Referenced by Main::Main(), and Q3FileDialog::popupContextMenu().

{
    QAction *action = new QAction(this);
    action->setSeparator(true);
    insertAction(before, action);
    return action;
}

Here is the call graph for this function:

bool QMenu::isEmpty

(

)

const

Since:

4.2

Returns true if there are no actions inserted into the menu, false otherwise.

See also:

QWidget::actions()

Definition at line 1274 of file qmenu.cpp.

References QWidget::actions(), and QList< T >::isEmpty().

{
    return actions().isEmpty();
}

Here is the call graph for this function:

void QMenu::clear

(

)

Removes all the menu's actions. Actions owned by the menu and not shown in any other widget are deleted.

See also:

removeAction()

Definition at line 1285 of file qmenu.cpp.

References QWidget::actions(), i, QList< T >::isEmpty(), QObject::parent(), QWidget::removeAction(), and QList< T >::size().

Referenced by Q3ComboBox::clear(), Q3ToolBar::createPopup(), Q3MainWindow::menuAboutToShow(), Q3ComboBox::popup(), QToolBar::resizeEvent(), ColorSwatch::updateContextMenu(), and MainWindow::updateWindowMenu().

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

Here is the call graph for this function:

void QMenu::setTearOffEnabled

(

bool

)

Definition at line 1198 of file qmenu.cpp.

References d, QWidget::isVisible(), QWidget::resize(), and sizeHint().

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

Here is the call graph for this function:

bool QMenu::isTearOffEnabled

(

)

const

Definition at line 1212 of file qmenu.cpp.

{
    return d_func()->tearoff;
}

bool QMenu::isTearOffMenuVisible

(

)

const

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.

See also:

hideTearOffMenu() isTearOffEnabled()

Definition at line 1224 of file qmenu.cpp.

{
    if (d_func()->tornPopup)
        return d_func()->tornPopup->isVisible();
    return false;
}

void QMenu::hideTearOffMenu

(

)

This function will forcibly hide the torn off menu making it disappear from the users desktop.

See also:

isTearOffMenuVisible() isTearOffEnabled()

Definition at line 1237 of file qmenu.cpp.

{
    if (d_func()->tornPopup)
        d_func()->tornPopup->close();
}

void QMenu::setDefaultAction

(

QAction *

act

)

This will set the default action to 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.

See also:

defaultAction()

Definition at line 1173 of file qmenu.cpp.

{
    d_func()->defaultAction = act;
}

QAction * QMenu::defaultAction

(

)

const

Returns the current default action.

See also:

setDefaultAction()

Definition at line 1183 of file qmenu.cpp.

{
    return d_func()->defaultAction;
}

void QMenu::setActiveAction

(

QAction *

act

)

Sets the currently highlighted action to act.

Definition at line 1247 of file qmenu.cpp.

References d, and QMenuPrivate::QMenuScroller::ScrollCenter.

Referenced by QAccessibleMenu::doAction().

{
    Q_D(QMenu);
    d->setCurrentAction(act, 0);
    if (d->scroll)
        d->scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollCenter);
}

QAction * QMenu::activeAction

(

)

const

Returns the currently highlighted action, or 0 if no action is currently highlighted.

Definition at line 1260 of file qmenu.cpp.

{
    return d_func()->currentAction;
}

void QMenu::popup	(	const QPoint &	p,
		QAction *	atAction = 0
	)

Displays the menu so that the action atAction will be at the specified global position 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.

See also:

QWidget::mapToGlobal(), exec()

Definition at line 1377 of file qmenu.cpp.

References aboutToShow(), QRect::bottom(), d, QApplication::desktop(), QEffects::DownScroll, emit, QWidget::ensurePolished(), QWidget::height(), QRect::height(), QSize::height(), i, int, QApplication::isEffectEnabled(), QRect::left(), QEffects::LeftScroll, m, p, QStyle::pixelMetric(), QStyle::PM_MenuDesktopFrameWidth, QAccessible::PopupMenuStart, QCursor::pos(), QWidget::pos(), qApp, qFadeEffect(), qMax(), qMin(), qScrollEffect(), QRect::right(), QEffects::RightScroll, Qt::RightToLeft, QMenuPrivate::QMenuScroller::ScrollDown, QMenuPrivate::QMenuScroller::ScrollNone, QMenuPrivate::QMenuScroller::ScrollUp, QWidget::setGeometry(), QSize::setHeight(), QPoint::setX(), QPoint::setY(), QStyle::SH_Menu_FillScreenWithScroll, QWidget::show(), QWidget::size(), sizeHint(), QWidget::style(), styleHint(), QRect::top(), Qt::UI_AnimateMenu, Qt::UI_FadeMenu, QAccessible::updateAccessibility(), QEffects::UpScroll, QSize::width(), QPoint::x(), QRect::y(), QPoint::y(), and QWidget::y().

Referenced by QWorkspacePrivate::_q_popupOperationMenu(), QWorkspacePrivate::_q_showOperationMenu(), SourceTextEdit::contextMenuEvent(), exec(), Q3ComboBox::popup(), and Q3ActionGroupPrivate::update().

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

    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);
    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();
    const bool snapToMouse = (p == mouse);

    //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() > screen.right()-desktopFrame)
            pos.setX(qMax(p.x()-size.width(), screen.right()-desktopFrame-size.width()));
    } else {
        if (pos.x()+size.width() > screen.right()-desktopFrame)
            pos.setX(qMin(p.x()-size.width(), screen.right()-desktopFrame-size.width()));
        if (pos.x() < screen.left()+desktopFrame)
            pos.setX(qMax(p.x(), screen.left() + desktopFrame));
    }
    if (pos.y() + size.height() > screen.bottom() - desktopFrame) {
        if(snapToMouse)
            pos.setY(qMin(mouse.y() - (size.height() + desktopFrame), screen.bottom()-desktopFrame-size.height()));
        else
            pos.setY(qMax(p.y() - (size.height() + desktopFrame), screen.bottom()-desktopFrame-size.height()));
    } else if (pos.y() < screen.top()) {
        pos.setY(screen.top());
    }

    if (pos.y() < screen.top())
        pos.setY(screen.top());
    if (pos.y()+size.height() > screen.bottom() - desktopFrame) {
        if (d->scroll) {
            d->scroll->scrollFlags |= uint(QMenuPrivate::QMenuScroller::ScrollDown);
            int y = qMax(screen.y(),pos.y());
            size.setHeight(screen.height()-desktopFrame*2-y);
        } else {
            // Too big for screen, bias to see bottom of menu (for some reason)
            pos.setY(screen.bottom()-size.height());
        }
    }
    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
}

Here is the call graph for this function:

QAction * QMenu::exec

(

)

Executes this menu synchronously.

This is equivalent to {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:

      exec(QCursor::pos());

or aligned to a widget:

      exec(somewidget.mapToGlobal(QPoint(0,0)));

or in reaction to a QMouseEvent *e:

      exec(e->globalPos());

Definition at line 1545 of file qmenu.cpp.

References QWidget::createWinId(), and QWidget::pos().

Referenced by QFileDialogPrivate::_q_showContextMenu(), QMainWindow::contextMenuEvent(), QTextControlPrivate::contextMenuEvent(), MainWindow::contextMenuEvent(), QMessageBoxDetailsText::TextEdit::contextMenuEvent(), ColorSwatch::contextMenuEvent(), qdesigner_internal::QtBrushEditor::contextMenuEvent(), QScrollBar::contextMenuEvent(), qdesigner_internal::WidgetBoxTreeView::contextMenuEvent(), QPixelTool::contextMenuEvent(), qdesigner_internal::QtGradientStopsWidget::contextMenuEvent(), QLabel::contextMenuEvent(), QWidget::event(), exec(), Q3PopupMenu::exec(), QDesignerToolBar::handleContextMenuEvent(), QDesignerMenuBar::handleContextMenuEvent(), QDesignerMenu::handleContextMenuEvent(), Q3TextEdit::pickSpecial(), QVFb::popupMenu(), QDBusViewer::showContextMenu(), HelpDialog::showIndexItemMenu(), HelpDialog::showListItemMenu(), and HelpDialog::showTreeItemMenu().

{
    createWinId();
    return exec(pos());
}

Here is the call graph for this function:

QAction * QMenu::exec	(	const QPoint &	p,
		QAction *	action = 0
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Executes this menu synchronously.

Pops up the menu so that the action action will be at the specified global position 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:

        exec(QCursor::pos());

or aligned to a widget:

        exec(somewidget.mapToGlobal(QPoint(0, 0)));

or in reaction to a QMouseEvent *e:

      exec(e->globalPos());

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.

See also:

popup(), QWidget::mapToGlobal()

Definition at line 1593 of file qmenu.cpp.

References d, QEventLoop::exec(), QPointer< T >::isNull(), p, and popup().

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

Here is the call graph for this function:

QAction * QMenu::exec	(	QList< QAction * >	actions,
		const QPoint &	pos,
		QAction *	at = 0
	)			[static]

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Executes this menu synchronously.

The menu's actions are specified by the list of actions. The menu will pop up so that the specified action, at, appears at global position pos. If at is not specified then the menu appears at position 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:

       QMenu menu;
       QAction *at = actions[0]; // Assumes actions is not empty
       foreach (QAction *a, actions)
          menu.addAction(a);
       menu.exec(pos, at);

See also:

popup(), QWidget::mapToGlobal()

Definition at line 1636 of file qmenu.cpp.

References QWidget::actions(), addAction(), QList< T >::begin(), QList< T >::end(), exec(), and QWidget::pos().

{
    QMenu menu;
    for(QList<QAction*>::Iterator it = actions.begin(); it != actions.end(); ++it)
        menu.addAction((*it));
    return menu.exec(pos, at);
}

Here is the call graph for this function:

QSize QMenu::sizeHint

(

)

const [virtual]

Reimplemented from QWidget.

Definition at line 1328 of file qmenu.cpp.

References QMap< Key, T >::constBegin(), QMap< Key, T >::constEnd(), QStyle::CT_Menu, d, QWidget::ensurePolished(), QApplication::globalStrut(), i, QWidget::palette(), QStyleOption::palette, QStyle::pixelMetric(), QStyle::PM_MenuHMargin, QStyle::PM_MenuPanelWidth, QStyle::PM_MenuTearoffHeight, QStyle::PM_MenuVMargin, QStyleOption::rect, QWidget::rect(), s, QStyle::sizeFromContents(), QStyleOption::state, QStyle::State_None, and QWidget::style().

Referenced by QWorkspacePrivate::_q_showOperationMenu(), QTornOffMenu::actionEvent(), actionEvent(), changeEvent(), Q3ToolBar::createPopup(), popup(), setTearOffEnabled(), and Q3ComboBox::sizeHint().

{
    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;
    }
    s.rwidth() += 2 * style()->pixelMetric(QStyle::PM_MenuHMargin, &opt, this);
    s.rheight() += 2 * 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);
}

Here is the call graph for this function:

QRect QMenu::actionGeometry

(

QAction *

act

)

const

Returns the geometry of action act.

Definition at line 1320 of file qmenu.cpp.

Referenced by QDesignerMenu::actionAtPosition(), QDesignerMenu::dragMoveEvent(), QDesignerMenu::paintEvent(), QAccessibleMenu::rect(), QDesignerMenu::showLineEdit(), QDesignerMenu::slotShowSubMenuNow(), and QDesignerMenu::subMenuPixmapRect().

{
    return d_func()->actionRect(act);
}

QAction * QMenu::actionAt

(

const QPoint &

pt

)

const

Returns the item at pt; returns 0 if there is no item there.

Definition at line 1310 of file qmenu.cpp.

Referenced by QAccessibleMenu::childAt().

{
    if (QAction *ret = d_func()->actionAt(pt))
        return ret;
    return 0;
}

QAction * QMenu::menuAction

(

)

const

Returns the action associated with this menu.

Definition at line 453 of file qmenu.cpp.

Referenced by QMultiInputContext::actions(), QMenuBar::addMenu(), addMenu(), Q3ActionGroup::addTo(), qdesigner_internal::QDesignerResource::create(), QDesignerMenu::createRealMenuAction(), QMenuBar::insertMenu(), insertMenu(), QDesignerMenu::safeMenuAction(), QToolButton::setMenu(), MainWindow::setup(), and ToolBar::ToolBar().

{
    return d_func()->menuAction;
}

QString QMenu::title

(

)

const

Definition at line 465 of file qmenu.cpp.

Referenced by addMenu(), QDesignerMenu::createRealMenuAction(), and QMenu().

{
    return d_func()->menuAction->text();
}

void QMenu::setTitle

(

const QString &

title

)

Definition at line 470 of file qmenu.cpp.

Referenced by QtWindowListMenu::addTo(), ColorSwatch::ColorSwatch(), QDesignerMenu::createRealMenuAction(), and QUnicodeControlCharacterMenu::QUnicodeControlCharacterMenu().

{
    d_func()->menuAction->setText(text);
}

QIcon QMenu::icon

(

)

const

Definition at line 482 of file qmenu.cpp.

Referenced by addAction(), addMenu(), QtWindowListMenu::addWindow(), QtWindowListMenu::setCascadeIcon(), QtWindowListMenu::setCloseAllIcon(), QtWindowListMenu::setCloseIcon(), QtWindowListMenu::setDefaultIcon(), setIcon(), QtWindowListMenu::setTileIcon(), and QtWindowListMenu::setWindowIcon().

{
    return d_func()->menuAction->icon();
}

void QMenu::setIcon

(

const QIcon &

icon

)

Definition at line 487 of file qmenu.cpp.

References icon().

Referenced by QMenuBar::addMenu(), addMenu(), and ToolBar::ToolBar().

{
    d_func()->menuAction->setIcon(icon);
}

Here is the call graph for this function:

void QMenu::setNoReplayFor

(

QWidget *

widget

)

Definition at line 2537 of file qmenu.cpp.

{
    d_func()->noReplayFor = noReplayFor;
}

bool QMenu::separatorsCollapsible

(

)

const

Definition at line 2552 of file qmenu.cpp.

References d.

{
    Q_D(const QMenu);
    return d->collapsibleSeparators;
}

void QMenu::setSeparatorsCollapsible

(

bool

collapse

)

Definition at line 2558 of file qmenu.cpp.

References d, QWidget::isVisible(), and QWidget::update().

{
    Q_D(QMenu);
    d->collapsibleSeparators = collapse;
    d->itemsDirty = 1;
    if (isVisible()) {
        d->updateActions();
        update();
    }
}

Here is the call graph for this function:

void QMenu::aboutToShow

(

)

[signal]

This signal is emitted just before the menu is shown to the user.

See also:

aboutToHide(), show()

Referenced by popup().

void QMenu::aboutToHide

(

)

[signal]

Since:

4.2

This signal is emitted just before the menu is hidden from the user.

See also:

aboutToShow(), hide()

Referenced by hideEvent().

void QMenu::triggered

(

QAction *

action

)

[signal]

This signal is emitted when a menu action is triggered; action is the action that caused the signal to be emitted.

Normally, you connect each menu action's {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".

See also:

hovered(), QAction::triggered()

Referenced by actionEvent(), addAction(), QtWindowListMenu::addWindow(), and QDesignerMenu::handleContextMenuEvent().

void QMenu::hovered

(

QAction *

action

)

[signal]

This signal is emitted when a menu action is highlighted; action is the action that caused the signal to be emitted.

Often this is used to update status information.

See also:

triggered(), QAction::hovered()

Referenced by actionEvent().

int QMenu::columnCount

(

)

const [protected]

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.

Definition at line 1302 of file qmenu.cpp.

{
    return d_func()->ncols;
}

void QMenu::changeEvent

(

QEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1837 of file qmenu.cpp.

References QWidget::changeEvent(), d, QEvent::EnabledChange, QEvent::FontChange, QWidget::isEnabled(), QWidget::isVisible(), QEvent::LayoutDirectionChange, QWidget::resize(), QMenuPrivate::QMenuScroller::ScrollNone, QWidget::setMouseTracking(), QStyle::SH_Menu_MouseTracking, QStyle::SH_Menu_Scrollable, sizeHint(), QWidget::style(), QEvent::StyleChange, styleHint(), and QEvent::type().

{
    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());
    }
    QWidget::changeEvent(e);
}

Here is the call graph for this function:

void QMenu::keyPressEvent

(

QKeyEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1913 of file qmenu.cpp.

References QEvent::accept(), Qt::AltModifier, QString::at(), c, Qt::CaseInsensitive, QRect::center(), QWidget::close(), d, QWhatsThis::enterWhatsThisMode(), QWidget::height(), QWidget::hide(), i, QEvent::ignore(), QString::indexOf(), int, QWidget::isRightToLeft(), QKeyEvent::key(), key, Qt::Key_Alt, Qt::Key_Back, Qt::Key_Control, Qt::Key_Down, Qt::Key_End, Qt::Key_Enter, Qt::Key_Escape, Qt::Key_F1, Qt::Key_Home, Qt::Key_Left, Qt::Key_Meta, Qt::Key_PageDown, Qt::Key_PageUp, Qt::Key_Return, Qt::Key_Right, Qt::Key_Select, Qt::Key_Shift, Qt::Key_Space, Qt::Key_Tab, Qt::Key_Up, QRect::left(), QString::length(), m, QAction::menu(), QKeySequence::mnemonic(), QKeyEvent::modifiers(), next, QStyle::pixelMetric(), QStyle::PM_MenuScrollerHeight, QStyle::PM_MenuTearoffHeight, qApp, QRect::right(), QMenuPrivate::QMenuScroller::ScrollBottom, QMenuPrivate::QMenuScroller::ScrollDown, QMenuPrivate::QMenuScroller::ScrollStay, QMenuPrivate::QMenuScroller::ScrollTop, QMenuPrivate::QMenuScroller::ScrollUp, QMenuPrivate::SelectedFromElsewhere, QMenuPrivate::SelectedFromKeyboard, QCoreApplication::sendEvent(), QStyle::SH_Menu_AllowActiveAndDisabled, QStyle::SH_Menu_KeyboardSearch, QStyle::SH_Menu_SelectionWrap, QStyle::SH_Menu_SpaceActivatesItem, QStyle::SH_MenuBar_AltKeyNavigation, Qt::ShiftModifier, QWidget::style(), QStyle::styleHint(), styleHint(), QKeyEvent::text(), QAction::text(), QChar::toUpper(), QAction::Trigger, QWidget::width(), QWidget::x(), QPoint::y(), and QWidget::y().

Referenced by event(), and focusNextPrevChild().

{
    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;
    }
    if (key == Qt::Key_Tab) //means down
        key = Qt::Key_Down;

    bool key_consumed = false;
    switch(key) {
#ifdef Q_WS_MAC
    case Qt::Key_PageUp:
#endif
    case Qt::Key_Home:
        key_consumed = true;
        if (d->scroll) {
            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())) {
                    if(d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)
                        d->scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollTop, true);
                    else
                        d->setCurrentAction(act, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);
                    break;
                }
            }
        }
        break;
#ifdef Q_WS_MAC
    case Qt::Key_PageDown:
#endif
    case Qt::Key_End:
        key_consumed = true;
        if (d->scroll) {
            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())) {
                    if(d->scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown)
                        d->scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollBottom, true);
                    else
                        d->setCurrentAction(act, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);
                    break;
                }
            }
        }
        break;
#ifndef Q_WS_MAC
    case Qt::Key_PageUp:
        key_consumed = true;
        if (d->currentAction && d->scroll)
            d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollUp, true, true);
        break;
    case Qt::Key_PageDown:
        key_consumed = true;
        if (d->currentAction && d->scroll)
            d->scrollMenu(QMenuPrivate::QMenuScroller::ScrollDown, true, true);
        break;
#endif
    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->setFirstActionActive();
            key_consumed = true;
            break;
        }
        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 && d->causedPopup.widget &&
            qobject_cast<QMenu*>(d->causedPopup.widget)) {
            QPointer<QWidget> caused = d->causedPopup.widget;
            hide();
            if (caused)
                caused->setFocus();
            key_consumed = true;
        }
        break; }

    case Qt::Key_Alt:
        key_consumed = true;
        if ( style()->styleHint(QStyle::SH_MenuBar_AltKeyNavigation, 0, this))
        {
            hide();
#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;
            hide(); //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;
        }

        for(QWidget *caused = this; caused;) {
            if (QMenu *m = qobject_cast<QMenu*>(caused)) {
                QAction *currentAction = d->currentAction;
                if(currentAction && (!currentAction->isEnabled() || currentAction->menu() || currentAction->isSeparator()))
                    currentAction = 0;
                caused = m->d_func()->causedPopup.widget;
                if (m->d_func()->eventLoop)
                    m->d_func()->syncAction = currentAction; // synchronous operation
            } else {
                break;
            }
        }

        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;
                d->setCurrentAction(nextAction, 20, QMenuPrivate::SelectedFromElsewhere, true);
                if (!nextAction->menu() && activateAction)
                    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();
}

Here is the call graph for this function:

void QMenu::mouseReleaseEvent

(

QMouseEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1804 of file qmenu.cpp.

References d, m, QAction::menu(), QMouseEvent::pos(), and QAction::Trigger.

{
    Q_D(QMenu);
    if (d->mouseEventTaken(e))
        return;

    d->mouseDown = false;
    QAction *action = d->actionAt(e->pos());
    for(QWidget *caused = this; caused;) {
        if (QMenu *m = qobject_cast<QMenu*>(caused)) {
            QAction *currentAction = d->currentAction;
            if(currentAction && (!currentAction->isEnabled() || currentAction->menu() || currentAction->isSeparator()))
                currentAction = 0;
            caused = m->d_func()->causedPopup.widget;
            if (m->d_func()->eventLoop)
                m->d_func()->syncAction = currentAction; // synchronous operation
        } else {
            break;
        }
    }
    if (action && action == d->currentAction) {
        if (action->menu())
            action->menu()->d_func()->setFirstActionActive();
        else
            d->activateAction(action, QAction::Trigger);
    } else if (d->motions > 6) {
        d->hideUpToMenuBar();
    }
}

Here is the call graph for this function:

void QMenu::mousePressEvent

(

QMouseEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1780 of file qmenu.cpp.

References d, QMouseEvent::globalPos(), QMouseEvent::pos(), QWidget::rect(), QWidget::setAttribute(), QWidget::update(), and Qt::WA_NoMouseReplay.

{
    Q_D(QMenu);
    if (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 = true;

    QAction *action = d->actionAt(e->pos());
    d->setCurrentAction(action, 20);
    update();
}

Here is the call graph for this function:

void QMenu::mouseMoveEvent

(

QMouseEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 2293 of file qmenu.cpp.

References QMouseEvent::buttons(), QRect::contains(), d, QWidget::isVisible(), Qt::LeftButton, QMouseEvent::pos(), QWidget::rect(), QStyle::SH_Menu_SubMenuPopupDelay, QMenuPrivate::sloppyDelayTimer, QBasicTimer::start(), QWidget::style(), and styleHint().

{
    Q_D(QMenu);
    if (!isVisible() || 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 {
        d->mouseDown = e->buttons() & Qt::LeftButton;
    }
    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));
    }
}

Here is the call graph for this function:

void QMenu::wheelEvent

(

QWheelEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1768 of file qmenu.cpp.

References d, QWheelEvent::delta(), QWheelEvent::pos(), QWidget::rect(), QMenuPrivate::QMenuScroller::ScrollDown, and QMenuPrivate::QMenuScroller::ScrollUp.

{
    Q_D(QMenu);
    if (d->scroll && rect().contains(e->pos()))
        d->scrollMenu(e->delta() > 0 ?
                      QMenuPrivate::QMenuScroller::ScrollUp : QMenuPrivate::QMenuScroller::ScrollDown);
}

Here is the call graph for this function:

void QMenu::enterEvent

(

QEvent *

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 2322 of file qmenu.cpp.

{
    d_func()->motions = -1; // force us to ignore the generate mouse move in mouseMoveEvent()
}

void QMenu::leaveEvent

(

QEvent *

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 2330 of file qmenu.cpp.

References d.

{
    Q_D(QMenu);
    d->sloppyAction = 0;
    if (!d->sloppyRegion.isEmpty())
        d->sloppyRegion = QRegion();
}

void QMenu::hideEvent

(

QHideEvent *

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1647 of file qmenu.cpp.

References aboutToHide(), d, emit, QAccessible::PopupMenuEnd, and QAccessible::updateAccessibility().

{
    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 = false;
    d->hasHadMouse = false;
    d->causedPopup.widget = 0;
    d->causedPopup.action = 0;
}

Here is the call graph for this function:

void QMenu::paintEvent

(

QPaintEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1670 of file qmenu.cpp.

References QStyle::CE_MenuEmptyArea, QStyle::CE_MenuItem, QStyle::CE_MenuScroller, QStyle::CE_MenuTearoff, QStyleOptionMenuItem::checkType, d, QStyle::drawControl(), QStyle::drawPrimitive(), QStyleOptionMenuItem::EmptyArea, QWidget::height(), i, QStyleOption::initFrom(), QRect::intersects(), QStyleOptionFrame::lineWidth, QStyleOptionMenuItem::maxIconWidth, QStyleOptionMenuItem::menuItemType, QStyleOptionMenuItem::menuRect, QStyleOptionFrame::midLineWidth, QStyleOptionMenuItem::NotCheckable, p, QWidget::palette(), QStyleOption::palette, QStyle::PE_FrameMenu, QStyle::pixelMetric(), QStyle::PM_MenuPanelWidth, QStyle::PM_MenuScrollerHeight, QStyle::PM_MenuTearoffHeight, QPaintEvent::rect(), QStyleOption::rect, QWidget::rect(), QMenuPrivate::QMenuScroller::ScrollDown, QStyleOptionMenuItem::Scroller, QMenuPrivate::QMenuScroller::ScrollUp, QRect::setRect(), QStyleOption::state, QStyle::State_DownArrow, QStyle::State_Enabled, QStyle::State_None, QStyle::State_Selected, QWidget::style(), QStyleOptionMenuItem::tabWidth, QStyleOptionMenuItem::TearOff, QRect::translate(), and QWidget::width().

Referenced by QDesignerMenu::paintEvent().

{
    Q_D(QMenu);
    QPainter p(this);
    QRegion emptyArea = QRegion(rect());

    //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 = d->getStyleOption(action);
        opt.rect = adjustedActionRect;
        style()->drawControl(QStyle::CE_MenuItem, &opt, &p, this);
    }

    const int fw = style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, this);
    QStyleOptionMenuItem menuOpt;
    menuOpt.initFrom(this);
    menuOpt.palette = palette();
    menuOpt.state = QStyle::State_None;
    menuOpt.checkType = QStyleOptionMenuItem::NotCheckable;
    menuOpt.menuRect = rect();
    menuOpt.maxIconWidth = 0;
    menuOpt.tabWidth = 0;
    //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);
}

Here is the call graph for this function:

void QMenu::actionEvent

(

QActionEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 2363 of file qmenu.cpp.

References QActionEvent::action(), QEvent::ActionAdded, QEvent::ActionChanged, QEvent::ActionRemoved, QActionEvent::before(), QObject::connect(), d, QObject::disconnect(), hovered(), QWidget::isVisible(), QWidget::resize(), QWidget::setAttribute(), SIGNAL, sizeHint(), SLOT, triggered(), QEvent::type(), QWidget::update(), and Qt::WA_Resized.

Referenced by QDesignerMenu::actionEvent(), and QTornOffMenu::actionEvent().

{
    Q_D(QMenu);
    d->itemsDirty = 1;
    setAttribute(Qt::WA_Resized, false);
    if (d->tornPopup)
        d->tornPopup->syncWithMenu(this, e);
    if (e->type() == QEvent::ActionAdded) {
        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);
        }
    }

#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 (isVisible()) {
        d->updateActions();
  resize(sizeHint());
        update();
    }
}

Here is the call graph for this function:

void QMenu::timerEvent

(

QTimerEvent *

e

)

[protected, virtual]

Reimplemented from QObject.

Definition at line 2342 of file qmenu.cpp.

References d, internalDelayedPopup(), internalSetSloppyAction(), QMenuPrivate::menuDelayTimer, QMenuPrivate::QMenuScroller::ScrollNone, QMenuPrivate::sloppyDelayTimer, QTimerEvent::timerId(), and timerId.

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

Here is the call graph for this function:

bool QMenu::event

(

QEvent *

e

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1866 of file qmenu.cpp.

References d, QWidget::event(), Qt::Key_Backtab, Qt::Key_Tab, QEvent::KeyPress, keyPressEvent(), QEvent::QueryWhatsThis, QEvent::Resize, QEvent::setAccepted(), QEvent::Show, and QEvent::type().

Referenced by QDesignerMenu::actionEvent(), QDesignerMenu::dragEnterEvent(), QDesignerMenu::dragMoveEvent(), QDesignerMenu::dropEvent(), QDesignerMenu::eventFilter(), QDesignerMenu::handleContextMenuEvent(), QDesignerMenu::handleEvent(), QDesignerMenu::handleMouseDoubleClickEvent(), QDesignerMenu::handleMouseMoveEvent(), QDesignerMenu::handleMousePressEvent(), QDesignerMenu::handleMouseReleaseEvent(), QDesignerMenu::keyPressEvent(), QDesignerMenu::keyReleaseEvent(), and QDesignerMenu::paintEvent().

{
    Q_D(QMenu);
    switch (e->type()) {
    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::Resize:
        d->itemsDirty = 1;
        d->updateActions();
        break;
    case QEvent::Show:
        d->updateActions();
        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);
}

Here is the call graph for this function:

bool QMenu::focusNextPrevChild

(

bool

next

)

[protected, virtual]

Reimplemented from QWidget.

Definition at line 1902 of file qmenu.cpp.

References Qt::Key_Backtab, Qt::Key_Tab, QEvent::KeyPress, keyPressEvent(), Qt::NoModifier, and QWidget::setFocus().

{
    setFocus();
    QKeyEvent ev(QEvent::KeyPress, next ? Qt::Key_Tab : Qt::Key_Backtab, Qt::NoModifier);
    keyPressEvent(&ev);
    return true;
}

Here is the call graph for this function:

void QMenu::internalSetSloppyAction

(

)

[private, slot]

Definition at line 2413 of file qmenu.cpp.

Referenced by timerEvent().

{
    if (d_func()->sloppyAction)
        d_func()->setCurrentAction(d_func()->sloppyAction, 0);
}

void QMenu::internalDelayedPopup

(

)

[private, slot]

Definition at line 2422 of file qmenu.cpp.

References d, QApplication::desktop(), QWidget::geometry(), i, QWidget::isRightToLeft(), QWidget::mapFromGlobal(), QWidget::mapToGlobal(), QCursor::pos(), QWidget::pos(), right(), QDesktopWidget::screenNumber(), QStyle::SH_Menu_SloppySubMenus, QWidget::style(), styleHint(), QPoint::x(), QWidget::x(), and QPoint::y().

Referenced by timerEvent().

{
    Q_D(QMenu);

    //hide the current item
    if (QMenu *menu = d->activeMenu) {
        d->activeMenu = 0;
        menu->hide();
    }

    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;

    const QRect actionRect(d->actionRect(d->currentAction));
    const QSize menuSize(d->activeMenu->sizeHint());
    const QPoint rightPos(mapToGlobal(QPoint(actionRect.right(), actionRect.top())));
    const QPoint leftPos(mapToGlobal(QPoint(actionRect.left() - 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);
}

QMenu::Q_PRIVATE_SLOT	(	d_func()	,
		void	_q_actionTriggered()
	)			[private]

Reimplemented from QWidget.

---

Friends And Related Function Documentation

friend class QTornOffMenu [friend]

Definition at line 366 of file qmenu.h.

friend class Q3PopupMenu [friend]

Definition at line 367 of file qmenu.h.

friend class QComboBox [friend]

Definition at line 368 of file qmenu.h.

---

Member Data Documentation

void friend class ()) private QMenu::QMenuBarPrivate [private]

Definition at line 150 of file qmenu.h.

---

The documentation for this class was generated from the following files:

• src/gui/widgets/qmenu.h
• src/gui/widgets/qmenu.cpp

---