#include <qmenu_p.h>

Inheritance diagram for QMenuPrivate:

Classes
struct	QMacMenuPrivate

struct	QMenuCaused

struct	QMenuScroller

struct	QWceMenuPrivate

Public Types
enum	SelectionReason { SelectedFromKeyboard, SelectedFromElsewhere }

Public Types inherited from QWidgetPrivate
enum	CloseMode { CloseNoEvent, CloseWithEvent, CloseWithSpontaneousEvent }

enum	Direction { DirectionNorth = 0x01, DirectionEast = 0x10, DirectionSouth = 0x02, DirectionWest = 0x20 }

enum	DrawWidgetFlags { DrawAsRoot = 0x01, DrawPaintOnScreen = 0x02, DrawRecursive = 0x04, DrawInvisible = 0x08, DontSubtractOpaqueChildren = 0x10, DontSetCompositionMode = 0x20, DontDrawOpaqueChildren = 0x40, DontDrawNativeChildren = 0x80 }

Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Public Functions
void	_q_actionHovered ()

void	_q_actionTriggered ()

void	_q_overrideMenuActionDestroyed ()

QAction *	actionAt (QPoint p) const

QAction *	actionAt (int i) const

QRect	actionRect (QAction *) const

void	activateAction (QAction *, QAction::ActionEvent, bool self=true)

void	activateCausedStack (const QList< QPointer< QWidget > > &, QAction *, QAction::ActionEvent, bool)

QSize	adjustMenuSizeForScreen (const QRect &screen)

virtual QList< QPointer< QWidget > >	calcCausedStack () const

int	getLastVisibleAction () const

bool	hasMouseMoved (const QPoint &globalPos)

void	hideMenu (QMenu *menu, bool justRegister=false)

void	hideUpToMenuBar ()

int	indexOf (QAction *act) const

void	init ()

OSMenuRef	macMenu (OSMenuRef merge)

bool	mouseEventTaken (QMouseEvent *)

void	popupAction (QAction *, int, bool)

QRect	popupGeometry (const QWidget *widget) const

QRect	popupGeometry (int screen=-1) const

	QMenuPrivate ()

int	scrollerHeight () const

void	scrollMenu (QMenuScroller::ScrollLocation location, bool active=false)

void	scrollMenu (QMenuScroller::ScrollDirection direction, bool page=false, bool active=false)

void	scrollMenu (QAction *action, QMenuScroller::ScrollLocation location, bool active=false)

void	setCurrentAction (QAction *, int popup=-1, SelectionReason reason=SelectedFromElsewhere, bool activateFirst=false)

void	setFirstActionActive ()

void	setMacMenuEnabled (bool enable=true)

void	setOverrideMenuAction (QAction *)

void	setSyncAction ()

void	syncSeparatorsCollapsible (bool collapsible)

QWidget *	topCausedWidget () const

void	updateActionRects () const

void	updateActionRects (const QRect &screen) const

void	updateLayoutDirection ()

QAction *	wceCommands (uint command)

HMENU	wceMenu ()

	~QMenuPrivate ()

Public Functions inherited from QWidgetPrivate
void	_q_showIfNotHidden ()

virtual void	aboutToDestroy ()

void	activateChildLayoutsRecursively ()

QSize	adjustedSize () const

void	adjustQuitOnCloseAttribute ()

QInputContext *	assignedInputContext () const

QPainter *	beginSharedPainter ()

QWidget *	childAt_helper (const QPoint &, bool) const

QWidget *	childAtRecursiveHelper (const QPoint &p, bool, bool includeFrame=false) const

QRect	clipRect () const

QRegion	clipRegion () const

void	clipToEffectiveMask (QRegion &region) const

bool	close_helper (CloseMode mode)

void	create_sys (WId window, bool initializeWindow, bool destroyOldWindow)

QWindowSurface *	createDefaultWindowSurface ()

QWindowSurface *	createDefaultWindowSurface_sys ()

void	createExtra ()
	Creates the widget extra data. More...

void	createRecursively ()

void	createSysExtra ()

void	createTLExtra ()

void	createTLSysExtra ()

void	createWinId (WId id=0)

void	deactivateWidgetCleanup ()

void	deleteExtra ()
	Deletes the widget extra data. More...

void	deleteSysExtra ()

void	deleteTLSysExtra ()

void	drawWidget (QPaintDevice pdev, const QRegion &rgn, const QPoint &offset, int flags, QPainter sharedPainter=0, QWidgetBackingStore *backingStore=0)

QWidget *	effectiveFocusWidget ()

QRect	effectiveRectFor (const QRect &rect) const

bool	endSharedPainter ()

void	enforceNativeChildren ()

QWExtra *	extraData () const

QRect	frameStrut () const

void	getLayoutItemMargins (int left, int top, int right, int bottom) const

const QRegion &	getOpaqueChildren () const

void	handleSoftwareInputPanel (Qt::MouseButton button, bool clickCausedFocus)

virtual bool	hasHeightForWidth () const

void	hide_helper ()

void	hide_sys ()
	Platform-specific part of QWidget::hide(). More...

void	hideChildren (bool spontaneous)

void	inheritStyle ()

void	init (QWidget *desktopWidget, Qt::WindowFlags f)

QInputContext *	inputContext () const

void	invalidateBuffer (const QRegion &)
	Invalidates the rgn (in widget's coordinates) of the backing store, i.e. More...

void	invalidateBuffer (const QRect &)
	This function is equivalent to calling invalidateBuffer(QRegion(rect), ...), but is more efficient as it eliminates QRegion operations/allocations and can use the rect more precisely for additional cut-offs. More...

void	invalidateBuffer_resizeHelper (const QPoint &oldPos, const QSize &oldSize)
	Invalidates the buffer when the widget is resized. More...

void	invalidateGraphicsEffectsRecursively ()

bool	isAboutToShow () const

bool	isBackgroundInherited () const

bool	isOverlapped (const QRect &) const

void	lower_sys ()

QPoint	mapFromGlobal (const QPoint &pos) const

QPoint	mapToGlobal (const QPoint &pos) const

QWidgetBackingStore *	maybeBackingStore () const

QTLWExtra *	maybeTopData () const

void	moveRect (const QRect &, int dx, int dy)

bool	nativeChildrenForced () const

QFont	naturalWidgetFont (uint inheritedMask) const

QPalette	naturalWidgetPalette (uint inheritedMask) const
	Returns the palette that the widget w inherits from its ancestors and QApplication::palette. More...

void	paintBackground (QPainter *, const QRegion &, int flags=DrawAsRoot) const

bool	paintOnScreen () const

void	paintSiblingsRecursive (QPaintDevice pdev, const QObjectList &children, int index, const QRegion &rgn, const QPoint &offset, int flags, QPainter sharedPainter, QWidgetBackingStore *backingStore)

bool	pointInsideRectAndMask (const QPoint &) const

QRegion	prepareToRender (const QRegion &region, QWidget::RenderFlags renderFlags)

void	propagatePaletteChange ()
	Propagate this widget's palette to all children, except style sheet widgets, and windows that don't enable window propagation (palettes don't normally propagate to windows). More...

	QWidgetPrivate (int version=QObjectPrivateVersion)

void	raise_sys ()

QPaintDevice *	redirected (QPoint *offset) const

void	registerDropSite (bool)

void	render (QPaintDevice *target, const QPoint &targetOffset, const QRegion &sourceRegion, QWidget::RenderFlags renderFlags, bool readyToRender)

void	render_helper (QPainter *painter, const QPoint &targetOffset, const QRegion &sourceRegion, QWidget::RenderFlags renderFlags)

void	repaint_sys (const QRegion &rgn)

void	reparentFocusWidgets (QWidget *oldtlw)

void	resolveFont ()
	Determine which font is implicitly imposed on this widget by its ancestors and QApplication::font, resolve this against its own font (attributes from the implicit font are copied over). More...

void	resolveLayoutDirection ()

void	resolveLocale ()

void	resolvePalette ()
	Determine which palette is inherited from this widget's ancestors and QApplication::palette, resolve this against this widget's palette (attributes from the inherited palette are copied over this widget's palette). More...

void	restoreRedirected ()

void	scroll_sys (int dx, int dy)

void	scroll_sys (int dx, int dy, const QRect &r)

void	scrollChildren (int dx, int dy)

void	scrollRect (const QRect &, int dx, int dy)

void	sendPendingMoveAndResizeEvents (bool recursive=false, bool disableUpdates=false)

void	sendStartupMessage (const char *message) const
	Platform-specific part of QWidget::show(). More...

void	setConstraints_sys ()

void	setCursor_sys (const QCursor &cursor)

void	setDirtyOpaqueRegion ()

void	setEnabled_helper (bool)

void	setFocus_sys ()

void	setFont_helper (const QFont &font)

void	setGeometry_sys (int, int, int, int, bool)

void	setLayoutDirection_helper (Qt::LayoutDirection)

void	setLayoutItemMargins (int left, int top, int right, int bottom)

void	setLayoutItemMargins (QStyle::SubElement element, const QStyleOption *opt=0)

void	setLocale_helper (const QLocale &l, bool forceUpdate=false)

void	setMask_sys (const QRegion &)

bool	setMaximumSize_helper (int &maxw, int &maxh)

bool	setMinimumSize_helper (int &minw, int &minh)

void	setModal_sys ()

void	setNetWmWindowTypes ()

void	setOpaque (bool opaque)

void	setPalette_helper (const QPalette &)

void	setParent_sys (QWidget *parent, Qt::WindowFlags)

void	setRedirected (QPaintDevice *replacement, const QPoint &offset)

void	setSharedPainter (QPainter *painter)

void	setStyle_helper (QStyle *newStyle, bool propagate, bool metalHack=false)

void	setUpdatesEnabled_helper (bool)

void	setWindowFilePath_helper (const QString &filePath)

void	setWindowIcon_helper ()

void	setWindowIcon_sys (bool forceReset=false)

void	setWindowIconText_helper (const QString &cap)

void	setWindowIconText_sys (const QString &cap)

void	setWindowOpacity_sys (qreal opacity)

void	setWindowRole ()

void	setWindowTitle_helper (const QString &cap)

void	setWindowTitle_sys (const QString &cap)

void	setWinId (WId)

QPainter *	sharedPainter () const

void	show_helper ()

void	show_recursive ()
	Makes the widget visible in the isVisible() meaning of the word. More...

void	show_sys ()
	Platform-specific part of QWidget::show(). More...

void	showChildren (bool spontaneous)

void	stackUnder_sys (QWidget *)

void	subtractOpaqueChildren (QRegion &rgn, const QRect &clipRect) const

void	subtractOpaqueSiblings (QRegion &source, bool *hasDirtySiblingsAbove=0, bool alsoNonOpaque=false) const

void	syncBackingStore ()

void	syncBackingStore (const QRegion &region)

QTLWExtra *	topData () const

void	unsetCursor_sys ()

void	updateFont (const QFont &)
	Assign font to this widget, and propagate it to all children, except style sheet widgets (handled differently) and windows that don't enable window propagation. More...

void	updateFrameStrut ()
	Computes the frame rectangle when needed. More...

void	updateGeometry_helper (bool forceUpdate)

void	updateIsOpaque ()

void	updateIsTranslucent ()

void	updateSystemBackground ()

void	updateX11AcceptFocus ()

void	x11UpdateIsOpaque ()

	~QWidgetPrivate ()

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Static Public Functions
static QMenuPrivate *	get (QMenu *m)

Static Public Functions inherited from QWidgetPrivate
static void	adjustFlags (Qt::WindowFlags &flags, QWidget *w=0)

static QGraphicsProxyWidget *	nearestGraphicsProxyWidget (const QWidget *origin)
	Finds the nearest widget embedded in a graphics proxy widget along the chain formed by this widget and its ancestors. More...

static int	pointToRect (const QPoint &p, const QRect &r)

static QRect	screenGeometry (const QWidget *widget)

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Public Variables
uint	aboutToHide: 1

QPointer< QAction >	actionAboutToTrigger

QVector< QRect >	actionRects

bool	activationRecursionGuard

QPointer< QMenu >	activeMenu

QMenuCaused	causedPopup

uint	collapsibleSeparators: 1

QAction *	currentAction

QPointer< QAction >	defaultAction

QAction *	defaultMenuAction

bool	doChildEffects

QEventLoop *	eventLoop

bool	hasCheckableItems

uint	hasHadMouse: 1

uint	itemsDirty: 1

struct QMenuPrivate::QMacMenuPrivate *	mac_menu

uint	maxIconWidth

QAction *	menuAction

QBasicTimer	menuDelayTimer

int	motions

QPoint	mousePopupPos

uint	ncols: 4

QPointer< QWidget >	noReplayFor

struct QMenuPrivate::QMenuScroller *	scroll

QString	searchBuffer

QBasicTimer	searchBufferTimer

QAction *	sloppyAction

int	sloppyDelayTimer

QRegion	sloppyRegion

QPointer< QAction >	syncAction

uint	tabWidth

uint	tearoff: 1

uint	tearoffHighlighted: 1

uint	tornoff: 1

QPointer< QTornOffMenu >	tornPopup

struct QMenuPrivate::QWceMenuPrivate *	wce_menu

QHash< QAction , QWidget >	widgetItems

Public Variables inherited from QWidgetPrivate
QString	accessibleDescription

QString	accessibleName

QList< QAction * >	actions

QPalette::ColorRole	bg_role: 8

signed char	bottomLayoutItemMargin

short	bottommargin

QWidgetData	data

QRegion	dirty

uint	dirtyOpaqueChildren: 1

QWExtra *	extra

QPaintEngine *	extraPaintEngine

QPalette::ColorRole	fg_role: 8

QWidget *	focus_child

QWidget *	focus_next

QWidget *	focus_prev

QMap< Qt::GestureType, Qt::GestureFlags >	gestureContext

QGraphicsEffect *	graphicsEffect

Qt::HANDLE	hd

uint	high_attributes [4]

QPointer< QInputContext >	ic

Qt::InputMethodHints	imHints

uint	inDirtyList: 1

uint	inheritedFontResolveMask

uint	inheritedPaletteResolveMask

uint	inheritsInputMethodHints: 1

uint	inSetParent: 1

uint	isGLWidget: 1

uint	isMoved: 1

uint	isOpaque: 1

uint	isScrolled: 1

QLayout *	layout

signed char	leftLayoutItemMargin

short	leftmargin

QLocale	locale

QRegion *	needsFlush

QRegion	opaqueChildren

Qt::HANDLE	picture

const QMetaObject *	polished

QPaintDevice *	redirectDev

QPoint	redirectOffset

signed char	rightLayoutItemMargin

short	rightmargin

QSizePolicy	size_policy

QString	statusTip

QString	toolTip

signed char	topLayoutItemMargin

short	topmargin

uint	usesDoubleBufferedGLContext: 1

QString	whatsThis

QWidgetItemV2 *	widgetItem

QX11Info	xinfo

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Static Public Variables
static QHash< OSMenuRef, OSMenuRef >	mergeMenuHash

static QHash< OSMenuRef, QMenuMergeList * >	mergeMenuItemsHash

static QMenu *	mouseDown = 0

Static Public Variables inherited from QWidgetPrivate
static QWidgetSet *	allWidgets = 0

static int	instanceCounter = 0

static QWidget *	keyboardGrabber = 0

static QWidgetMapper *	mapper = 0

static int	maxInstances = 0

static QWidget *	mouseGrabber = 0

Detailed Description

Definition at line 144 of file qmenu_p.h.

Enumerations

◆ SelectionReason

enum QMenuPrivate::SelectionReason

Enumerator
SelectedFromKeyboard
SelectedFromElsewhere

Definition at line 219 of file qmenu_p.h.

                          {
         SelectedFromKeyboard,
         SelectedFromElsewhere
     };

Constructors and Destructors

◆ QMenuPrivate()

QMenuPrivate::QMenuPrivate ( )

inline

Definition at line 148 of file qmenu_p.h.

                    : itemsDirty(0), maxIconWidth(0), tabWidth(0), ncols(0),
                       collapsibleSeparators(true), activationRecursionGuard(false), hasHadMouse(0), aboutToHide(0), motions(0),
                       currentAction(0),
 #ifdef QT_KEYPAD_NAVIGATION
                       selectAction(0),
                       cancelAction(0),
 #endif
                       scroll(0), eventLoop(0), tearoff(0), tornoff(0), tearoffHighlighted(0),
                       hasCheckableItems(0), sloppyDelayTimer(0), sloppyAction(0), doChildEffects(false)
 #ifdef QT3_SUPPORT
                       ,emitHighlighted(false)
 #endif
 #ifdef Q_WS_MAC
                       ,mac_menu(0)
 #endif
 #if defined(Q_WS_WINCE) && !defined(QT_NO_MENUBAR)
                       ,wce_menu(0)
 #endif
 #ifdef Q_WS_S60
                       ,symbian_menu(0)
 #endif
     { }

◆ ~QMenuPrivate()

QMenuPrivate::~QMenuPrivate ( )

inline

Definition at line 170 of file qmenu_p.h.

     {
         delete scroll;
 #ifdef Q_WS_MAC
         delete mac_menu;
 #endif
 #if defined(Q_WS_WINCE) && !defined(QT_NO_MENUBAR)
         delete wce_menu;
 #endif
 #ifdef Q_WS_S60
         delete symbian_menu;
 #endif
 
     }

Functions

◆ _q_actionHovered()

void QMenuPrivate::_q_actionHovered ( )

Definition at line 1187 of file qmenu.cpp.

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

◆ _q_actionTriggered()

void QMenuPrivate::_q_actionTriggered ( )

Definition at line 1152 of file qmenu.cpp.

 {
     Q_Q(QMenu);
     if (QAction *action = qobject_cast<QAction *>(q->sender())) {
         QWeakPointer<QAction> actionGuard = action;
 #ifdef QT3_SUPPORT
         //we store it here because the action might be deleted/changed by connected slots
         const int id = q->findIdForAction(action);
 #endif
         emit q->triggered(action);
 #ifdef QT3_SUPPORT
         emit q->activated(id);
 #endif
 
         if (!activationRecursionGuard && actionGuard) {
             //in case the action has not been activated by the mouse
             //we check the parent hierarchy
             QList< QPointer<QWidget> > list;
             for(QWidget *widget = q->parentWidget(); widget; ) {
                 if (qobject_cast<QMenu*>(widget)
 #ifndef QT_NO_MENUBAR
                     || qobject_cast<QMenuBar*>(widget)
 #endif
                     ) {
                     list.append(widget);
                     widget = widget->parentWidget();
                 } else {
                     break;
                 }
             }
             activateCausedStack(list, action, QAction::Trigger, false);
         }
     }
 }

◆ _q_overrideMenuActionDestroyed()

void QMenuPrivate::_q_overrideMenuActionDestroyed ( )

Definition at line 685 of file qmenu.cpp.

Referenced by setOverrideMenuAction().

 {
     menuAction=defaultMenuAction;
 }

◆ actionAt() [1/2]

QAction * QMenuPrivate::actionAt ( QPoint p ) const

Definition at line 661 of file qmenu.cpp.

 {
     if (!q_func()->rect().contains(p))     //sanity check
        return 0;
 
     for(int i = 0; i < actionRects.count(); i++) {
         if (actionRects.at(i).contains(p))
             return actions.at(i);
     }
     return 0;
 }

◆ actionAt() [2/2]

QAction* QMenuPrivate::actionAt ( int i ) const

inline

Definition at line 268 of file qmenu_p.h.

268 { return q_func()->actions().at(i); }

◆ actionRect()

QRect QMenuPrivate::actionRect ( QAction * act ) const

Definition at line 419 of file qmenu.cpp.

Referenced by activateAction(), and setCurrentAction().

 {
     int index = actions.indexOf(act);
     if (index == -1)
         return QRect();
 
     updateActionRects();
 
     //we found the action
     return actionRects.at(index);
 }

◆ activateAction()

void QMenuPrivate::activateAction	(	QAction *	action,
		QAction::ActionEvent	action_e,
		bool	self = `true`
	)

Definition at line 1085 of file qmenu.cpp.

Referenced by setCurrentAction().

 {
     Q_Q(QMenu);
 #ifndef QT_NO_WHATSTHIS
     bool inWhatsThisMode = QWhatsThis::inWhatsThisMode();
 #endif
     if (!action || !q->isEnabled()
         || (action_e == QAction::Trigger
 #ifndef QT_NO_WHATSTHIS
             && !inWhatsThisMode
 #endif
             && (action->isSeparator() ||!action->isEnabled())))
         return;
 
     /* I have to save the caused stack here because it will be undone after popup execution (ie in the hide).
        Then I iterate over the list to actually send the events. --Sam
     */
     const QList<QPointer<QWidget> > causedStack = calcCausedStack();
     if (action_e == QAction::Trigger) {
 #ifndef QT_NO_WHATSTHIS
         if (!inWhatsThisMode)
             actionAboutToTrigger = action;
 #endif
 
         if (q->testAttribute(Qt::WA_DontShowOnScreen)) {
             hideUpToMenuBar();
         } else {
             for(QWidget *widget = QApplication::activePopupWidget(); widget; ) {
                 if (QMenu *qmenu = qobject_cast<QMenu*>(widget)) {
                     if(qmenu == q)
                         hideUpToMenuBar();
                     widget = qmenu->d_func()->causedPopup.widget;
                 } else {
                     break;
                 }
             }
         }
 
 #ifndef QT_NO_WHATSTHIS
         if (inWhatsThisMode) {
             QString s = action->whatsThis();
             if (s.isEmpty())
                 s = whatsThis;
             QWhatsThis::showText(q->mapToGlobal(actionRect(action).center()), s, q);
             return;
         }
 #endif
     }
 
 
     activateCausedStack(causedStack, action, action_e, self);
 
 
     if (action_e == QAction::Hover) {
 #ifndef QT_NO_ACCESSIBILITY
         if (QAccessible::isActive()) {
             int actionIndex = indexOf(action) + 1;
             QAccessible::updateAccessibility(q, actionIndex, QAccessible::Focus);
             QAccessible::updateAccessibility(q, actionIndex, QAccessible::Selection);
         }
 #endif
         action->showStatusText(topCausedWidget());
     } else {
         actionAboutToTrigger = 0;
     }
 }

◆ activateCausedStack()

void QMenuPrivate::activateCausedStack	(	const QList< QPointer< QWidget > > &	causedStack,
		QAction *	action,
		QAction::ActionEvent	action_e,
		bool	self
	)

Definition at line 1036 of file qmenu.cpp.

Referenced by _q_actionTriggered(), and activateAction().

 {
     QBoolBlocker guard(activationRecursionGuard);
 #ifdef QT3_SUPPORT
     const int actionId = q_func()->findIdForAction(action);
 #endif
     if(self)
         action->activate(action_e);
 
     for(int i = 0; i < causedStack.size(); ++i) {
         QPointer<QWidget> widget = causedStack.at(i);
         if (!widget)
             continue;
         //fire
         if (QMenu *qmenu = qobject_cast<QMenu*>(widget)) {
             widget = qmenu->d_func()->causedPopup.widget;
             if (action_e == QAction::Trigger) {
                 emit qmenu->triggered(action);
            } else if (action_e == QAction::Hover) {
                 emit qmenu->hovered(action);
 #ifdef QT3_SUPPORT
                 if (emitHighlighted) {
                     emit qmenu->highlighted(actionId);
                     emitHighlighted = false;
                 }
 #endif
             }
 #ifndef QT_NO_MENUBAR
         } else if (QMenuBar *qmenubar = qobject_cast<QMenuBar*>(widget)) {
             if (action_e == QAction::Trigger) {
                 emit qmenubar->triggered(action);
 #ifdef QT3_SUPPORT
                 emit qmenubar->activated(actionId);
 #endif
             } else if (action_e == QAction::Hover) {
                 emit qmenubar->hovered(action);
 #ifdef QT3_SUPPORT
                 if (emitHighlighted) {
                     emit qmenubar->highlighted(actionId);
                     emitHighlighted = false;
                 }
 #endif
             }
             break; //nothing more..
 #endif
         }
     }
 }

◆ adjustMenuSizeForScreen()

QSize QMenuPrivate::adjustMenuSizeForScreen ( const QRect & screen )

Definition at line 391 of file qmenu.cpp.

 {
     Q_Q(QMenu);
     QSize ret = screen.size();
     itemsDirty = true;
     updateActionRects(screen);
     const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q);
     ret.setWidth(actionRects.at(getLastVisibleAction()).right() + fw);
     return ret;
 }

◆ calcCausedStack()

QList< QPointer< QWidget > > QMenuPrivate::calcCausedStack ( ) const

virtual

Reimplemented in QTornOffMenu::QTornOffMenuPrivate.

Definition at line 224 of file qmenu.cpp.

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

◆ get()

static QMenuPrivate* QMenuPrivate::get ( QMenu * m )

inlinestatic

Definition at line 186 of file qmenu_p.h.

Referenced by QPushButtonPrivate::_q_popupPressed().

186 { return m->d_func(); }

◆ getLastVisibleAction()

int QMenuPrivate::getLastVisibleAction ( ) const

Definition at line 402 of file qmenu.cpp.

Referenced by adjustMenuSizeForScreen(), and updateActionRects().

 {
     //let's try to get the last visible action
     int lastVisibleAction = actions.count() - 1;
     for (;lastVisibleAction >= 0; --lastVisibleAction) {
         const QAction *action = actions.at(lastVisibleAction);
         if (action->isVisible()) {
             //removing trailing separators
             if (action->isSeparator() && collapsibleSeparators)
                 continue;
             break;
         }
     }
     return lastVisibleAction;
 }

◆ hasMouseMoved()

bool QMenuPrivate::hasMouseMoved ( const QPoint & globalPos )

Definition at line 1205 of file qmenu.cpp.

Referenced by mouseEventTaken().

 {
     //determines if the mouse has moved (ie its initial 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();
 }

◆ hideMenu()

void QMenuPrivate::hideMenu	(	QMenu *	menu,
		bool	justRegister = `false`
	)

Definition at line 471 of file qmenu.cpp.

Referenced by hideUpToMenuBar(), popupAction(), and setCurrentAction().

 {
     if (!menu)
         return;
 #if !defined(QT_NO_EFFECTS)
     menu->blockSignals(true);
     aboutToHide = true;
     // Flash item which is about to trigger (if any).
     if (menu->style()->styleHint(QStyle::SH_Menu_FlashTriggeredItem)
         && currentAction && currentAction == actionAboutToTrigger
         && menu->actions().contains(currentAction)) {
         QEventLoop eventLoop;
         QAction *activeAction = currentAction;
 
         menu->setActiveAction(0);
         QTimer::singleShot(60, &eventLoop, SLOT(quit()));
         eventLoop.exec();
 
         // Select and wait 20 ms.
         menu->setActiveAction(activeAction);
         QTimer::singleShot(20, &eventLoop, SLOT(quit()));
         eventLoop.exec();
     }
 
     // Fade out.
     if (menu->style()->styleHint(QStyle::SH_Menu_FadeOutOnHide)) {
         // ### Qt 4.4:
         // Should be something like: q->transitionWindow(Qt::FadeOutTransition, MenuFadeTimeInSec);
         // Hopefully we'll integrate qt/research/windowtransitions into main before 4.4.
         // Talk to Richard, Trenton or Bjoern.
 #if defined(Q_WS_MAC)
         if (justRegister) {
             QMacWindowFader::currentFader()->setFadeDuration(MenuFadeTimeInSec);
             QMacWindowFader::currentFader()->registerWindowToFade(menu);
         } else {
             macWindowFade(qt_mac_window_for(menu), MenuFadeTimeInSec);
         }
 
 #endif // Q_WS_MAC
     }
     aboutToHide = false;
     menu->blockSignals(false);
 #endif // QT_NO_EFFECTS
     if (!justRegister)
         menu->close();
 }

◆ hideUpToMenuBar()

void QMenuPrivate::hideUpToMenuBar ( )

Definition at line 435 of file qmenu.cpp.

Referenced by activateAction(), and mouseEventTaken().

 {
     Q_Q(QMenu);
     bool fadeMenus = q->style()->styleHint(QStyle::SH_Menu_FadeOutOnHide);
     if (!tornoff) {
         QWidget *caused = causedPopup.widget;
         hideMenu(q); //hide after getting causedPopup
         while(caused) {
 #ifndef QT_NO_MENUBAR
             if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) {
                 mb->d_func()->setCurrentAction(0);
                 mb->d_func()->setKeyboardMode(false);
                 caused = 0;
             } else
 #endif
             if (QMenu *m = qobject_cast<QMenu*>(caused)) {
                 caused = m->d_func()->causedPopup.widget;
                 if (!m->d_func()->tornoff)
                     hideMenu(m, fadeMenus);
                 if (!fadeMenus) // Mac doesn't clear the action until after hidden.
                     m->d_func()->setCurrentAction(0);
             } else {                caused = 0;
             }
         }
 #if defined(Q_WS_MAC)
         if (fadeMenus) {
             QEventLoop eventLoop;
             QTimer::singleShot(int(MenuFadeTimeInSec * 1000), &eventLoop, SLOT(quit()));
             QMacWindowFader::currentFader()->performFade();
             eventLoop.exec();
         }
 #endif
     }
     setCurrentAction(0);
 }

◆ indexOf()

int QMenuPrivate::indexOf ( QAction * act ) const

inline

Definition at line 269 of file qmenu_p.h.

Referenced by activateAction().

269 { return q_func()->actions().indexOf(act); }

◆ init()

void QMenuPrivate::init ( )

Definition at line 155 of file qmenu.cpp.

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

 {
     Q_Q(QMenu);
 #ifndef QT_NO_WHATSTHIS
     q->setAttribute(Qt::WA_CustomWhatsThis);
 #endif
     q->setAttribute(Qt::WA_X11NetWmWindowTypePopupMenu);
     defaultMenuAction = menuAction = new QAction(q);
     menuAction->d_func()->menu = q;
     q->setMouseTracking(q->style()->styleHint(QStyle::SH_Menu_MouseTracking, 0, q));
     if (q->style()->styleHint(QStyle::SH_Menu_Scrollable, 0, q)) {
         scroll = new QMenuPrivate::QMenuScroller;
         scroll->scrollFlags = QMenuPrivate::QMenuScroller::ScrollNone;
     }
 
 #ifdef QT_SOFTKEYS_ENABLED
     selectAction = QSoftKeyManager::createKeyedAction(QSoftKeyManager::SelectSoftKey, Qt::Key_Select, q);
     cancelAction = QSoftKeyManager::createKeyedAction(QSoftKeyManager::CancelSoftKey, Qt::Key_Back, q);
     selectAction->setPriority(QAction::HighPriority);
     cancelAction->setPriority(QAction::HighPriority);
     q->addAction(selectAction);
     q->addAction(cancelAction);
 #endif
 
 #ifdef Q_WS_S60
     if (S60->avkonComponentsSupportTransparency) {
         bool noSystemBackground = q->testAttribute(Qt::WA_NoSystemBackground);
         q->setAttribute(Qt::WA_TranslucentBackground); // also sets WA_NoSystemBackground
         q->setAttribute(Qt::WA_NoSystemBackground, noSystemBackground); // restore system background attribute
     }
 #endif
 }

◆ macMenu()

OSMenuRef QMenuPrivate::macMenu ( OSMenuRef merge )

Definition at line 1529 of file qmenu_mac.mm.

Referenced by setMacMenuEnabled().

 {
     Q_UNUSED(merge);
     Q_Q(QMenu);
     if (mac_menu && mac_menu->menu)
         return mac_menu->menu;
     if (!mac_menu)
         mac_menu = new QMacMenuPrivate;
     mac_menu->menu = qt_mac_create_menu(q);
     if (merge) {
 #ifndef QT_MAC_USE_COCOA
         SetMenuItemProperty(mac_menu->menu, 0, kMenuCreatorQt, kMenuPropertyMergeMenu, sizeof(merge), &merge);
 #else
         mergeMenuHash.insert(mac_menu->menu, merge);
 #endif
     }
     QList<QAction*> items = q->actions();
     for(int i = 0; i < items.count(); i++)
         mac_menu->addAction(items[i], 0, this);
     syncSeparatorsCollapsible(collapsibleSeparators);
     return mac_menu->menu;
 }

◆ mouseEventTaken()

bool QMenuPrivate::mouseEventTaken ( QMouseEvent * e )

Definition at line 958 of file qmenu.cpp.

 {
     Q_Q(QMenu);
     QPoint pos = q->mapFromGlobal(e->globalPos());
     if (scroll && !activeMenu) { //let the scroller "steal" the event
         bool isScroll = false;
         if (pos.x() >= 0 && pos.x() < q->width()) {
             for(int dir = QMenuScroller::ScrollUp; dir <= QMenuScroller::ScrollDown; dir = dir << 1) {
                 if (scroll->scrollFlags & dir) {
                     if (dir == QMenuScroller::ScrollUp)
                         isScroll = (pos.y() <= scrollerHeight());
                     else if (dir == QMenuScroller::ScrollDown)
                         isScroll = (pos.y() >= q->height() - scrollerHeight());
                     if (isScroll) {
                         scroll->scrollDirection = dir;
                         break;
                     }
                 }
             }
         }
         if (isScroll) {
             scroll->scrollTimer.start(50, q);
             return true;
         } else {
             scroll->scrollTimer.stop();
         }
     }
 
     if (tearoff) { //let the tear off thingie "steal" the event..
         QRect tearRect(0, 0, q->width(), q->style()->pixelMetric(QStyle::PM_MenuTearoffHeight, 0, q));
         if (scroll && scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)
             tearRect.translate(0, scrollerHeight());
         q->update(tearRect);
         if (tearRect.contains(pos) && hasMouseMoved(e->globalPos())) {
             setCurrentAction(0);
             tearoffHighlighted = 1;
             if (e->type() == QEvent::MouseButtonRelease) {
                 if (!tornPopup)
                     tornPopup = new QTornOffMenu(q);
                 tornPopup->setGeometry(q->geometry());
                 tornPopup->show();
                 hideUpToMenuBar();
             }
             return true;
         }
         tearoffHighlighted = 0;
     }
 
     if (q->frameGeometry().contains(e->globalPos())) //otherwise if the event is in our rect we want it..
         return false;
 
     for(QWidget *caused = causedPopup.widget; caused;) {
         bool passOnEvent = false;
         QWidget *next_widget = 0;
         QPoint cpos = caused->mapFromGlobal(e->globalPos());
 #ifndef QT_NO_MENUBAR
         if (QMenuBar *mb = qobject_cast<QMenuBar*>(caused)) {
             passOnEvent = mb->rect().contains(cpos);
         } else
 #endif
         if (QMenu *m = qobject_cast<QMenu*>(caused)) {
             passOnEvent = m->rect().contains(cpos);
             next_widget = m->d_func()->causedPopup.widget;
         }
         if (passOnEvent) {
             if(e->type() != QEvent::MouseButtonRelease || mouseDown == caused) {
             QMouseEvent new_e(e->type(), cpos, e->button(), e->buttons(), e->modifiers());
             QApplication::sendEvent(caused, &new_e);
             return true;
         }
         }
         if (!next_widget)
             break;
         caused = next_widget;
     }
     return false;
 }

◆ popupAction()

void QMenuPrivate::popupAction	(	QAction *	action,
		int	delay,
		bool	activateFirst
	)

Definition at line 518 of file qmenu.cpp.

Referenced by setCurrentAction().

 {
     Q_Q(QMenu);
     if (action && action->isEnabled()) {
         if (!delay)
             q->internalDelayedPopup();
         else if (!menuDelayTimer.isActive() && (!action->menu() || !action->menu()->isVisible()))
             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);
     }
 }

◆ popupGeometry() [1/2]

QRect QMenuPrivate::popupGeometry ( const QWidget * widget ) const

Definition at line 195 of file qmenu.cpp.

Referenced by scrollMenu(), and updateActionRects().

 {
 #ifdef Q_WS_WIN
     return QApplication::desktop()->screenGeometry(widget);
 #elif defined Q_WS_X11
     if (X11->desktopEnvironment == DE_KDE)
         return QApplication::desktop()->screenGeometry(widget);
     else
         return QApplication::desktop()->availableGeometry(widget);
 #else
         return QApplication::desktop()->availableGeometry(widget);
 #endif
 }

◆ popupGeometry() [2/2]

QRect QMenuPrivate::popupGeometry ( int screen = -1 ) const

Definition at line 210 of file qmenu.cpp.

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

◆ scrollerHeight()

int QMenuPrivate::scrollerHeight ( ) const

Definition at line 188 of file qmenu.cpp.

Referenced by mouseEventTaken(), scrollMenu(), and setFirstActionActive().

 {
     Q_Q(const QMenu);
     return qMax(QApplication::globalStrut().height(), q->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, q));
 }

◆ scrollMenu() [1/3]

void QMenuPrivate::scrollMenu	(	QMenuScroller::ScrollLocation	location,
		bool	active = `false`
	)

Definition at line 873 of file qmenu.cpp.

Referenced by scrollMenu().

 {
     Q_Q(QMenu);
     updateActionRects();
     if(location == QMenuScroller::ScrollBottom) {
         for(int i = actions.size()-1; i >= 0; --i) {
             QAction *act = actions.at(i);
             if (actionRects.at(i).isNull())
                 continue;
             if (!act->isSeparator() &&
                 (q->style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, q)
                  || act->isEnabled())) {
                 if(scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollDown)
                     scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollBottom, active);
                 else if(active)
                     setCurrentAction(act, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);
                 break;
             }
         }
     } else if(location == QMenuScroller::ScrollTop) {
         for(int i = 0; i < actions.size(); ++i) {
             QAction *act = actions.at(i);
             if (actionRects.at(i).isNull())
                 continue;
             if (!act->isSeparator() &&
                 (q->style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, q)
                  || act->isEnabled())) {
                 if(scroll->scrollFlags & QMenuPrivate::QMenuScroller::ScrollUp)
                     scrollMenu(act, QMenuPrivate::QMenuScroller::ScrollTop, active);
                 else if(active)
                     setCurrentAction(act, /*popup*/-1, QMenuPrivate::SelectedFromKeyboard);
                 break;
             }
         }
     }
 }

◆ scrollMenu() [2/3]

void QMenuPrivate::scrollMenu	(	QMenuScroller::ScrollDirection	direction,
		bool	page = `false`,
		bool	active = `false`
	)

Definition at line 911 of file qmenu.cpp.

 {
     Q_Q(QMenu);
     if (!scroll || !(scroll->scrollFlags & direction)) //not really possible...
         return;
     updateActionRects();
     const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp)   ? scrollerHeight() : 0;
     const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollerHeight() : 0;
     const int vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q);
     const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q);
     const int offset = topScroll ? topScroll-vmargin : 0;
     if (direction == QMenuScroller::ScrollUp) {
         for(int i = 0, saccum = 0; i < actions.count(); i++) {
             saccum -= actionRects.at(i).height();
             if (saccum <= scroll->scrollOffset-offset) {
                 scrollMenu(actions.at(i), page ? QMenuScroller::ScrollBottom : QMenuScroller::ScrollTop, active);
                 break;
             }
         }
     } else if (direction == QMenuScroller::ScrollDown) {
         bool scrolled = false;
         for(int i = 0, saccum = 0; i < actions.count(); i++) {
             const int iHeight = actionRects.at(i).height();
             saccum -= iHeight;
             if (saccum <= scroll->scrollOffset-offset) {
                 const int scrollerArea = q->height() - botScroll - fw*2;
                 int visible = (scroll->scrollOffset-offset) - saccum;
                 for(i++ ; i < actions.count(); i++) {
                     visible += actionRects.at(i).height();
                     if (visible > scrollerArea - topScroll) {
                         scrolled = true;
                         scrollMenu(actions.at(i), page ? QMenuScroller::ScrollTop : QMenuScroller::ScrollBottom, active);
                         break;
                     }
                 }
                 break;
             }
         }
         if(!scrolled) {
             scroll->scrollFlags &= ~QMenuScroller::ScrollDown;
             q->update();
         }
     }
 }

◆ scrollMenu() [3/3]

void QMenuPrivate::scrollMenu	(	QAction *	action,
		QMenuScroller::ScrollLocation	location,
		bool	active = `false`
	)

Definition at line 761 of file qmenu.cpp.

 {
     Q_Q(QMenu);
     if (!scroll || !scroll->scrollFlags)
         return;
     updateActionRects();
     int newOffset = 0;
     const int topScroll = (scroll->scrollFlags & QMenuScroller::ScrollUp)   ? scrollerHeight() : 0;
     const int botScroll = (scroll->scrollFlags & QMenuScroller::ScrollDown) ? scrollerHeight() : 0;
     const int vmargin = q->style()->pixelMetric(QStyle::PM_MenuVMargin, 0, q);
     const int fw = q->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0, q);
 
     if (location == QMenuScroller::ScrollTop) {
         for(int i = 0, saccum = 0; i < actions.count(); i++) {
             if (actions.at(i) == action) {
                 newOffset = topScroll - saccum;
                 break;
             }
             saccum += actionRects.at(i).height();
         }
     } else {
         for(int i = 0, saccum = 0; i < actions.count(); i++) {
             saccum += actionRects.at(i).height();
             if (actions.at(i) == action) {
                 if (location == QMenuScroller::ScrollCenter)
                     newOffset = ((q->height() / 2) - botScroll) - (saccum - topScroll);
                 else
                     newOffset = (q->height() - botScroll) - saccum;
                 break;
             }
         }
         if(newOffset)
             newOffset -= fw * 2;
     }
 
     //figure out which scroll flags
     uint newScrollFlags = QMenuScroller::ScrollNone;
     if (newOffset < 0) //easy and cheap one
         newScrollFlags |= QMenuScroller::ScrollUp;
     int saccum = newOffset;
     for(int i = 0; i < actionRects.count(); i++) {
         saccum += actionRects.at(i).height();
         if (saccum > q->height()) {
             newScrollFlags |= QMenuScroller::ScrollDown;
             break;
         }
     }
 
     if (!(newScrollFlags & QMenuScroller::ScrollDown) && (scroll->scrollFlags & QMenuScroller::ScrollDown)) {
         newOffset = q->height() - (saccum - newOffset) - fw*2 - vmargin;    //last item at bottom
     }
 
     if (!(newScrollFlags & QMenuScroller::ScrollUp) && (scroll->scrollFlags & QMenuScroller::ScrollUp)) {
         newOffset = 0;  //first item at top
     }
 
     if (newScrollFlags & QMenuScroller::ScrollUp)
         newOffset -= vmargin;
 
     QRect screen = popupGeometry(q);
     const int desktopFrame = q->style()->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, 0, q);
     if (q->height() < screen.height()-(desktopFrame*2)-1) {
         QRect geom = q->geometry();
         if (newOffset > scroll->scrollOffset && (scroll->scrollFlags & newScrollFlags & QMenuScroller::ScrollUp)) { //scroll up
             const int newHeight = geom.height()-(newOffset-scroll->scrollOffset);
             if(newHeight > geom.height())
                 geom.setHeight(newHeight);
         } else if(scroll->scrollFlags & newScrollFlags & QMenuScroller::ScrollDown) {
             int newTop = geom.top() + (newOffset-scroll->scrollOffset);
             if (newTop < desktopFrame+screen.top())
                 newTop = desktopFrame+screen.top();
             if (newTop < geom.top()) {
                 geom.setTop(newTop);
                 newOffset = 0;
                 newScrollFlags &= ~QMenuScroller::ScrollUp;
             }
         }
         if (geom.bottom() > screen.bottom() - desktopFrame)
             geom.setBottom(screen.bottom() - desktopFrame);
         if (geom.top() < desktopFrame+screen.top())
             geom.setTop(desktopFrame+screen.top());
         if (geom != q->geometry()) {
 #if 0
             if (newScrollFlags & QMenuScroller::ScrollDown &&
                q->geometry().top() - geom.top() >= -newOffset)
                 newScrollFlags &= ~QMenuScroller::ScrollDown;
 #endif
             q->setGeometry(geom);
         }
     }
 
     //actually update flags
     const int delta = qMin(0, newOffset) - scroll->scrollOffset; //make sure the new offset is always negative
     if (!itemsDirty && delta) {
         //we've scrolled so we need to update the action rects
         for (int i = 0; i < actionRects.count(); ++i) {
             QRect &current = actionRects[i];
             current.moveTop(current.top() + delta);
 
             //we need to update the widgets geometry
             if (QWidget *w = widgetItems.value(actions.at(i)))
                 w->setGeometry(current);
         }
     }
     scroll->scrollOffset += delta;
     scroll->scrollFlags = newScrollFlags;
     if (active)
         setCurrentAction(action);
 
     q->update();     //issue an update so we see all the new state..
 }

◆ setCurrentAction()

void QMenuPrivate::setCurrentAction	(	QAction *	action,
		int	popup = `-1`,
		SelectionReason	reason = `SelectedFromElsewhere`,
		bool	activateFirst = `false`
	)

Definition at line 576 of file qmenu.cpp.

Referenced by hideUpToMenuBar(), mouseEventTaken(), scrollMenu(), and setFirstActionActive().

 {
     Q_Q(QMenu);
     tearoffHighlighted = 0;
     // Reselect the currently active action in case mouse moved over other menu items when
     // moving from sub menu action to sub menu (QTBUG-20094).
     if (reason != SelectedFromKeyboard && 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;
 #endif
 
     currentAction = action;
     if (action) {
         if (!action->isSeparator()) {
             activateAction(action, QAction::Hover);
             if (popup != -1) {
                 hideActiveMenu = 0; //will be done "later"
                 // if the menu is visible then activate the required action,
                 // otherwise we just mark the action as currentAction
                 // and activate it when the menu will be popuped.
                 if (q->isVisible())
                     popupAction(currentAction, popup, activateFirst);
             }
             q->update(actionRect(action));
 
             if (reason == SelectedFromKeyboard) {
                 QWidget *widget = widgetItems.value(action);
                 if (widget) {
                     if (widget->focusPolicy() != Qt::NoFocus)
                         widget->setFocus(Qt::TabFocusReason);
                 } else {
                     //when the action has no QWidget, the QMenu itself should
                     // get the focus
                     // Since the menu is a pop-up, it uses the popup reason.
                     if (!q->hasFocus()) {
                         q->setFocus(Qt::PopupFocusReason);
                     }
                 }
             }
         } else { //action is a separator
             if (popup != -1)
                 hideActiveMenu = 0; //will be done "later"
         }
 #ifndef QT_NO_STATUSTIP
     }  else if (previousAction) {
         previousAction->d_func()->showStatusText(topCausedWidget(), QString());
 #endif
     }
     if (hideActiveMenu) {
         activeMenu = 0;
 #ifndef QT_NO_EFFECTS
         // kill any running effect
         qFadeEffect(0);
         qScrollEffect(0);
 #endif
         hideMenu(hideActiveMenu);
     }
 }

◆ setFirstActionActive()

void QMenuPrivate::setFirstActionActive ( )

Definition at line 552 of file qmenu.cpp.

 {
     Q_Q(QMenu);
     updateActionRects();
     for(int i = 0, saccum = 0; i < actions.count(); i++) {
         const QRect &rect = actionRects.at(i);
         if (rect.isNull())
             continue;
         if (scroll && scroll->scrollFlags & QMenuScroller::ScrollUp) {
             saccum -= rect.height();
             if (saccum > scroll->scrollOffset - scrollerHeight())
                 continue;
         }
         QAction *act = actions.at(i);
         if (!act->isSeparator() &&
            (q->style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, q)
             || act->isEnabled())) {
             setCurrentAction(act);
             break;
         }
     }
 }

◆ setMacMenuEnabled()

void QMenuPrivate::setMacMenuEnabled ( bool enable = true )

Warning: This function is not part of the public interface.

Definition at line 1574 of file qmenu_mac.mm.

 {
     if (!macMenu(0))
         return;
 
     QMacCocoaAutoReleasePool pool;
     if (enable) {
         for (int i = 0; i < mac_menu->actionItems.count(); ++i) {
             QMacMenuAction *menuItem = mac_menu->actionItems.at(i);
             if (menuItem && menuItem->action && menuItem->action->isEnabled()) {
                 // Only enable those items which contains an enabled QAction.
                 // i == 0 -> the menu itself, hence i + 1 for items.
                 EnableMenuItem(mac_menu->menu, i + 1);
             }
         }
     } else {
         DisableAllMenuItems(mac_menu->menu);
     }
 }

◆ setOverrideMenuAction()

void QMenuPrivate::setOverrideMenuAction ( QAction * a )

Definition at line 673 of file qmenu.cpp.

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

◆ setSyncAction()

void QMenuPrivate::setSyncAction ( )

Definition at line 534 of file qmenu.cpp.

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

◆ syncSeparatorsCollapsible()

void QMenuPrivate::syncSeparatorsCollapsible ( bool collapse )

Warning: This function is not part of the public interface.

Definition at line 1556 of file qmenu_mac.mm.

Referenced by macMenu().

 {
 #ifndef QT_MAC_USE_COCOA
     if (collapse)
         ChangeMenuAttributes(mac_menu->menu, kMenuAttrCondenseSeparators, 0);
     else
         ChangeMenuAttributes(mac_menu->menu, 0, kMenuAttrCondenseSeparators);
 #else
     qt_mac_menu_collapseSeparators(mac_menu->menu, collapse);
 #endif
 }

◆ topCausedWidget()

QWidget * QMenuPrivate::topCausedWidget ( ) const

Definition at line 653 of file qmenu.cpp.

Referenced by activateAction(), and setCurrentAction().

 {
     QWidget* top = causedPopup.widget;
     while (QMenu* m = qobject_cast<QMenu *>(top))
         top = m->d_func()->causedPopup.widget;
     return top;
 }

◆ updateActionRects() [1/2]

void QMenuPrivate::updateActionRects ( ) const

Definition at line 239 of file qmenu.cpp.

Referenced by actionRect(), adjustMenuSizeForScreen(), scrollMenu(), and setFirstActionActive().

 {
     Q_Q(const QMenu);
     updateActionRects(popupGeometry(q));
 }

◆ updateActionRects() [2/2]

void QMenuPrivate::updateActionRects ( const QRect & screen ) const

Definition at line 245 of file qmenu.cpp.

 {
     Q_Q(const QMenu);
     if (!itemsDirty)
         return;
 
     q->ensurePolished();
 
     //let's reinitialize the buffer
     actionRects.resize(actions.count());
     actionRects.fill(QRect());
 
     int lastVisibleAction = getLastVisibleAction();
 
     int max_column_width = 0,
         dh = screen.height(),
         y = 0;
     QStyle *style = q->style();
     QStyleOption opt;
     opt.init(q);
     const int hmargin = style->pixelMetric(QStyle::PM_MenuHMargin, &opt, q),
               vmargin = style->pixelMetric(QStyle::PM_MenuVMargin, &opt, q),
               icone = style->pixelMetric(QStyle::PM_SmallIconSize, &opt, q);
     const int fw = style->pixelMetric(QStyle::PM_MenuPanelWidth, &opt, q);
     const int deskFw = style->pixelMetric(QStyle::PM_MenuDesktopFrameWidth, &opt, q);
     const int tearoffHeight = tearoff ? style->pixelMetric(QStyle::PM_MenuTearoffHeight, &opt, q) : 0;
 
     //for compatibility now - will have to refactor this away
     tabWidth = 0;
     maxIconWidth = 0;
     hasCheckableItems = false;
     ncols = 1;
     sloppyAction = 0;
 
     for (int i = 0; i < actions.count(); ++i) {
         QAction *action = actions.at(i);
         if (action->isSeparator() || !action->isVisible() || widgetItems.contains(action))
             continue;
         //..and some members
         hasCheckableItems |= action->isCheckable();
         QIcon is = action->icon();
         if (!is.isNull()) {
             maxIconWidth = qMax<uint>(maxIconWidth, icone + 4);
         }
     }
 
     //calculate size
     QFontMetrics qfm = q->fontMetrics();
     bool previousWasSeparator = true; // this is true to allow removing the leading separators
     for(int i = 0; i <= lastVisibleAction; i++) {
         QAction *action = actions.at(i);
 
         if (!action->isVisible() ||
             (collapsibleSeparators && previousWasSeparator && action->isSeparator()))
             continue; // we continue, this action will get an empty QRect
 
         previousWasSeparator = action->isSeparator();
 
         //let the style modify the above size..
         QStyleOptionMenuItem opt;
         q->initStyleOption(&opt, action);
         const QFontMetrics &fm = opt.fontMetrics;
 
         QSize sz;
         if (QWidget *w = widgetItems.value(action)) {
           sz = w->sizeHint().expandedTo(w->minimumSize()).expandedTo(w->minimumSizeHint()).boundedTo(w->maximumSize());
         } else {
             //calc what I think the size is..
             if (action->isSeparator()) {
                 sz = QSize(2, 2);
             } else {
                 QString s = action->text();
                 int t = s.indexOf(QLatin1Char('\t'));
                 if (t != -1) {
                     tabWidth = qMax(int(tabWidth), qfm.width(s.mid(t+1)));
                     s = s.left(t);
     #ifndef QT_NO_SHORTCUT
                 } else {
                     QKeySequence seq = action->shortcut();
                     if (!seq.isEmpty())
                         tabWidth = qMax(int(tabWidth), qfm.width(seq));
     #endif
                 }
                 sz.setWidth(fm.boundingRect(QRect(), Qt::TextSingleLine | Qt::TextShowMnemonic, s).width());
                 sz.setHeight(qMax(fm.height(), qfm.height()));
 
                 QIcon is = action->icon();
                 if (!is.isNull()) {
                     QSize is_sz = QSize(icone, icone);
                     if (is_sz.height() > sz.height())
                         sz.setHeight(is_sz.height());
                 }
             }
             sz = style->sizeFromContents(QStyle::CT_MenuItem, &opt, sz, q);
         }
 
 
         if (!sz.isEmpty()) {
             max_column_width = qMax(max_column_width, sz.width());
             //wrapping
             if (!scroll &&
                y+sz.height()+vmargin > dh - (deskFw * 2)) {
                 ncols++;
                 y = vmargin;
             }
             y += sz.height();
             //update the item
             actionRects[i] = QRect(0, 0, sz.width(), sz.height());
         }
     }
 
     max_column_width += tabWidth; //finally add in the tab width
     const int sfcMargin = style->sizeFromContents(QStyle::CT_Menu, &opt, QApplication::globalStrut(), q).width() - QApplication::globalStrut().width();
     const int min_column_width = q->minimumWidth() - (sfcMargin + leftmargin + rightmargin + 2 * (fw + hmargin));
     max_column_width = qMax(min_column_width, max_column_width);
 
     //calculate position
     const int base_y = vmargin + fw + topmargin +
         (scroll ? scroll->scrollOffset : 0) +
         tearoffHeight;
     int x = hmargin + fw + leftmargin;
     y = base_y;
 
     for(int i = 0; i < actions.count(); i++) {
         QRect &rect = actionRects[i];
         if (rect.isNull())
             continue;
         if (!scroll &&
            y+rect.height() > dh - deskFw * 2) {
             x += max_column_width + hmargin;
             y = base_y;
         }
         rect.translate(x, y);                        //move
         rect.setWidth(max_column_width); //uniform width
 
         //we need to update the widgets geometry
         if (QWidget *widget = widgetItems.value(actions.at(i))) {
             widget->setGeometry(rect);
             widget->setVisible(actions.at(i)->isVisible());
         }
 
         y += rect.height();
     }
     itemsDirty = 0;
 }

◆ updateLayoutDirection()

void QMenuPrivate::updateLayoutDirection ( )

Definition at line 691 of file qmenu.cpp.

 {
     Q_Q(QMenu);
     //we need to mimic the cause of the popup's layout direction
     //to allow setting it on a mainwindow for example
     //we call setLayoutDirection_helper to not overwrite a user-defined value
     if (!q->testAttribute(Qt::WA_SetLayoutDirection)) {
         if (QWidget *w = causedPopup.widget)
             setLayoutDirection_helper(w->layoutDirection());
         else if (QWidget *w = q->parentWidget())
             setLayoutDirection_helper(w->layoutDirection());
         else
             setLayoutDirection_helper(QApplication::layoutDirection());
     }
 }

◆ wceCommands()

QAction * QMenuPrivate::wceCommands ( uint command )

Definition at line 364 of file qmenu_wince.cpp.

 {
     QAction *foundAction = 0;
     for (int i  = 0; i < wce_menu->actionItems.size(); ++i) {
         if (foundAction)
             break;
         QWceMenuAction *action = wce_menu->actionItems.at(i);
         if (action->action->menu()) {
             foundAction = action->action->menu()->d_func()->wceCommands(command);
         }
         else if (action->command == command) {
             activateAction(action->action, QAction::Trigger);
             return action->action;
         }
     }
     if (foundAction)
         emit q_func()->triggered(foundAction);
     return foundAction;
 }

◆ wceMenu()

HMENU QMenuPrivate::wceMenu ( )

Definition at line 483 of file qmenu_wince.cpp.

 {
     if (!wce_menu)
         wce_menu = new QWceMenuPrivate;
     if (!wce_menu->menuHandle)
         wce_menu->rebuild();
     return wce_menu->menuHandle;
 }

Properties

◆ aboutToHide

uint QMenuPrivate::aboutToHide

Definition at line 211 of file qmenu_p.h.

Referenced by hideMenu().

◆ actionAboutToTrigger

QPointer<QAction> QMenuPrivate::actionAboutToTrigger

Definition at line 338 of file qmenu_p.h.

Referenced by activateAction(), and hideMenu().

◆ actionRects

QVector<QRect> QMenuPrivate::actionRects

mutable

Definition at line 194 of file qmenu_p.h.

Referenced by actionAt(), actionRect(), adjustMenuSizeForScreen(), scrollMenu(), setFirstActionActive(), and updateActionRects().

◆ activationRecursionGuard

bool QMenuPrivate::activationRecursionGuard

Definition at line 205 of file qmenu_p.h.

Referenced by _q_actionTriggered(), and activateCausedStack().

◆ activeMenu

QPointer<QMenu> QMenuPrivate::activeMenu

Definition at line 254 of file qmenu_p.h.

Referenced by mouseEventTaken(), popupAction(), and setCurrentAction().

◆ causedPopup

QMenuCaused QMenuPrivate::causedPopup

Definition at line 263 of file qmenu_p.h.

Referenced by QPushButtonPrivate::_q_popupPressed(), calcCausedStack(), hideUpToMenuBar(), mouseEventTaken(), QTornOffMenu::QTornOffMenuPrivate::QTornOffMenuPrivate(), setCurrentAction(), topCausedWidget(), and updateLayoutDirection().

◆ collapsibleSeparators

uint QMenuPrivate::collapsibleSeparators

Definition at line 201 of file qmenu_p.h.

Referenced by getLastVisibleAction(), macMenu(), and updateActionRects().

◆ currentAction

QAction* QMenuPrivate::currentAction

Definition at line 213 of file qmenu_p.h.

Referenced by hideMenu(), setCurrentAction(), and setSyncAction().

◆ defaultAction

QPointer<QAction> QMenuPrivate::defaultAction

Definition at line 283 of file qmenu_p.h.

◆ defaultMenuAction

QAction* QMenuPrivate::defaultMenuAction

Definition at line 286 of file qmenu_p.h.

Referenced by _q_overrideMenuActionDestroyed(), init(), and setOverrideMenuAction().

◆ doChildEffects

bool QMenuPrivate::doChildEffects

Definition at line 303 of file qmenu_p.h.

◆ eventLoop

QEventLoop* QMenuPrivate::eventLoop

Definition at line 246 of file qmenu_p.h.

Referenced by hideMenu(), and hideUpToMenuBar().

◆ hasCheckableItems

bool QMenuPrivate::hasCheckableItems

mutable

Definition at line 275 of file qmenu_p.h.

Referenced by updateActionRects().

◆ hasHadMouse

uint QMenuPrivate::hasHadMouse

Definition at line 210 of file qmenu_p.h.

◆ itemsDirty

uint QMenuPrivate::itemsDirty

mutable

Definition at line 190 of file qmenu_p.h.

Referenced by adjustMenuSizeForScreen(), scrollMenu(), and updateActionRects().

◆ mac_menu

struct QMenuPrivate::QMacMenuPrivate * QMenuPrivate::mac_menu

Referenced by macMenu(), setMacMenuEnabled(), and syncSeparatorsCollapsible().

◆ maxIconWidth

uint QMenuPrivate::maxIconWidth

mutable

Definition at line 191 of file qmenu_p.h.

Referenced by updateActionRects().

◆ menuAction

QAction* QMenuPrivate::menuAction

Definition at line 285 of file qmenu_p.h.

Referenced by _q_overrideMenuActionDestroyed(), init(), and setOverrideMenuAction().

◆ menuDelayTimer

QBasicTimer QMenuPrivate::menuDelayTimer

Definition at line 218 of file qmenu_p.h.

Referenced by popupAction().

◆ mergeMenuHash

QHash< OSMenuRef, OSMenuRef > QMenuPrivate::mergeMenuHash

static

Definition at line 334 of file qmenu_p.h.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction(), QMenuBarPrivate::macMenu(), macMenu(), QMenuBarPrivate::macUpdateMenuBarImmediatly(), QMenuPrivate::QMacMenuPrivate::merged(), qt_mac_set_modal_state(), and QMenuPrivate::QMacMenuPrivate::~QMacMenuPrivate().

◆ mergeMenuItemsHash

QHash< OSMenuRef, QMenuMergeList * > QMenuPrivate::mergeMenuItemsHash

static

Definition at line 335 of file qmenu_p.h.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction(), QMenuBarPrivate::macUpdateMenuBarImmediatly(), QMenuPrivate::QMacMenuPrivate::merged(), qt_mac_menu_merge_action(), QMenuPrivate::QMacMenuPrivate::removeAction(), and QMenuPrivate::QMacMenuPrivate::~QMacMenuPrivate().

◆ motions

int QMenuPrivate::motions

Definition at line 212 of file qmenu_p.h.

Referenced by hasMouseMoved().

◆ mouseDown

QMenu * QMenuPrivate::mouseDown = 0

static

Definition at line 208 of file qmenu_p.h.

Referenced by mouseEventTaken().

◆ mousePopupPos

QPoint QMenuPrivate::mousePopupPos

Definition at line 209 of file qmenu_p.h.

Referenced by hasMouseMoved().

◆ ncols

uint QMenuPrivate::ncols

mutable

Definition at line 200 of file qmenu_p.h.

Referenced by updateActionRects().

◆ noReplayFor

QPointer<QWidget> QMenuPrivate::noReplayFor

Definition at line 390 of file qmenu_p.h.

◆ scroll

struct QMenuPrivate::QMenuScroller * QMenuPrivate::scroll

Referenced by init(), mouseEventTaken(), scrollMenu(), setFirstActionActive(), and updateActionRects().

◆ searchBuffer

QString QMenuPrivate::searchBuffer

Definition at line 250 of file qmenu_p.h.

◆ searchBufferTimer

QBasicTimer QMenuPrivate::searchBufferTimer

Definition at line 251 of file qmenu_p.h.

◆ sloppyAction

QAction* QMenuPrivate::sloppyAction

mutable

Definition at line 279 of file qmenu_p.h.

Referenced by setCurrentAction(), and updateActionRects().

◆ sloppyDelayTimer

int QMenuPrivate::sloppyDelayTimer

Definition at line 278 of file qmenu_p.h.

◆ sloppyRegion

QRegion QMenuPrivate::sloppyRegion

Definition at line 280 of file qmenu_p.h.

Referenced by setCurrentAction().

◆ syncAction

QPointer<QAction> QMenuPrivate::syncAction

Definition at line 247 of file qmenu_p.h.

◆ tabWidth

uint QMenuPrivate::tabWidth

mutable

Definition at line 191 of file qmenu_p.h.

Referenced by updateActionRects().

◆ tearoff

uint QMenuPrivate::tearoff

Definition at line 272 of file qmenu_p.h.

Referenced by mouseEventTaken(), and updateActionRects().

◆ tearoffHighlighted

uint QMenuPrivate::tearoffHighlighted

Definition at line 272 of file qmenu_p.h.

Referenced by mouseEventTaken(), and setCurrentAction().

◆ tornoff

uint QMenuPrivate::tornoff

Definition at line 272 of file qmenu_p.h.

Referenced by hideUpToMenuBar(), and QTornOffMenu::QTornOffMenuPrivate::QTornOffMenuPrivate().

◆ tornPopup

QPointer<QTornOffMenu> QMenuPrivate::tornPopup

Definition at line 273 of file qmenu_p.h.

Referenced by mouseEventTaken().

◆ wce_menu

struct QMenuPrivate::QWceMenuPrivate * QMenuPrivate::wce_menu

Referenced by wceMenu().

◆ widgetItems

QHash<QAction *, QWidget *> QMenuPrivate::widgetItems

mutable

Definition at line 195 of file qmenu_p.h.

Referenced by QMenuPrivate::QMacMenuPrivate::addAction(), scrollMenu(), setCurrentAction(), and updateActionRects().

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

/src/gui/widgets/qmenu_p.h
/src/gui/widgets/qmenu.cpp
/src/gui/widgets/qmenu_mac.mm
/src/gui/widgets/qmenu_wince.cpp

Classes

Public Types

Public Functions

Static Public Functions

Public Variables

Static Public Variables

Detailed Description

Enumerations

◆ SelectionReason

Constructors and Destructors

◆ QMenuPrivate()

◆ ~QMenuPrivate()

Functions

◆ _q_actionHovered()

◆ _q_actionTriggered()

◆ _q_overrideMenuActionDestroyed()

◆ actionAt() [1/2]

◆ actionAt() [2/2]

◆ actionRect()

◆ activateAction()

◆ activateCausedStack()

◆ adjustMenuSizeForScreen()

◆ calcCausedStack()

◆ get()

◆ getLastVisibleAction()

◆ hasMouseMoved()

◆ hideMenu()

◆ hideUpToMenuBar()

◆ indexOf()

◆ init()

◆ macMenu()

◆ mouseEventTaken()

◆ popupAction()

◆ popupGeometry() [1/2]

◆ popupGeometry() [2/2]

◆ scrollerHeight()

◆ scrollMenu() [1/3]

◆ scrollMenu() [2/3]

◆ scrollMenu() [3/3]

◆ setCurrentAction()

◆ setFirstActionActive()

◆ setMacMenuEnabled()

◆ setOverrideMenuAction()

◆ setSyncAction()

◆ syncSeparatorsCollapsible()

◆ topCausedWidget()

◆ updateActionRects() [1/2]

◆ updateActionRects() [2/2]

◆ updateLayoutDirection()

◆ wceCommands()

◆ wceMenu()

Properties

◆ aboutToHide

◆ actionAboutToTrigger

◆ actionRects

◆ activationRecursionGuard

◆ activeMenu

◆ causedPopup

◆ collapsibleSeparators

◆ currentAction

◆ defaultAction

◆ defaultMenuAction

◆ doChildEffects

◆ eventLoop

◆ hasCheckableItems

◆ hasHadMouse

◆ itemsDirty

◆ mac_menu

◆ maxIconWidth

◆ menuAction

◆ menuDelayTimer

◆ mergeMenuHash

◆ mergeMenuItemsHash

◆ motions

◆ mouseDown

◆ mousePopupPos

◆ ncols

◆ noReplayFor

◆ scroll

◆ searchBuffer