menu.c File Reference

#include "precomp.h"

Go to the source code of this file.

Defines
#define	pmenuNext   (((PMENUWND)ppopupmenu->spwndNextPopup)->ppopupmenu->spmenu)
Functions
void	xxxMNDismiss (PMENUSTATE pMenuState)
BOOL	MNFadeSelection (PMENU pmenu, PITEM pitem)
void	xxxMNDismissWithNotify (PMENUSTATE pMenuState, PMENU pmenu, PITEM pitem, UINT uPos, LPARAM lParam)
PITEM	MNGetpItem (PPOPUPMENU ppopup, UINT uIndex)
void	xxxMNSetCapture (PPOPUPMENU ppopup)
void	xxxMNReleaseCapture (void)
void	MNCheckButtonDownState (PMENUSTATE pMenuState)
PWND	GetMenuStateWindow (PMENUSTATE pMenuState)
void	UnlockPopupMenuWindow (PMENU pmenu, PWND pwnd)
PVOID	LockPopupMenu (PPOPUPMENU ppopup, PMENU *pspmenu, PMENU pmenu)
PVOID	UnlockPopupMenu (PPOPUPMENU ppopup, PMENU *pspmenu)
PVOID	LockWndMenu (PWND pwnd, PMENU *pspmenu, PMENU pmenu)
PVOID	UnlockWndMenu (PWND pwnd, PMENU *pspmenu)
BOOL	xxxMNSetTop (PPOPUPMENU ppopup, int iNewTop)
BOOL	xxxMNDoScroll (PPOPUPMENU ppopup, UINT uArrow, BOOL fSetTimer)
int	MNCheckScroll (PMENU pMenu, PMONITOR pMonitor)
BOOL	MNIsPopupItem (ITEM *lpItem)
BOOL	xxxMNSwitchToAlternateMenu (PPOPUPMENU ppopupmenu)
void	xxxMNDestroyHandler (PPOPUPMENU ppopupmenu)
void	xxxMNChar (PPOPUPMENU ppopupmenu, PMENUSTATE pMenuState, UINT character)
DWORD	GetMenuInheritedContextHelpId (PPOPUPMENU ppopup)
void	xxxMNKeyDown (PPOPUPMENU ppopupmenu, PMENUSTATE pMenuState, UINT key)
UINT	xxxMNPositionHierarchy (PPOPUPMENU ppopup, PITEM pitem, int cx, int cy, int *px, int *py, PMONITOR *ppMonitor)
void	xxxCleanupDesktopMenu (PWND pwndDeskMenu, PDESKTOP pdesk)
PWND	xxxMNOpenHierarchy (PPOPUPMENU ppopupmenu, PMENUSTATE pMenuState)
BOOL	xxxMNHideNextHierarchy (PPOPUPMENU ppopup)
void	xxxMNCloseHierarchy (PPOPUPMENU ppopupmenu, PMENUSTATE pMenuState)
BOOL	xxxMNDoubleClick (PMENUSTATE pMenuState, PPOPUPMENU ppopup, int idxItem)
PITEM	xxxMNSelectItem (PPOPUPMENU ppopupmenu, PMENUSTATE pMenuState, UINT itemPos)
UINT	MNItemHitTest (PMENU pMenu, PWND pwnd, POINT pt)
void	LockMFMWFPWindow (PULONG_PTR puHitArea, ULONG_PTR uNewHitArea)
void	UnlockMFMWFPWindow (PULONG_PTR puHitArea)
BOOL	IsMFMWFPWindow (ULONG_PTR uHitArea)
LONG_PTR	xxxMNFindWindowFromPoint (PPOPUPMENU ppopupmenu, PUINT pIndex, POINTS screenPt)
void	xxxMNCancel (PMENUSTATE pMenuState, UINT uMsg, UINT cmd, LPARAM lParam)
void	xxxMNButtonDown (PPOPUPMENU ppopupmenu, PMENUSTATE pMenuState, UINT posItemHit, BOOL fClick)
void	MNSetTimerToAutoDismiss (PMENUSTATE pMenuState, PWND pwnd)
void	xxxMNMouseMove (PPOPUPMENU ppopup, PMENUSTATE pMenuState, POINTS ptScreen)
void	xxxMNButtonUp (PPOPUPMENU ppopup, PMENUSTATE pMenuState, UINT posItemHit, LPARAM lParam)
UINT	MNSetTimerToOpenHierarchy (PPOPUPMENU ppopup)
UINT	MNSetTimerToCloseHierarchy (PPOPUPMENU ppopup)
BOOL	xxxCallHandleMenuMessages (PMENUSTATE pMenuState, PWND pwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT	xxxMenuWindowProc (PWND pwnd, UINT message, WPARAM wParam, LPARAM lParam)

---

Define Documentation

#define pmenuNext   (((PMENUWND)ppopupmenu->spwndNextPopup)->ppopupmenu->spmenu)

Referenced by xxxMenuWindowProc().

---

Function Documentation

DWORD GetMenuInheritedContextHelpId (  PPOPUPMENU  ppopup  )

Definition at line 1196 of file ntuser/kernel/menu.c. References tagMENU::dwContextHelpId, DWORD, tagPOPUPMENU::fHasMenuBar, tagPOPUPMENU::fIsMenuBar, NULL, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPrevPopup, and TRUE. Referenced by xxxMNKeyDown(). { PWND pWnd; /* * If we are already at the menubar, simply return it's ContextHelpId */ UserAssert(ppopup != NULL); if (ppopup->fIsMenuBar) goto Exit_GMI; while(TRUE) { UserAssert(ppopup != NULL); /* * See if the given popup has a context help id. */ if (ppopup->spmenu->dwContextHelpId) { /* Found the context Id */ break; } /* * Get the previous popup menu; * Check if the previous menu is the menu bar. */ if ( (ppopup->fHasMenuBar) && (ppopup->spwndPrevPopup == ppopup->spwndNotify)) { ppopup = ppopup -> ppopupmenuRoot; break; } else { /* * See if this has a valid prevPopup; (it could be TrackPopup menu) */ if ((pWnd = ppopup -> spwndPrevPopup) == NULL) { return ((DWORD)0); } ppopup = ((PMENUWND)pWnd)->ppopupmenu; } } Exit_GMI: return(ppopup->spmenu->dwContextHelpId); }

PWND GetMenuStateWindow (  PMENUSTATE  pMenuState  )

Definition at line 232 of file ntuser/kernel/menu.c. References tagPOPUPMENU::fIsTrackPopup, NULL, tagMENUSTATE::pGlobalPopupMenu, tagPOPUPMENU::spwndActivePopup, tagPOPUPMENU::spwndNextPopup, and tagPOPUPMENU::spwndPopupMenu. Referenced by NtUserEndMenu(), xxxHandleMenuMessages(), and xxxMNDragOver(). { if (pMenuState == NULL) { return NULL; } else if (pMenuState->pGlobalPopupMenu->fIsTrackPopup) { return pMenuState->pGlobalPopupMenu->spwndPopupMenu; } else if (pMenuState->pGlobalPopupMenu->spwndNextPopup != NULL) { return pMenuState->pGlobalPopupMenu->spwndNextPopup; } else { return pMenuState->pGlobalPopupMenu->spwndActivePopup; } }

BOOL IsMFMWFPWindow (  ULONG_PTR  uHitArea  )

Definition at line 3145 of file ntuser/kernel/menu.c. References BOOL, FALSE, MFMWFP_ALTMENU, MFMWFP_NOITEM, MFMWFP_OFFMENU, and TRUE. Referenced by LockMFMWFPWindow(), UnlockMFMWFPWindow(), xxxHandleMenuMessages(), xxxMenuWindowProc(), xxxMNFindWindowFromPoint(), xxxMNSetGapState(), and xxxMNUpdateDraggingInfo(). { switch(uHitArea) { case MFMWFP_OFFMENU: case MFMWFP_NOITEM: case MFMWFP_ALTMENU: return FALSE; default: return TRUE; } }

void LockMFMWFPWindow (  PULONG_PTR  puHitArea, ULONG_PTR  uNewHitArea )

Definition at line 3097 of file ntuser/kernel/menu.c. References IsMFMWFPWindow(), Lock, and UnlockMFMWFPWindow(). Referenced by xxxHandleMenuMessages(), and xxxMNUpdateDraggingInfo(). { /* * Bail if there is nothing to do. */ if (*puHitArea == uNewHitArea) { return; } /* * Unlock current hit area */ UnlockMFMWFPWindow(puHitArea); /* * Lock new hit area */ if (IsMFMWFPWindow(uNewHitArea)) { Lock(puHitArea, (PWND)uNewHitArea); } else { *puHitArea = uNewHitArea; } }

PVOID LockPopupMenu (  PPOPUPMENU  ppopup, PMENU *  pspmenu, PMENU  pmenu )

Definition at line 296 of file ntuser/kernel/menu.c. References tagWND::head, Lock, NULL, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagPOPUPMENU::spwndNotify, tagMENU::spwndNotify, UnlockPopupMenuWindow(), and Validateppopupmenu. Referenced by xxxMenuWindowProc(), xxxMNKeyDown(), xxxMNOpenHierarchy(), xxxMNStartMenu(), and xxxTrackPopupMenuEx(). { /* * If you hit this assertion, you're probably not passing the right thing */ UserAssert((pspmenu == &ppopup->spmenu) || (pspmenu == &ppopup->spmenuAlternate)); Validateppopupmenu(ppopup); /* * This won't work properly if the popup hasn't locked the notification * window. */ UserAssert(ppopup->spwndNotify != NULL); /* * When using modeless menus, menus can be shared by several active popups. * If the menu has owner draw items, the app better knows how to draw them * correctly. This shouldn't happen with modal menus though */ #if DBG if ((*pspmenu != NULL) && ((*pspmenu)->spwndNotify != NULL) && ((*pspmenu)->spwndNotify != ppopup->spwndNotify)) { RIPMSG3(RIP_WARNING, "LockPopupMenu: Current Menu %#p shared by %#p and %#p", *pspmenu, (*pspmenu)->spwndNotify, ppopup->spwndNotify); } #endif /* * Unlock the current's menu spwndNotify if needed */ UnlockPopupMenuWindow(*pspmenu, ppopup->spwndNotify); /* * Lock the notification window into the menu structure */ if (pmenu != NULL) { /* * Display a warning if this menu is being shared */ #if DBG if ((pmenu->spwndNotify != NULL) && (pmenu->spwndNotify != ppopup->spwndNotify) && (pmenu != pmenu->spwndNotify->head.rpdesk->spmenuDialogSys)) { RIPMSG3(RIP_WARNING, "LockPopupMenu: New Menu %#p shared by %#p and %#p", pmenu, pmenu->spwndNotify, ppopup->spwndNotify); } #endif /* * spwndNotify "owns" this menu now. */ Lock(&pmenu->spwndNotify, ppopup->spwndNotify); } /* * Lock the menu into the popup structure (unlock the previous one) */ return Lock(pspmenu, pmenu); }

PVOID LockWndMenu (  PWND  pwnd, PMENU *  pspmenu, PMENU  pmenu )

Definition at line 422 of file ntuser/kernel/menu.c. References Lock, NULL, tagWND::spmenu, tagWND::spmenuSys, tagMENU::spwndNotify, and Unlock. Referenced by xxxCreateWindowEx(), xxxGetSystemMenu(), xxxSetDialogSystemMenu(), xxxSetMenu(), xxxSetSystemMenu(), and xxxSetWindowData(). { /* * If you hit this assertion, you're probably not passing the right thing */ UserAssert((pspmenu == &pwnd->spmenu) || (pspmenu == &pwnd->spmenuSys)); /* * If the current menu is owned by this window, unlock it */ if ((*pspmenu != NULL) && ((*pspmenu)->spwndNotify == pwnd)) { Unlock(&((*pspmenu)->spwndNotify)); } /* * If nobody owns the new menu, make this window the owner */ if ((pmenu != NULL) && (pmenu->spwndNotify == NULL)) { Lock(&pmenu->spwndNotify, pwnd); } /* * Lock the menu into the window structure (unlock the previous menu) */ return Lock(pspmenu, pmenu); }

void MNCheckButtonDownState (  PMENUSTATE  pMenuState  )

Definition at line 206 of file ntuser/kernel/menu.c. References _GetKeyState(), FALSE, tagMENUSTATE::fButtonDown, tagMENUSTATE::fDragAndDrop, tagMENUSTATE::fDragging, tagMENUSTATE::fIgnoreButtonUp, tagMENUSTATE::fModelessMenu, tagMENUSTATE::uButtonDownHitArea, UnlockMFMWFPWindow(), and tagMENUSTATE::vkButtonDown. Referenced by xxxCallHandleMenuMessages(), and xxxMenuWindowProc(). { /* * Modeless menus don't capture the mouse so when a mouse down * goes off the window, we need to keep watching its state. * We also might not see the button up when going on DoDragDrop loop */ UserAssert(pMenuState->fDragAndDrop || pMenuState->fModelessMenu); pMenuState->fButtonDown = ((_GetKeyState(pMenuState->vkButtonDown) & 0x8000) != 0); if (!pMenuState->fButtonDown) { pMenuState->fDragging = pMenuState->fIgnoreButtonUp = FALSE; UnlockMFMWFPWindow(&pMenuState->uButtonDownHitArea); } }

int MNCheckScroll (  PMENU  pMenu, PMONITOR  pMonitor )

Definition at line 627 of file ntuser/kernel/menu.c. References tagMENU::cItems, tagITEM::cxItem, tagMENU::cxMenu, tagITEM::cyItem, tagMENU::cyMax, tagMENU::cyMenu, tagMENU::dwArrowsOn, gcyMenuScrollArrow, tagMENU::iMaxTop, tagMENU::iTop, MSA_ATBOTTOM, MSA_ATTOP, MSA_OFF, MSA_ON, tagMONITOR::rcMonitor, tagMENU::rgItems, SYSMET, UINT, and tagITEM::yItem. Referenced by xxxMenuWindowProc(). { int i; UINT cyMax; PITEM pItem; /* * Max height that fits on the monitor */ cyMax = (pMonitor->rcMonitor.bottom - pMonitor->rcMonitor.top); /* * If the menu has a valid max height, use it */ if ((pMenu->cyMax != 0) && (pMenu->cyMax < cyMax)) { cyMax = pMenu->cyMax; } /* * Bail if menu is either empty, multicolumn, or able to fit * without scrolling */ if ((pMenu->rgItems == 0) || (pMenu->rgItems->cxItem != pMenu->cxMenu) || (pMenu->cyMenu + (2 * SYSMET(CYFIXEDFRAME)) <= cyMax)) { pMenu->dwArrowsOn = MSA_OFF; pMenu->iTop = 0; pMenu->iMaxTop = 0; return pMenu->cyMenu; } /* * Max client height */ cyMax -= 2 * (SYSMET(CYFIXEDFRAME) + gcyMenuScrollArrow); /* * Determine the menu height * Find the first item that won't fit. */ pItem = pMenu->rgItems; for (i = 0; i < (int)pMenu->cItems; i++, pItem++) { if (pItem->yItem > (UINT)cyMax) { break; } } if (i != 0) { pItem--; } pMenu->cyMenu = pItem->yItem; /* * compute the last possible top item when all remaining items are fully * visible */ cyMax = 0; i = pMenu->cItems - 1; pItem = pMenu->rgItems + i; for (; i >= 0; i--, pItem--) { cyMax += pItem->cyItem; if (cyMax > pMenu->cyMenu) { break; } } if ((UINT)i != pMenu->cItems - 1) { i++; } pMenu->iMaxTop = i; /* * Update top item and scroll state */ if (pMenu->iTop > i) { pMenu->iTop = i; } if (pMenu->iTop == i) { pMenu->dwArrowsOn = MSA_ATBOTTOM; } else if (pMenu->iTop == 0) { pMenu->dwArrowsOn = MSA_ATTOP; } else { pMenu->dwArrowsOn = MSA_ON; } /* * This is funtion is called by MN_SIZEWINDOW which doesn't check * if the scroll bars are present but simply adds (2 * SYSMET(CYFIXEDFRAME)) * to calculate the window height. So we add the scrollbars height * here. (I believe MN_SIZEWINDOW is a private-but-publicly-known message) */ return (pMenu->cyMenu + (2 * gcyMenuScrollArrow)); }

BOOL MNFadeSelection (  PMENU  pmenu, PITEM  pitem )

Definition at line 47 of file ntuser/kernel/menu.c. References BOOL, CMS_SELECTIONFADE, CreateFade(), tagITEM::cxItem, tagITEM::cyItem, FALSE, gpDispInfo, tagDISPLAYINFO::hdcScreen, MNGetPopupFromMenu(), NULL, tagWND::rcClient, ShowFade(), tagPOPUPMENU::spwndPopupMenu, TestALPHA, TRUE, tagITEM::xItem, and tagITEM::yItem. Referenced by xxxMNDismissWithNotify(). { PWND pwnd; HDC hdc; RECT rc; PPOPUPMENU ppopup; if (!TestALPHA(SELECTIONFADE)) return FALSE; /* * Get the window for the currently active popup menu. */ if ((ppopup = MNGetPopupFromMenu(pmenu, NULL)) == NULL) return FALSE; if ((pwnd = ppopup->spwndPopupMenu) == NULL) return FALSE; rc.left = pwnd->rcClient.left + pitem->xItem; rc.top = pwnd->rcClient.top + pitem->yItem; rc.right = rc.left + pitem->cxItem; rc.bottom = rc.top + pitem->cyItem; /* * Initialize the fade animation and get the DC to draw the selection into. */ if ((hdc = CreateFade(NULL, &rc, CMS_SELECTIONFADE, 0)) == NULL) return FALSE; /* * Read the current menu selection right from the screen, since the menu * is still visible and it's always on top. In the worst case we could * offset the origin of the DC and call xxxDrawMenuItem, but just reading * from the screen is much faster. */ GreBitBlt(hdc, 0, 0, pitem->cxItem, pitem->cyItem, gpDispInfo->hdcScreen, rc.left, rc.top, SRCCOPY, 0); ShowFade(); return TRUE; }

PITEM MNGetpItem (  PPOPUPMENU  ppopup, UINT  uIndex )

Definition at line 136 of file ntuser/kernel/menu.c. References tagMENU::cItems, NULL, tagMENU::rgItems, and tagPOPUPMENU::spmenu. Referenced by xxxMenuWindowProc(), xxxMNSetGapState(), and xxxMNUpdateDraggingInfo(). { if ((ppopup == NULL) || (uIndex >= ppopup->spmenu->cItems)) { return NULL; } return ppopup->spmenu->rgItems + uIndex; }

BOOL MNIsPopupItem (  ITEM *  lpItem  )

Definition at line 727 of file ntuser/kernel/menu.c. References BOOL, ITEM, tagITEM::spSubMenu, and TestMFS. Referenced by xxxMNButtonDown(). { return((lpItem) && (lpItem->spSubMenu) && !TestMFS(lpItem, MFS_GRAYED)); }

UINT MNItemHitTest (  PMENU  pMenu, PWND  pwnd, POINT  pt )

Definition at line 2983 of file ntuser/kernel/menu.c. References tagMENU::cItems, tagQ::codeCapture, CopyInflateRect(), tagITEM::cxItem, tagITEM::cyItem, tagMENU::cyMenu, tagMENU::dwArrowsOn, tagMENU::iTop, MFISPOPUP, MFMWFP_DOWNARROW, MFMWFP_NOITEM, MFMWFP_UPARROW, MNGetToppItem(), MSA_OFF, NO_CAP_SYS, tagTHREADINFO::pq, PtiCurrent, PtInRect(), tagWND::rcClient, tagWND::rcWindow, tagMENU::rgItems, SCREEN_CAPTURE, SYSMET, TestMF, TestWF, and UINT. Referenced by FindNCHitEx(), xxxMenuItemFromPoint(), and xxxMNFindWindowFromPoint(). { PITEM pItem; UINT iItem; RECT rect; PTHREADINFO ptiCurrent = PtiCurrent(); if (pMenu->cItems == 0) return MFMWFP_NOITEM; /* * This point is screen-relative. Menu bar coordinates relative * to the window. But popup menu coordinates are relative to the client. */ if (TestMF(pMenu, MFISPOPUP)) { /* * Bail if it's outside rcWindow */ CopyInflateRect(&rect, &(pwnd->rcWindow), -SYSMET(CXFIXEDFRAME), -SYSMET(CYFIXEDFRAME)); if (!PtInRect(&rect, pt)) { return MFMWFP_NOITEM; } /* ScreenToClient */ #ifdef USE_MIRRORING if (TestWF(pwnd, WEFLAYOUTRTL)) { pt.x = pwnd->rcClient.right - pt.x; } else #endif { pt.x -= pwnd->rcClient.left; } pt.y -= pwnd->rcClient.top; /* * If on the non client area, then it's on the scroll arrows */ if (pt.y < 0) { return MFMWFP_UPARROW; } else if (pt.y > (int)pMenu->cyMenu) { return MFMWFP_DOWNARROW; } } else { /* ScreenToWindow */ #ifdef USE_MIRRORING if (TestWF(pwnd, WEFLAYOUTRTL) && ( (ptiCurrent->pq->codeCapture == SCREEN_CAPTURE) || (ptiCurrent->pq->codeCapture == NO_CAP_SYS) ) ) { pt.x = pwnd->rcWindow.right - pt.x; } else #endif { pt.x -= pwnd->rcWindow.left; } pt.y -= pwnd->rcWindow.top; } /* * Step through all the items in the menu. * If scrollable menu */ if (pMenu->dwArrowsOn != MSA_OFF) { UserAssert(TestMF(pMenu, MFISPOPUP)); pItem = MNGetToppItem(pMenu); rect.left = rect.top = 0; rect.right = pItem->cxItem; rect.bottom = pItem->cyItem; for (iItem = pMenu->iTop; (iItem < (int)pMenu->cItems) && (rect.top < (int)pMenu->cyMenu); iItem++) { if (PtInRect(&rect, pt)) { return iItem; } pItem++; rect.top = rect.bottom; rect.bottom += pItem->cyItem; } } else { /* * No scroll bars. */ for (iItem = 0, pItem = pMenu->rgItems; iItem < pMenu->cItems; iItem++, pItem++) { /* Is the mouse inside this item's rectangle? */ rect.left = pItem->xItem; rect.top = pItem->yItem; rect.right = pItem->xItem + pItem->cxItem; rect.bottom = pItem->yItem + pItem->cyItem; if (PtInRect(&rect, pt)) { return(iItem); } } } return(MFMWFP_NOITEM); }

void MNSetTimerToAutoDismiss (  PMENUSTATE  pMenuState, PWND  pwnd )

Definition at line 3600 of file ntuser/kernel/menu.c. References _SetTimer(), tagMENUSTATE::fAboutToAutoDismiss, tagMENUSTATE::fAutoDismiss, gdtMNDropDown, IDSYS_MNAUTODISMISS, NULL, and TRUE. Referenced by xxxMenuWindowProc(), and xxxMNMouseMove(). { if (pMenuState->fAutoDismiss && !pMenuState->fAboutToAutoDismiss) { if (_SetTimer(pwnd, IDSYS_MNAUTODISMISS, 16 * gdtMNDropDown, NULL)) { pMenuState->fAboutToAutoDismiss = TRUE; } else { RIPMSG0(RIP_WARNING, "xxxMNMouseMove: Failed to set autodismiss timer"); } } }

UINT MNSetTimerToCloseHierarchy (  PPOPUPMENU  ppopup  )

Definition at line 3917 of file ntuser/kernel/menu.c. References _SetTimer(), tagPOPUPMENU::fAboutToHide, tagPOPUPMENU::fHideTimer, tagPOPUPMENU::fHierarchyDropped, gdtMNDropDown, IDSYS_MNHIDE, NULL, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndPopupMenu, TRUE, and UINT. Referenced by xxxMNSelectItem(). { if (!ppopup->fHierarchyDropped) return(0); if (ppopup->fHideTimer) return(1); if (!_SetTimer(ppopup->spwndPopupMenu, IDSYS_MNHIDE, gdtMNDropDown, NULL)) return((UINT) -1); ppopup->fHideTimer = TRUE; ppopup = ((PMENUWND)(ppopup->spwndNextPopup))->ppopupmenu; ppopup->fAboutToHide = TRUE; return(1); }

UINT MNSetTimerToOpenHierarchy (  PPOPUPMENU  ppopup  )

Definition at line 3870 of file ntuser/kernel/menu.c. References _SetTimer(), tagMENU::cItems, tagPOPUPMENU::fHierarchyDropped, tagPOPUPMENU::fShowTimer, tagITEM::fState, gdtMNDropDown, IDSYS_MNSHOW, MFMWFP_NOITEM, NULL, tagPOPUPMENU::posDropped, tagPOPUPMENU::posSelectedItem, tagMENU::rgItems, tagPOPUPMENU::spmenu, tagITEM::spSubMenu, tagPOPUPMENU::spwndPopupMenu, TRUE, and UINT. Referenced by xxxMenuWindowProc(). { PITEM pItem; /* * No selection so fail */ if (ppopup->posSelectedItem == MFMWFP_NOITEM) return(0); if (ppopup->posSelectedItem >= ppopup->spmenu->cItems) return(0); /* * Is item an enabled popup? * Get a pointer to the currently selected item in this menu. */ pItem = ppopup->spmenu->rgItems + ppopup->posSelectedItem; if ((pItem->spSubMenu == NULL) || (pItem->fState & MFS_GRAYED)) return(0); if (ppopup->fShowTimer || (ppopup->fHierarchyDropped && (ppopup->posSelectedItem == ppopup->posDropped))) { /* * A timer is already set or the hierarchy is already opened. */ return 1; } if (!_SetTimer(ppopup->spwndPopupMenu, IDSYS_MNSHOW, gdtMNDropDown, NULL)) return (UINT)-1; ppopup->fShowTimer = TRUE; return 1; }

void UnlockMFMWFPWindow (  PULONG_PTR  puHitArea  )

Definition at line 3128 of file ntuser/kernel/menu.c. References IsMFMWFPWindow(), MFMWFP_OFFMENU, and Unlock. Referenced by LockMFMWFPWindow(), MNCheckButtonDownState(), xxxHandleMenuMessages(), xxxMNDragLeave(), and xxxMNEndMenuState(). { if (IsMFMWFPWindow(*puHitArea)) { Unlock(puHitArea); } else { *puHitArea = MFMWFP_OFFMENU; } }

PVOID UnlockPopupMenu (  PPOPUPMENU  ppopup, PMENU *  pspmenu )

Definition at line 367 of file ntuser/kernel/menu.c. References IsRootPopupMenu(), NULL, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagPOPUPMENU::spwndNotify, Unlock, and UnlockPopupMenuWindow(). Referenced by MNFreePopup(), and xxxMNKeyDown(). { /* * If you hit this assertion, you're probably not passing the right thing */ UserAssert((pspmenu == &ppopup->spmenu) || (pspmenu == &ppopup->spmenuAlternate)); /* * If nothing is locked, bail. */ if (*pspmenu == NULL) { return NULL; } /* * This won't work properly if the popup already unlocked the notification * window. However, this can happen with the root popup if the * notification window gets destroyed while in menu mode. */ UserAssert((ppopup->spwndNotify != NULL) || IsRootPopupMenu(ppopup)); /* * When using modeless menus, menus can be shared by several active * popups/notification windows. If the menu has owner draw items, * the app better knows how to paint them right. It shouldn't * happen with modal menus though. */ #if DBG if (((*pspmenu)->spwndNotify != NULL) && (ppopup->spwndNotify != NULL) && (ppopup->spwndNotify != (*pspmenu)->spwndNotify)) { RIPMSG3(RIP_WARNING, "UnlockPopupMenu: Menu %#p shared by %#p and %#p", *pspmenu, (*pspmenu)->spwndNotify, ppopup->spwndNotify); } #endif /* * Unlock the menu's spwndNotify if needed */ UnlockPopupMenuWindow(*pspmenu, ppopup->spwndNotify); /* * Unlock the menu from the popup structure */ return Unlock(pspmenu); }

void UnlockPopupMenuWindow (  PMENU  pmenu, PWND  pwnd )

Definition at line 258 of file ntuser/kernel/menu.c. References NULL, tagWND::spmenu, tagWND::spmenuSys, tagMENU::spwndNotify, TestWF, Unlock, and WFDESTROYED. Referenced by LockPopupMenu(), and UnlockPopupMenu(). { /* * Bail if there's nothing to unlock */ if ((pmenu == NULL) || (pmenu->spwndNotify == NULL)) { return; } /* * if pmenu->spwndNotify owns the menu, bail */ if ((pmenu == pmenu->spwndNotify->spmenu) || (pmenu == pmenu->spwndNotify->spmenuSys)) { return; } /* * If pwnd doesn't own the menu, and pmenu->spwndNotify is not destroyed, bail */ if ((pwnd != pmenu->spwndNotify) && !TestWF(pmenu->spwndNotify, WFDESTROYED)) { return; } /* * Unlock it */ Unlock(&pmenu->spwndNotify); return; }

PVOID UnlockWndMenu (  PWND  pwnd, PMENU *  pspmenu )

Definition at line 458 of file ntuser/kernel/menu.c. References NULL, tagWND::spmenu, tagWND::spmenuSys, and Unlock. Referenced by xxxFreeWindow(), xxxGetSystemMenu(), xxxSetWindowData(), and xxxSetWindowStyle(). { /* * If you hit this assertion, you're probably not passing the right thing */ UserAssert((pspmenu == &pwnd->spmenu) || (pspmenu == &pwnd->spmenuSys)); /* * If nothing is locked, bail */ if (*pspmenu == NULL) { return NULL; } /* * If this window owns the menu, unlock it from the menu strucutre */ if (pwnd == (*pspmenu)->spwndNotify) { Unlock(&((*pspmenu)->spwndNotify)); } /* * Unlock the menu from the window structure */ return Unlock(pspmenu); }

BOOL xxxCallHandleMenuMessages (  PMENUSTATE  pMenuState, PWND  pwnd, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 3951 of file ntuser/kernel/menu.c. References BOOL, CheckLock, ExitMenuLoop(), FALSE, tagMENUSTATE::fButtonDown, tagMENUSTATE::fInCallHandleMenuMessages, tagMENUSTATE::fInDoDragDrop, tagMENUSTATE::fModelessMenu, tagMENUSTATE::fMouseOffMenu, GET_X_LPARAM, GET_Y_LPARAM, HW, MNCheckButtonDownState(), msg, NULL, tagMENUSTATE::pGlobalPopupMenu, tagWND::rcClient, TRUE, xxxEndMenuLoop(), xxxHandleMenuMessages(), and xxxMNEndMenuState(). Referenced by xxxMenuWindowProc(), xxxMNDragOver(), and xxxScanSysQueue(). { BOOL fHandled; MSG msg; CheckLock(pwnd); UserAssert(pMenuState->fModelessMenu || pMenuState->fInDoDragDrop); /* * Since modeless menus don't capture the mouse, then we need to * keep checking on the mouse button when the mouse is off the * menu. * Note that we do not set fMouseOffMenu if fInDoDragDrop is set */ if (pMenuState->fMouseOffMenu && pMenuState->fButtonDown) { UserAssert(!pMenuState->fInDoDragDrop && pMenuState->fModelessMenu); MNCheckButtonDownState(pMenuState); } /* * Setup the msg structure */ msg.hwnd = HW(pwnd); msg.message = message; msg.wParam = wParam; /* * xxxHandleMenuMessages expects screen coordinates */ if ((message >= WM_MOUSEFIRST) && (message <= WM_MOUSELAST)) { msg.lParam = MAKELONG(GET_X_LPARAM(lParam) + pwnd->rcClient.left, GET_Y_LPARAM(lParam) + pwnd->rcClient.top); } else { msg.lParam = lParam; } /* * Not used by xxxHandleMenuMessages */ msg.time = 0; msg.pt.x = msg.pt.x = 0; UserAssert(pMenuState->pGlobalPopupMenu != NULL); pMenuState->fInCallHandleMenuMessages = TRUE; fHandled = xxxHandleMenuMessages(&msg, pMenuState, pMenuState->pGlobalPopupMenu); pMenuState->fInCallHandleMenuMessages = FALSE; /* * If the message was handled and this is a modeless menu, * check to see if it's time to go. */ if (fHandled && pMenuState->fModelessMenu && ExitMenuLoop (pMenuState, pMenuState->pGlobalPopupMenu)) { xxxEndMenuLoop (pMenuState, pMenuState->pGlobalPopupMenu); xxxMNEndMenuState(TRUE); } return fHandled; }

void xxxCleanupDesktopMenu (  PWND  pwndDeskMenu, PDESKTOP  pdesk )

Definition at line 1908 of file ntuser/kernel/menu.c. References _GetDesktopWindow, CheckLock, tagWND::head, tagDESKTOP::pDeskInfo, tagDESKTOPINFO::spwnd, tagDESKTOP::spwndMessage, tagWND::spwndOwner, tagWND::spwndParent, ThreadLockAlways, ThreadUnlock, Unlock, and xxxSetParent(). Referenced by xxxMNCloseHierarchy(), and xxxMNOpenHierarchy(). { TL tlpwnd; CheckLock(pwndDeskMenu); /* * Put it on the message window tree so it is out of the way. */ UserAssert(pwndDeskMenu->spwndParent == _GetDesktopWindow()); ThreadLockAlways(pdesk->spwndMessage, &tlpwnd); xxxSetParent(pwndDeskMenu, pdesk->spwndMessage); ThreadUnlock(&tlpwnd); /* * Give ownershipe back to the desktop thread */ pwndDeskMenu->head.pti = pdesk->pDeskInfo->spwnd->head.pti; Unlock(&pwndDeskMenu->spwndOwner); }

LRESULT xxxMenuWindowProc (  PWND  pwnd, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 4022 of file ntuser/kernel/menu.c. References _GetDCEx(), _KillTimer(), _MonitorFromWindow(), _PostMessage(), _ReleaseDC(), _SetTimer(), ATW_SETFOCUS, AW_SKIP2, BOOL, CheckLock, tagMENU::cItems, ClearMF, CMS_MENUFADE, CreateFade(), tagMENUSTATE::cxAni, tagMENU::cxMenu, cy, tagMENUSTATE::cyAni, tagMENUSTATE::dwAniStartTime, tagMENU::dwArrowsOn, dwFlags, DWORD, tagMENUSTATE::fAboutToAutoDismiss, tagMENUSTATE::fActiveNoForeground, FADE_MENU, FADE_SHOW, FALSE, FBadWindow(), tagMENUSTATE::fButtonDown, tagMENUSTATE::fDragAndDrop, tagMENUSTATE::fDragging, tagMENUSTATE::fIgnoreButtonUp, tagMENUSTATE::fInCallHandleMenuMessages, tagPOPUPMENU::fInCancel, FindBestPos(), tagMENUSTATE::fInDoDragDrop, tagMENUSTATE::fModelessMenu, tagMENUSTATE::fMouseOffMenu, FNID_MENU, tagITEM::fState, tagPOPUPMENU::fToggle, tagPOPUPMENU::fTrackMouseEvent, gcyMenuScrollArrow, GET_X_LPARAM, GET_Y_LPARAM, GetAppCompatFlags2(), GETFNID, GetpMenuState(), GETPTI, gpqForeground, gpqForegroundPrev, tagMENU::hbrBack, tagMENUSTATE::hdcWndAni, tagWND::head, HRGN_FULL, HW, tagMENUSTATE::iAniDropDir, tagPOPUPMENU::iDropDir, IDSYS_MNANIMATE, IDSYS_MNAUTODISMISS, IDSYS_MNDOWN, IDSYS_MNHIDE, IDSYS_MNSHOW, IDSYS_MNUP, InflateRect(), Is500Compat, ISAMENU, IsMFMWFPWindow(), IsRecursedMenuState(), tagMENUSTATE::ixAni, tagMENUSTATE::iyAni, L, Lock, LockMenuState(), LockPopupMenu(), MFMWFP_MINVALID, MFMWFP_NOITEM, MFWINDOWDC, MNAllocPopup(), MNAnimate(), MNCheckButtonDownState(), MNCheckScroll(), MNCreateAnimationBitmap(), MNDrawFullNC(), MNEraseBackground(), MNFindNextValidItem(), MNGetpItem(), MNSetTimerToAutoDismiss(), MNSetTimerToOpenHierarchy(), MNSW_DRAWFRAME, MNSW_RETURNSIZE, MNXBORDER, MNYBORDER, MSA_OFF, NCA_ACTIVE, NCA_FORCEFRAMEOFF, NextTopWindow(), NtGetTickCount(), NULL, PAS_HORZ, PAS_OUT, PAS_VERT, tagMENUSTATE::pGlobalPopupMenu, PlayEventSound(), pmenuNext, tagMENUSTATE::pmnsPrev, tagPOPUPMENU::posDropped, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::ppopupmenuRoot, tagTHREADINFO::pq, PtiCurrent, PtInRect(), PtoH, PUINT, PWND_TOP, QF_CAPTURELOCKED, tagWND::rcClient, tagWND::rcWindow, RevalidateHwnd, SetMF, ShowFade(), tagPOPUPMENU::spmenu, tagITEM::spSubMenu, tagPOPUPMENU::spwndActivePopup, tagQ::spwndActivePrev, tagWND::spwndLastActive, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, StartFade(), SYSMET, TestALPHA, TestEffectUP, TestFadeFlags(), TestWF, ThreadLock, ThreadLockAlways, ThreadLockAlwaysWithPti, ThreadUnlock, TRUE, tagMENUSTATE::uButtonDownHitArea, tagMENUSTATE::uButtonDownIndex, UINT, USER_SOUND_MENUPOPUP, VALIDATECLASSANDSIZE, ValidateHmenu(), Validateppopupmenu, VER40, WFVISIBLE, xxxActivateThisWindow(), xxxActivateWindow(), xxxBeginPaint(), xxxCallHandleMenuMessages(), xxxClientRevokeDragDrop(), xxxDefWindowProc(), xxxDWP_DoNCActivate(), xxxEndMenuLoop(), xxxEndPaint(), xxxMenuDraw(), xxxMNButtonDown(), xxxMNButtonUp(), xxxMNCancel(), xxxMNChar(), xxxMNCloseHierarchy(), xxxMNCompute(), xxxMNDestroyHandler(), xxxMNDoScroll(), xxxMNDoubleClick(), xxxMNEndMenuState(), xxxMNFindWindowFromPoint(), xxxMNKeyDown(), xxxMNMouseMove(), xxxMNOpenHierarchy(), xxxMNPositionHierarchy(), xxxMNSelectItem(), xxxMNSetCapture(), xxxSendMessage(), xxxSetForegroundWindow(), xxxSetWindowPos(), xxxShowWindow(), xxxUnlockMenuState(), and xxxValidateRect(). Referenced by InitFunctionTables(), InitializeClientPfnArrays(), and LW_RegisterWindows(). { BOOL fIsRecursedMenu; LRESULT lRet; PAINTSTRUCT ps; PPOPUPMENU ppopupmenu; PMENUSTATE pMenuState; PMENU pmenu; PITEM pItem; TL tlpmenu; TL tlpwndNotify; PDESKTOP pdesk = pwnd->head.rpdesk; POINT ptOrg; HDC hdcAni; CheckLock(pwnd); VALIDATECLASSANDSIZE(pwnd, message, wParam, lParam, FNID_MENU, WM_NCCREATE); /* * If we're not in menu mode or this window is just being created, * there are only few messages we care about. */ pMenuState = GetpMenuState(pwnd); ppopupmenu = ((PMENUWND)pwnd)->ppopupmenu; pmenu = (ppopupmenu != NULL ? ppopupmenu->spmenu : NULL); if ((pMenuState == NULL) || (pmenu == NULL)) { switch (message) { case WM_NCCREATE: case WM_FINALDESTROY: break; case MN_SETHMENU: if (ppopupmenu != NULL) { break; } else { return 0; } default: goto CallDWP; } } else { /* * TPM_RECURSE support: make sure we grab the proper pMenuState. */ fIsRecursedMenu = ((ppopupmenu->ppopupmenuRoot != NULL) && IsRecursedMenuState(pMenuState, ppopupmenu)); if (fIsRecursedMenu) { while (IsRecursedMenuState(pMenuState, ppopupmenu) && (pMenuState->pmnsPrev != NULL)) { pMenuState = pMenuState->pmnsPrev; } UserAssert(pMenuState->pGlobalPopupMenu == ppopupmenu->ppopupmenuRoot); } Validateppopupmenu(ppopupmenu); /* * If this is a modeless menu, give xxxHandleMenuMessages the first * shot at the message */ if (pMenuState->fModelessMenu && !pMenuState->fInCallHandleMenuMessages) { /* * If this is a recursed menu, we don't want to process any * input for it until the current menu goes away. */ if (fIsRecursedMenu) { if (((message >= WM_MOUSEFIRST) && (message <= WM_MOUSELAST)) || ((message >= WM_KEYFIRST) && (message <= WM_KEYLAST)) || ((message >= WM_NCMOUSEFIRST) && (message <= WM_NCMOUSELAST))) { goto CallDWP; } } else { if (xxxCallHandleMenuMessages(pMenuState, pwnd, message, wParam, lParam)) { return 0; } } } } /* else of if ((pMenuState == NULL) || (ppopupmenu == NULL)) */ switch (message) { case WM_NCCREATE: /* * Ignore evil messages to prevent leaks. * Use RIP_ERROR for a while to make sure to see if we're getting here */ if (((PMENUWND)pwnd)->ppopupmenu != NULL) { RIPMSG1(RIP_ERROR, "xxxMenuWindowProc: evil WM_NCCREATE. already initialized. pwnd:%p", pwnd); return FALSE; } ppopupmenu = MNAllocPopup(TRUE); if (ppopupmenu == NULL) { return FALSE; } ((PMENUWND)pwnd)->ppopupmenu = ppopupmenu; ppopupmenu->posSelectedItem = MFMWFP_NOITEM; Lock(&(ppopupmenu->spwndPopupMenu), pwnd); return TRUE; case WM_NCCALCSIZE: xxxDefWindowProc(pwnd, message, wParam, lParam); if (pmenu->dwArrowsOn != MSA_OFF) { InflateRect((PRECT)lParam, 0, -gcyMenuScrollArrow); } break; case WM_ERASEBKGND: if (pmenu->hbrBack != NULL) { MNEraseBackground ((HDC) wParam, pmenu, 0, 0, pwnd->rcClient.right - pwnd->rcClient.left, pwnd->rcClient.bottom - pwnd->rcClient.top); return TRUE; } else { goto CallDWP; } break; case WM_PRINT: /* * default processing of WM_PRINT does not handle custom non- * client painting -- which scrollable menus have -- so take * care of drawing nonclient area and then let DefWindowProc * handle the rest */ if ((lParam & PRF_NONCLIENT) && (pmenu->dwArrowsOn != MSA_OFF)) { MNDrawFullNC(pwnd, (HDC)wParam, ppopupmenu); GreGetWindowOrg((HDC)wParam, &ptOrg); GreSetWindowOrg((HDC)wParam, ptOrg.x - MNXBORDER, ptOrg.y - MNYBORDER - gcyMenuScrollArrow, NULL); xxxDefWindowProc(pwnd, message, wParam, lParam & ~PRF_NONCLIENT); GreSetWindowOrg((HDC)wParam, ptOrg.x, ptOrg.y, NULL); } else { goto CallDWP; } break; case WM_WINDOWPOSCHANGING: if (!(((LPWINDOWPOS)lParam)->flags & SWP_SHOWWINDOW)) goto CallDWP; if (!TestEffectUP(MENUANIMATION) || !(ppopupmenu->iDropDir & PAS_OUT) || (GetAppCompatFlags2(VER40) & GACF2_ANIMATIONOFF)) { NoAnimation: ppopupmenu->iDropDir &= ~PAS_OUT; goto CallDWP; } /* * Create the animation bitmap. */ pMenuState->cxAni = pwnd->rcWindow.right - pwnd->rcWindow.left; pMenuState->cyAni = pwnd->rcWindow.bottom - pwnd->rcWindow.top; if (TestALPHA(MENUFADE)) { if ((hdcAni = CreateFade(pwnd, NULL, CMS_MENUFADE, FADE_SHOW | FADE_MENU)) == NULL) { goto NoAnimation; } } else { if (!MNCreateAnimationBitmap(pMenuState, pMenuState->cxAni, pMenuState->cyAni)) { goto NoAnimation; } /* * We shouldn't be animating at this time. */ UserAssert(pMenuState->hdcWndAni == NULL); /* * This window must be the active popup */ UserAssert(pMenuState->pGlobalPopupMenu->spwndActivePopup == pwnd); /* * Initialize animation info */ pMenuState->hdcWndAni = _GetDCEx(pwnd, HRGN_FULL, DCX_WINDOW | DCX_USESTYLE | DCX_INTERSECTRGN); pMenuState->iAniDropDir = ppopupmenu->iDropDir; pMenuState->ixAni = (pMenuState->iAniDropDir & PAS_HORZ) ? 0 : pMenuState->cxAni; pMenuState->iyAni = (pMenuState->iAniDropDir & PAS_VERT) ? 0 : pMenuState->cyAni; hdcAni = pMenuState->hdcAni; } /* * MFWINDOWDC is used by MNEraseBackground to determine where the * brush org should be set. */ SetMF(pmenu, MFWINDOWDC); xxxSendMessage(pwnd, WM_PRINT, (WPARAM)hdcAni, PRF_CLIENT | PRF_NONCLIENT | PRF_ERASEBKGND); ClearMF(pmenu, MFWINDOWDC); /* *If owner draw, we just passed hdcAni to the client side. * The app might have deleted it (??); no blue screen seems to * happen but only painting on that DC will fail from * now on. I won't waste time handling this unless it turns * out to be a problem (it's unlikely an app would do so). */ UserAssert(GreValidateServerHandle(hdcAni, DC_TYPE)); /* * While the window is still hidden, load the first fade animation * frame to avoid flicker when the window is actually shown. * * There would still be flicker with slide animations, though. It * could be fixed by using the window region, similar to * AnimateWindow. For now, too many functions would become xxx, so * let's not do it, unless it becomes a big issue. */ if (TestFadeFlags(FADE_MENU)) { ShowFade(); } goto CallDWP; case WM_WINDOWPOSCHANGED: if (!(((LPWINDOWPOS)lParam)->flags & SWP_SHOWWINDOW)) goto CallDWP; /* * If not animating, nothing else to do here. */ if (!(ppopupmenu->iDropDir & PAS_OUT)) goto CallDWP; /* * Start the animation cycle now. */ if (TestFadeFlags(FADE_MENU)) { StartFade(); } else { pMenuState->dwAniStartTime = NtGetTickCount(); _SetTimer(pwnd, IDSYS_MNANIMATE, 1, NULL); } ppopupmenu->iDropDir &= ~PAS_OUT; goto CallDWP; case WM_NCPAINT: if (ppopupmenu->iDropDir & PAS_OUT) { /* * When animating, validate itself to ensure no further drawing * that is not related to the animation. */ xxxValidateRect(pwnd, NULL); } else { /* * If we have scroll bars, draw them */ if (pmenu->dwArrowsOn != MSA_OFF) { HDC hdc = _GetDCEx(pwnd, (HRGN)wParam, DCX_USESTYLE | DCX_WINDOW | DCX_INTERSECTRGN | DCX_NODELETERGN | DCX_LOCKWINDOWUPDATE); MNDrawFullNC(pwnd, hdc, ppopupmenu); _ReleaseDC(hdc); } else { goto CallDWP; } } break; case WM_PRINTCLIENT: ThreadLock(pmenu, &tlpmenu); xxxMenuDraw((HDC)wParam, pmenu); ThreadUnlock(&tlpmenu); break; case WM_FINALDESTROY: /* * If we're animating, we must haved been killed in a rude way.... */ UserAssert((pMenuState == NULL) || (pMenuState->hdcWndAni == NULL)); /* * If this is a drag and drop menu, then call RevokeDragDrop. */ if ((pMenuState != NULL) && pMenuState->fDragAndDrop) { if (!SUCCEEDED(xxxClientRevokeDragDrop(HW(pwnd)))) { RIPMSG1(RIP_ERROR, "xxxMenuWindowProc: xxxClientRevokeRegisterDragDrop failed:%#p", pwnd); } } xxxMNDestroyHandler(ppopupmenu); return 0; case WM_PAINT: ThreadLock(pmenu, &tlpmenu); xxxBeginPaint(pwnd, &ps); xxxMenuDraw(ps.hdc, pmenu); xxxEndPaint(pwnd, &ps); ThreadUnlock(&tlpmenu); break; case WM_CHAR: case WM_SYSCHAR: xxxMNChar(ppopupmenu, pMenuState, (UINT)wParam); break; case WM_KEYDOWN: case WM_SYSKEYDOWN: xxxMNKeyDown(ppopupmenu, pMenuState, (UINT)wParam); break; case WM_TIMER: switch (wParam) { case IDSYS_MNSHOW: /* * Open the window and kill the show timer. * * Cancel any toggle state we might have. We don't * want to dismiss this on button up if shown from * button down. */ ppopupmenu->fToggle = FALSE; xxxMNOpenHierarchy(ppopupmenu, pMenuState); break; case IDSYS_MNHIDE: ppopupmenu->fToggle = FALSE; xxxMNCloseHierarchy(ppopupmenu,pMenuState); break; case IDSYS_MNUP: case IDSYS_MNDOWN: if (pMenuState->fButtonDown) { xxxMNDoScroll(ppopupmenu, (UINT)wParam, FALSE); } else { _KillTimer(pwnd, (UINT)wParam); } break; case IDSYS_MNANIMATE: if (pMenuState->hdcWndAni != NULL) { MNAnimate(pMenuState, TRUE); } else { /* * This timer shouldn't be set. Left over in msg queue? */ UserAssert(pMenuState->hdcWndAni != NULL); } break; case IDSYS_MNAUTODISMISS: /* * This is a one shot timer, so kill it. * Dismiss the popup if the flag hasn't been reset. */ _KillTimer(pwnd, IDSYS_MNAUTODISMISS); if (pMenuState->fAboutToAutoDismiss) { goto EndMenu; } } break; /* * Menu messages. */ case MN_SETHMENU: /* * wParam - new hmenu to associate with this menu window * Don't let them set the spmenu to NULL of we have to deal with * that all over. Use RIP_ERROR for a while to make sure this is OK */ if (wParam != 0) { if ((wParam = (WPARAM)ValidateHmenu((HMENU)wParam)) == 0) { break; } LockPopupMenu(ppopupmenu, &(ppopupmenu->spmenu), (PMENU)wParam); } else { RIPMSG1(RIP_ERROR, "xxxMenuWindowProc: MN_SETHMENU ignoring NULL wParam. pwnd:%p", pwnd); } break; case MN_GETHMENU: /* * returns the hmenu associated with this menu window */ return (LRESULT)PtoH(pmenu); case MN_SIZEWINDOW: { /* * Computes the size of the menu associated with this window and resizes * it if needed. Size is returned x in loword, y in highword. wParam * is 0 to just return new size. wParam is non zero if we should also resize * window. * When called by xxxMNUpdateShownMenu, we might need to redraw the * frame (i.e, the scrollbars). So we check for MNSW_DRAWFRAME in wParam. * If some app is sending this message and that bit is set, then we'll * do some extra work, but I think everything should be cool. */ int cx, cy; PMONITOR pMonitor; /* * Call menucomputeHelper directly since this is the entry point for * non toplevel menu bars. */ if (pmenu == NULL) break; ThreadLockAlways(pmenu, &tlpmenu); ThreadLock(ppopupmenu->spwndNotify, &tlpwndNotify); UserAssert(pmenu->spwndNotify == ppopupmenu->spwndNotify); xxxMNCompute(pmenu, ppopupmenu->spwndNotify, 0, 0, 0, 0); ThreadUnlock(&tlpwndNotify); ThreadUnlock(&tlpmenu); pMonitor = _MonitorFromWindow(pwnd, MONITOR_DEFAULTTOPRIMARY); cx = pmenu->cxMenu; cy = MNCheckScroll(pmenu, pMonitor); /* * Size the window? */ if (wParam != 0) { LONG lPos; int x, y; DWORD dwFlags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER; /* * Need to redraw the frame? */ if (wParam & MNSW_DRAWFRAME) { dwFlags |= SWP_DRAWFRAME; } /* * If the window is visible, it's being resized while * shown. So make sure that it still fits on the screen * (i.e, move it to the best pos). */ if (TestWF(pwnd, WFVISIBLE)) { lPos = FindBestPos( pwnd->rcWindow.left, pwnd->rcWindow.top, cx, cy, NULL, 0, ppopupmenu, pMonitor); x = GET_X_LPARAM(lPos); y = GET_Y_LPARAM(lPos); } else { dwFlags |= SWP_NOMOVE; } xxxSetWindowPos( pwnd, PWND_TOP, x, y, cx + 2*SYSMET(CXFIXEDFRAME), /* For shadow */ cy + 2*SYSMET(CYFIXEDFRAME), /* For shadow */ dwFlags); } return MAKELONG(cx, cy); } case MN_OPENHIERARCHY: { PWND pwndT; /* * Opens one level of the hierarchy at the selected item, if * present. Return 0 if error, else hwnd of opened hierarchy. */ pwndT = xxxMNOpenHierarchy(ppopupmenu, pMenuState); return (LRESULT)HW(pwndT); } case MN_CLOSEHIERARCHY: xxxMNCloseHierarchy(ppopupmenu, pMenuState); break; case MN_SELECTITEM: /* * wParam - the item to select. Must be a valid * Returns the item flags of the wParam (0 if failure) */ if ((wParam >= pmenu->cItems) && (wParam < MFMWFP_MINVALID)) { UserAssertMsg1(FALSE, "Bad wParam %x for MN_SELECTITEM", wParam); break; } pItem = xxxMNSelectItem(ppopupmenu, pMenuState, (UINT)wParam); if (pItem != NULL) { return((LONG)(DWORD)(WORD)(pItem->fState | ((pItem->spSubMenu != NULL) ? MF_POPUP : 0))); } break; case MN_SELECTFIRSTVALIDITEM: { UINT item; item = MNFindNextValidItem(pmenu, -1, 1, TRUE); xxxSendMessage(pwnd, MN_SELECTITEM, item, 0L); return (LONG)item; } case MN_CANCELMENUS: /* * Cancels all menus, unselects everything, destroys windows, and cleans * everything up for this hierarchy. wParam is the command to send and * lParam says if it is valid or not. */ xxxMNCancel(pMenuState, (UINT)wParam, (BOOL)LOWORD(lParam), 0); break; case MN_FINDMENUWINDOWFROMPOINT: /* * lParam is point to search for from this hierarchy down. * returns MFMWFP_* value or a pwnd. */ lRet = xxxMNFindWindowFromPoint(ppopupmenu, (PUINT)wParam, MAKEPOINTS(lParam)); /* * Convert return value to a handle. */ if (IsMFMWFPWindow(lRet)) { return (LRESULT)HW((PWND)lRet); } else { return lRet; } case MN_SHOWPOPUPWINDOW: /* * Forces the dropped down popup to be visible and if modeless, also active. */ PlayEventSound(USER_SOUND_MENUPOPUP); xxxShowWindow(pwnd, (pMenuState->fModelessMenu ? SW_SHOW : SW_SHOWNOACTIVATE)); break; case MN_ACTIVATEPOPUP: /* * Activates a popup. This messages is posted in response to WM_ACTIVATEAPP * or WM_ACTIVATE */ UserAssert(pMenuState->fModelessMenu); xxxActivateThisWindow(pwnd, 0, 0); break; case MN_ENDMENU: /* * End the menu. This message is posted to avoid ending the menu * at randmom moments. By posting the message, the request is * queued after any pending/current processing. */ EndMenu: xxxEndMenuLoop(pMenuState, pMenuState->pGlobalPopupMenu); if (pMenuState->fModelessMenu) { UserAssert(!pMenuState->fInCallHandleMenuMessages); xxxMNEndMenuState(TRUE); } return 0; case MN_DODRAGDROP: /* * Let the app know that the user is dragging. */ if (pMenuState->fDragging && (ppopupmenu->spwndNotify != NULL) && IsMFMWFPWindow(pMenuState->uButtonDownHitArea)) { /* * Get the pmenu that contains the item being dragged */ pmenu = (((PMENUWND)pMenuState->uButtonDownHitArea)->ppopupmenu)->spmenu; /* * If this is a modal menu, release the capture lock so * DoDragDrop (if called) can get it. */ if (!pMenuState->fModelessMenu) { UserAssert(PtiCurrent()->pq->QF_flags & QF_CAPTURELOCKED); PtiCurrent()->pq->QF_flags &= ~QF_CAPTURELOCKED; } LockMenuState(pMenuState); ThreadLockAlways(ppopupmenu->spwndNotify, &tlpwndNotify); /* * Give them a chance to call DoDragDrop */ pMenuState->fInDoDragDrop = TRUE; lRet = xxxSendMessage(ppopupmenu->spwndNotify, WM_MENUDRAG, pMenuState->uButtonDownIndex, (LPARAM)PtoH(pmenu)); pMenuState->fInDoDragDrop = FALSE; if (lRet == MND_ENDMENU) { /* * Go away. */ ThreadUnlock(&tlpwndNotify); if (!xxxUnlockMenuState(pMenuState)) { goto EndMenu; } else { return 0; } break; } else { /* * If the user starts dragging, we always * ignore the following button up */ pMenuState->fIgnoreButtonUp = TRUE; } /* * Check the button state since we might have not seen the button up * If so, this will cancel the dragging state */ MNCheckButtonDownState(pMenuState); /* * If this is a modal menu, make sure we recover capture */ if (!pMenuState->fModelessMenu) { xxxMNSetCapture(ppopupmenu); } ThreadUnlock(&tlpwndNotify); xxxUnlockMenuState(pMenuState); } return 0; case MN_BUTTONDOWN: /* * wParam is position (index) of item the button was clicked on. * Must be a valid */ if ((wParam >= pmenu->cItems) && (wParam < MFMWFP_MINVALID)) { UserAssertMsg1(FALSE, "Bad wParam %x for MN_BUTTONDOWN", wParam); break; } xxxMNButtonDown(ppopupmenu, pMenuState, (UINT)wParam, TRUE); break; case MN_MOUSEMOVE: /* * lParam is mouse move coordinate wrt screen. */ xxxMNMouseMove(ppopupmenu, pMenuState, MAKEPOINTS(lParam)); break; case MN_BUTTONUP: /* * wParam is position (index) of item the button was up clicked on. */ if ((wParam >= pmenu->cItems) && (wParam < MFMWFP_MINVALID)) { UserAssertMsg1(FALSE, "Bad wParam %x for MN_BUTTONUP", wParam); break; } xxxMNButtonUp(ppopupmenu, pMenuState, (UINT)wParam, lParam); break; case MN_SETTIMERTOOPENHIERARCHY: /* * Given the current selection, set a timer to show this hierarchy if * valid else return 0. */ return (LONG)(WORD)MNSetTimerToOpenHierarchy(ppopupmenu); case MN_DBLCLK: // // User double-clicked on item. wParamLo is the item. // xxxMNDoubleClick(pMenuState, ppopupmenu, (int)wParam); break; case WM_MOUSELEAVE: UserAssert(pMenuState->fModelessMenu); /* * If we're in DoDragDrop loop, we don't track the mouse * when it goes off the menu window */ pMenuState->fMouseOffMenu = !pMenuState->fInDoDragDrop; ppopupmenu->fTrackMouseEvent = FALSE; /* * See if we need to set the timer to autodismiss */ MNSetTimerToAutoDismiss(pMenuState, pwnd); /* * If we left the active popup, remove the selection */ if (ppopupmenu->spwndPopupMenu == pMenuState->pGlobalPopupMenu->spwndActivePopup) { xxxMNSelectItem(ppopupmenu, pMenuState, MFMWFP_NOITEM); } break; case WM_ACTIVATEAPP: if (pMenuState->fModelessMenu && (pwnd == pMenuState->pGlobalPopupMenu->spwndActivePopup)) { /* * If the application is getting activated, we post a message * to let the dust settle and then re-activate spwndPopupActive */ if (wParam) { _PostMessage(pwnd, MN_ACTIVATEPOPUP, 0, 0); /* * If we're not in the foregruond queue, we want to keep * the frame off. * This flag will also tell us that if we lose activation * while coming to the foregrund (later), we don't want * to dismiss the menu. */ pMenuState->fActiveNoForeground = (gpqForeground != PtiCurrent()->pq); } /* * Make the notification window frame show that we're active/inactive. * If the application is inactive but the user moves the mouse * over the menu, then we can get this message when the first * window in the app gets activated (i.e., the move causes a popup to * be closed/opened). So turn on the frame only if we're in * the foreground. */ if (ppopupmenu->spwndNotify != NULL) { ThreadLockAlways(ppopupmenu->spwndNotify, &tlpwndNotify); xxxDWP_DoNCActivate(ppopupmenu->spwndNotify, ((wParam && !pMenuState->fActiveNoForeground) ? NCA_ACTIVE : NCA_FORCEFRAMEOFF), HRGN_FULL); ThreadUnlock(&tlpwndNotify); } } break; case WM_ACTIVATE: if (pMenuState->fModelessMenu) { /* * If activation is NOT going to a menu window or * it's going to a recursed menu, bail */ if ((LOWORD(wParam) == WA_INACTIVE) && !pMenuState->fInCallHandleMenuMessages && !pMenuState->pGlobalPopupMenu->fInCancel) { lParam = (LPARAM)RevalidateHwnd((HWND)lParam); if ((lParam != 0) && ((GETFNID((PWND)lParam) != FNID_MENU) || IsRecursedMenuState(pMenuState, ((PMENUWND)lParam)->ppopupmenu))) { /* * If we're just coming to the foreground, then * activate the popup later and stay up. */ if (pMenuState->fActiveNoForeground && (gpqForeground == PtiCurrent()->pq)) { pMenuState->fActiveNoForeground = FALSE; _PostMessage(pwnd, MN_ACTIVATEPOPUP, 0, 0); } else { /* * Since the menu window is active, ending the menu * now would set a new active window, messing the * current activation that sent us this message. * so end the menu later. */ _PostMessage(pwnd, MN_ENDMENU, 0, 0); break; } } } goto CallDWP; } /* if (pMenuState->fModelessMenu) */ /* * We must make sure that the menu window does not get activated. * Powerpoint 2.00e activates it deliberately and this causes problems. * We try to activate the previously active window in such a case. * Fix for Bug #13961 --SANKAR-- 09/26/91-- */ /* * In Win32, wParam has other information in the hi 16bits, so to * prevent infinite recursion, we need to mask off those bits * Fix for NT bug #13086 -- 23-Jun-1992 JonPa * */ if (LOWORD(wParam)) { TL tlpwnd; /* * This is a super bogus hack. Let's start failing this for 5.0 apps. */ if (Is500Compat(PtiCurrent()->dwExpWinVer)) { RIPMSG1(RIP_ERROR, "xxxMenuWindowProc: Menu window activated:%#p", pwnd); _PostMessage(pwnd, MN_ENDMENU, 0, 0); break; } #if 0 /* * Activate the previously active wnd */ xxxActivateWindow(pwnd, AW_SKIP2); #else /* * Try the previously active window. */ if ((gpqForegroundPrev != NULL) && !FBadWindow(gpqForegroundPrev->spwndActivePrev) && !ISAMENU(gpqForegroundPrev->spwndActivePrev)) { pwnd = gpqForegroundPrev->spwndActivePrev; } else { /* * Find a new active window from the top-level window list. * Bug 78131: Make sure we don't loop for ever. This is a pretty * unusual scenario (in addtion, normally we should not hit this code path) * So let's use a counter to rule out the possibility that another * weird window configuration is going to make us loop for ever */ PWND pwndMenu = pwnd; UINT uCounter = 0; do { pwnd = NextTopWindow(PtiCurrent(), pwnd, NULL, 0); if (pwnd && !FBadWindow(pwnd->spwndLastActive) && !ISAMENU(pwnd->spwndLastActive)) { pwnd = pwnd->spwndLastActive; uCounter = 0; break; } } while ((pwnd != NULL) && (uCounter++ < 255)); /* * If we couldn't find a window, just bail. */ if (uCounter != 0) { RIPMSG0(RIP_ERROR, "xxxMenuWindowProc: couldn't fix active window"); _PostMessage(pwndMenu, MN_ENDMENU, 0, 0); break; } } if (pwnd != NULL) { PTHREADINFO pti = PtiCurrent(); ThreadLockAlwaysWithPti(pti, pwnd, &tlpwnd); /* * If GETPTI(pwnd) isn't pqCurrent this is a AW_SKIP* activation * we'll want to a do a xxxSetForegroundWindow(). */ if (GETPTI(pwnd)->pq != pti->pq) { /* * Only allow this if we're on the current foreground queue. */ if (gpqForeground == pti->pq) { xxxSetForegroundWindow(pwnd, FALSE); } } else { xxxActivateThisWindow(pwnd, 0, ATW_SETFOCUS); } ThreadUnlock(&tlpwnd); } #endif } break; case WM_SIZE: case WM_MOVE: /* * When a popup has been sized/moved, we need to make * sure any dropped hierarchy is moved accordingly. */ if (ppopupmenu->spwndNextPopup != NULL) { pItem = MNGetpItem(ppopupmenu, ppopupmenu->posDropped); if (pItem != NULL) { int x, y; PMONITOR pMonitorDummy; /* * If the dropped hierarchy needs to be recomputed, do it */ #define pmenuNext (((PMENUWND)ppopupmenu->spwndNextPopup)->ppopupmenu->spmenu) if (pmenuNext->cxMenu == 0) { xxxSendMessage(ppopupmenu->spwndNextPopup, MN_SIZEWINDOW, MNSW_RETURNSIZE, 0L); } /* * Find out the new position */ xxxMNPositionHierarchy(ppopupmenu, pItem, pmenuNext->cxMenu + (2 * SYSMET(CXFIXEDFRAME)), pmenuNext->cyMenu + (2 * SYSMET(CXFIXEDFRAME)), &x, &y, &pMonitorDummy); /* * Move it */ ThreadLockAlways(ppopupmenu->spwndNextPopup, &tlpwndNotify); xxxSetWindowPos(ppopupmenu->spwndNextPopup, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOSENDCHANGING); ThreadUnlock(&tlpwndNotify); #undef pmenuNext } /* if (pItem != NULL) */ } /* if (ppopupmenu->spwndNextPopup != NULL) */ break; case WM_NCHITTEST: /* * Since modeless menus don't capture the mouse, we * process this message to make sure that we always receive * a mouse move when the mouse in our window. * This also causes us to receive the WM_MOUSELEAVE only when * the mouse leaves the window and not just the client area. */ if (pMenuState->fModelessMenu) { ptOrg.x = GET_X_LPARAM(lParam); ptOrg.y = GET_Y_LPARAM(lParam); if (PtInRect(&pwnd->rcWindow, ptOrg)) { return HTCLIENT; } else { return HTNOWHERE; } } else { goto CallDWP; } default: CallDWP: return xxxDefWindowProc(pwnd, message, wParam, lParam); } return 0; }

void xxxMNButtonDown (  PPOPUPMENU  ppopupmenu, PMENUSTATE  pMenuState, UINT  posItemHit, BOOL  fClick )

Definition at line 3533 of file ntuser/kernel/menu.c. References BOOL, FALSE, tagMENUSTATE::fButtonDown, tagPOPUPMENU::fDropNextPopup, tagPOPUPMENU::fToggle, MNIsPopupItem(), tagPOPUPMENU::posSelectedItem, TRUE, xxxMNDoScroll(), xxxMNHideNextHierarchy(), xxxMNOpenHierarchy(), and xxxMNSelectItem(). Referenced by xxxHandleMenuMessages(), xxxMenuWindowProc(), and xxxMNMouseMove(). { PITEM pItem; BOOL fOpenHierarchy; /* * A different item was hit than is currently selected, so select it * and drop its menu if available. Make sure we toggle click state. */ if (ppopupmenu->posSelectedItem != posItemHit) { /* * We are clicking on a new item, not moving the mouse over to it. * So reset cancel toggle state. We don't want button up from * this button down to cancel. */ if (fClick) { fOpenHierarchy = TRUE; ppopupmenu->fToggle = FALSE; } else { fOpenHierarchy = (ppopupmenu->fDropNextPopup != 0); } /* * If the item has a popup and isn't disabled, open it. Note that * selecting this item will cancel any hierarchies associated with * the previously selected item. */ pItem = xxxMNSelectItem(ppopupmenu, pMenuState, posItemHit); if (MNIsPopupItem(pItem) && fOpenHierarchy) { /* Punt if menu was destroyed. */ if (xxxMNOpenHierarchy(ppopupmenu, pMenuState) == (PWND)-1) { return; } } } else { /* * We are moving over to the already-selected item. If we are * clicking for real, reset cancel toggle state. We want button * up to cancel if on same item. Otherwise, do nothing if just * moving... */ if (fClick) { ppopupmenu->fToggle = TRUE; } if (!xxxMNHideNextHierarchy(ppopupmenu) && fClick && xxxMNOpenHierarchy(ppopupmenu, pMenuState)) ppopupmenu->fToggle = FALSE; } if (fClick) { pMenuState->fButtonDown = TRUE; xxxMNDoScroll(ppopupmenu, posItemHit, TRUE); } }

void xxxMNButtonUp (  PPOPUPMENU  ppopup, PMENUSTATE  pMenuState, UINT  posItemHit, LPARAM  lParam )

Definition at line 3772 of file ntuser/kernel/menu.c. References tagMENU::cItems, FALSE, tagMENUSTATE::fButtonAlwaysDown, tagMENUSTATE::fButtonDown, tagPOPUPMENU::fHierarchyDropped, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fShowTimer, tagITEM::fState, tagPOPUPMENU::fToggle, tagITEM::fType, MFMWFP_NOITEM, NULL, tagPOPUPMENU::posSelectedItem, tagMENU::rgItems, tagPOPUPMENU::spmenu, tagITEM::spSubMenu, xxxMNDismiss(), xxxMNDismissWithNotify(), and xxxMNOpenHierarchy(). Referenced by xxxHandleMenuMessages(), and xxxMenuWindowProc(). { PITEM pItem; if (!pMenuState->fButtonDown) { /* * Ignore if button was never down... Really shouldn't happen... */ return; } if (posItemHit == MFMWFP_NOITEM) { RIPMSG0(RIP_WARNING, "button up on no item"); goto ExitButtonUp; } if (ppopup->posSelectedItem != posItemHit) { goto ExitButtonUp; } if (ppopup->fIsMenuBar) { /* * Handle button up in menubar specially. */ if (ppopup->fHierarchyDropped) { if (!ppopup->fToggle) { goto ExitButtonUp; } else { /* * Cancel menu now. */ ppopup->fToggle = FALSE; xxxMNDismiss(pMenuState); return; } } } else if (ppopup->fShowTimer) { ppopup->fToggle = FALSE; /* * Open hierarchy on popup */ xxxMNOpenHierarchy(ppopup, pMenuState); goto ExitButtonUp; } /* * If nothing is selected, get out. This occurs mainly on unbalanced * multicolumn menus where one of the columns isn't completely full. */ if (ppopup->posSelectedItem == MFMWFP_NOITEM) goto ExitButtonUp; if (ppopup->posSelectedItem >= ppopup->spmenu->cItems) goto ExitButtonUp; /* * Get a pointer to the currently selected item in this menu. */ pItem = &(ppopup->spmenu->rgItems[ppopup->posSelectedItem]); /* * Kick out of menu mode if user clicked on a non-separator, enabled, * non-hierarchical item. * * BOGUS * Why doesn't MFS_GRAYED check work for separators now? Find out later. */ if (!(pItem->fType & MFT_SEPARATOR) && !(pItem->fState & MFS_GRAYED) && (pItem->spSubMenu == NULL)) { xxxMNDismissWithNotify(pMenuState, ppopup->spmenu, pItem, ppopup->posSelectedItem, lParam); return; } ExitButtonUp: pMenuState->fButtonDown = pMenuState->fButtonAlwaysDown = FALSE; }

void xxxMNCancel (  PMENUSTATE  pMenuState, UINT  uMsg, UINT  cmd, LPARAM  lParam )

Definition at line 3395 of file ntuser/kernel/menu.c. References _PostMessage(), BOOL, tagMENUSTATE::cmdLast, FALSE, tagMENUSTATE::fButtonDown, tagPOPUPMENU::fDestroyed, tagPOPUPMENU::fInCancel, tagMENUSTATE::fInsideMenuLoop, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fIsSysMenu, tagPOPUPMENU::fIsTrackPopup, tagMENUSTATE::fMenuStarted, tagPOPUPMENU::fNoNotify, tagPOPUPMENU::fSynchronous, FWINABLE, tagWND::head, MFMWFP_NOITEM, NULL, tagMENUSTATE::pGlobalPopupMenu, PlayEventSound(), PtiCurrent, tagMENUSTATE::ptiMenuStateOwner, SMS_NOMENU, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, TestWF, ThreadLock, ThreadUnlock, TRUE, USER_SOUND_MENUCOMMAND, Validateppopupmenu, WFWIN31COMPAT, xxxDestroyWindow(), xxxMNCloseHierarchy(), xxxMNReleaseCapture(), xxxMNSelectItem(), xxxSendMenuSelect(), xxxSendMessage(), and xxxWindowEvent(). Referenced by xxxMenuWindowProc(), xxxMNDismiss(), and xxxMNDismissWithNotify(). { PPOPUPMENU ppopupmenu = pMenuState->pGlobalPopupMenu; BOOL fSynchronous = ppopupmenu->fSynchronous; BOOL fTrackFlagsSet = ppopupmenu->fIsTrackPopup; BOOL fIsSysMenu = ppopupmenu->fIsSysMenu; BOOL fIsMenuBar = ppopupmenu->fIsMenuBar; BOOL fNotify = !ppopupmenu->fNoNotify; PWND pwndT; TL tlpwndT; TL tlpwndPopupMenu; Validateppopupmenu(ppopupmenu); pMenuState->fInsideMenuLoop = FALSE; pMenuState->fButtonDown = FALSE; /* * Mark the popup as destroyed so people will not use it anymore. * This means that root popups can be marked as destroyed before * actually being destroyed (nice and confusing). */ ppopupmenu->fDestroyed = TRUE; /* * Only the menu loop owner can destroy the menu windows (i.e, xxxMNCloseHierarchy) */ if (PtiCurrent() != pMenuState->ptiMenuStateOwner) { RIPMSG1(RIP_WARNING, "xxxMNCancel: Thread %#p doesn't own the menu loop", PtiCurrent()); return; } /* * If the menu loop is running on a thread different than the thread * that owns spwndNotify, we can have two threads trying to cancel * this popup at the same time. */ if (ppopupmenu->fInCancel) { RIPMSG1(RIP_WARNING, "xxxMNCancel: already in cancel. ppopupmenu:%#p", ppopupmenu); return; } ppopupmenu->fInCancel = TRUE; ThreadLock(ppopupmenu->spwndPopupMenu, &tlpwndPopupMenu); /* * Close all hierarchies from this point down. */ xxxMNCloseHierarchy(ppopupmenu, pMenuState); /* * Unselect any items on this top level window */ xxxMNSelectItem(ppopupmenu, pMenuState, MFMWFP_NOITEM); pMenuState->fMenuStarted = FALSE; pwndT = ppopupmenu->spwndNotify; ThreadLock(pwndT, &tlpwndT); xxxMNReleaseCapture(); if (fTrackFlagsSet) { /* * Send a POPUPEND so people watching see them paired */ if (FWINABLE()) { xxxWindowEvent(EVENT_SYSTEM_MENUPOPUPEND, ppopupmenu->spwndPopupMenu, OBJID_CLIENT, 0, 0); } UserAssert(ppopupmenu->spwndPopupMenu != ppopupmenu->spwndPopupMenu->head.rpdesk->spwndMenu); xxxDestroyWindow(ppopupmenu->spwndPopupMenu); } if (pwndT == NULL) { ThreadUnlock(&tlpwndT); ThreadUnlock(&tlpwndPopupMenu); return; } /* * SMS_NOMENU hack so we can send MenuSelect messages with * (loword(lparam) = -1) when * the menu pops back up for the CBT people. In 3.0, all WM_MENUSELECT * messages went through the message filter so go through the function * SendMenuSelect. We need to do this in 3.1 since WordDefect for Windows * depends on this. */ xxxSendMenuSelect(pwndT, NULL, SMS_NOMENU, MFMWFP_NOITEM); if (FWINABLE()) { xxxWindowEvent(EVENT_SYSTEM_MENUEND, pwndT, (fIsSysMenu ? OBJID_SYSMENU : (fIsMenuBar ? OBJID_MENU : OBJID_WINDOW)), INDEXID_CONTAINER, 0); } if (fNotify) { /* * Notify app we are exiting the menu loop. Mainly for WinOldApp 386. * wParam is 1 if a TrackPopupMenu else 0. */ xxxSendMessage(pwndT, WM_EXITMENULOOP, ((fTrackFlagsSet && !fIsSysMenu)? 1 : 0), 0); } if (uMsg != 0) { PlayEventSound(USER_SOUND_MENUCOMMAND); pMenuState->cmdLast = cmd; if (!fSynchronous) { if (!fIsSysMenu && fTrackFlagsSet && !TestWF(pwndT, WFWIN31COMPAT)) { xxxSendMessage(pwndT, uMsg, cmd, lParam); } else { _PostMessage(pwndT, uMsg, cmd, lParam); } } } else pMenuState->cmdLast = 0; ThreadUnlock(&tlpwndT); ThreadUnlock(&tlpwndPopupMenu); }

void xxxMNChar (  PPOPUPMENU  ppopupmenu, PMENUSTATE  pMenuState, UINT  character )

Definition at line 1011 of file ntuser/kernel/menu.c. References BOOL, tagMENU::cItems, FALSE, tagPOPUPMENU::fDestroyed, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fIsSysMenu, tagITEM::fState, INT, MFMWFP_NOITEM, NULL, tagPOPUPMENU::posSelectedItem, PtoH, tagMENU::rgItems, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagPOPUPMENU::spwndNotify, ThreadLock, ThreadUnlock, TRUE, UINT, Validateppopupmenu, xxxMessageBeep(), xxxMNDismiss(), xxxMNFindChar(), xxxMNKeyDown(), xxxMNSelectItem(), xxxMNSwitchToAlternateMenu(), and xxxSendMessage(). Referenced by xxxHandleMenuMessages(), xxxMenuWindowProc(), and xxxMNKeyFilter(). { PMENU pMenu; UINT flags; LRESULT result; int item; INT matchType; BOOL fExecute = FALSE; TL tlpwndNotify; pMenu = ppopupmenu->spmenu; Validateppopupmenu(ppopupmenu); /* * If this comes in with a NULL pMenu, then we could have problems. * This could happen if the xxxMNStartMenuState never gets called * because the fInsideMenuLoop is set. * * This is placed in here temporarily until we can discover why * this pMenu isn't set. We will prevent the system from crashing * in the meantime. * * HACK: ChrisWil */ if (pMenu == NULL) { UserAssert(pMenu); xxxMNDismiss(pMenuState); return; } /* * If we're getting out of menu mode, bail */ if (ppopupmenu->fDestroyed) { return; } item = xxxMNFindChar(pMenu, character, ppopupmenu->posSelectedItem, &matchType); if (item != MFMWFP_NOITEM) { int item1; int firstItem = item; /* * Find first ENABLED menu item with the given mnemonic 'character' * !!! If none found, exit menu loop !!! */ while (pMenu->rgItems[item].fState & MFS_GRAYED) { item = xxxMNFindChar(pMenu, character, item, &matchType); if (item == firstItem) { xxxMNDismiss(pMenuState); return; } } item1 = item; /* * Find next ENABLED menu item with the given mnemonic 'character' * This is to see if we have a DUPLICATE MNEMONIC situation */ do { item = xxxMNFindChar(pMenu, character, item, &matchType); } while ((pMenu->rgItems[item].fState & MFS_GRAYED) && (item != firstItem)); if ((firstItem == item) || (item == item1)) fExecute = TRUE; item = item1; } if ((item == MFMWFP_NOITEM) && ppopupmenu->fIsMenuBar && (character == TEXT(' '))) { /* * Handle the case of the user cruising through the top level menu bar * without any popups dropped. We need to handle switching to and from * the system menu. */ if (ppopupmenu->fIsSysMenu) { /* * If we are on the system menu and user hits space, bring * down thesystem menu. */ item = 0; fExecute = TRUE; } else if (ppopupmenu->spmenuAlternate != NULL) { /* * We are not currently on the system menu but one exists. So * switch to it and bring it down. */ item = 0; goto SwitchToAlternate; } } if ((item == MFMWFP_NOITEM) && ppopupmenu->fIsMenuBar && ppopupmenu->spmenuAlternate) { /* * No matching item found on this top level menu (could be either the * system menu or the menu bar). We need to check the other menu. */ item = xxxMNFindChar(ppopupmenu->spmenuAlternate, character, 0, &matchType); if (item != MFMWFP_NOITEM) { SwitchToAlternate: if (xxxMNSwitchToAlternateMenu(ppopupmenu)) { xxxMNChar(ppopupmenu, pMenuState, character); } return; } } if (item == MFMWFP_NOITEM) { flags = (ppopupmenu->fIsSysMenu) ? MF_SYSMENU : 0; if (!ppopupmenu->fIsMenuBar) { flags |= MF_POPUP; } ThreadLock(ppopupmenu->spwndNotify, &tlpwndNotify); result = xxxSendMessage(ppopupmenu->spwndNotify, WM_MENUCHAR, MAKELONG((WORD)character, (WORD)flags), (LPARAM)PtoH(ppopupmenu->spmenu)); ThreadUnlock(&tlpwndNotify); switch (HIWORD(result)) { case MNC_IGNORE: xxxMessageBeep(0); /* * If we're on the menu bar, cancel menu mode (fall through). * We do this because you can really freak out an end user * who accidentally tapped the Alt key (causing us to go * into "invisible" menu mode) and now can't type anything! */ if (flags & MF_POPUP) { return; } /* * Fall through. */ case MNC_CLOSE: xxxMNDismiss(pMenuState); return; case MNC_EXECUTE: fExecute = TRUE; /* fall thru */ case MNC_SELECT: item = (UINT)(short)LOWORD(result); if ((WORD) item >= ppopupmenu->spmenu->cItems) { RIPMSG1(RIP_WARNING, "Invalid item number returned from WM_MENUCHAR %#lx", result); return; } break; } } if (item != MFMWFP_NOITEM) { xxxMNSelectItem(ppopupmenu, pMenuState, item); if (fExecute) xxxMNKeyDown(ppopupmenu, pMenuState, VK_RETURN); } }

void xxxMNCloseHierarchy (  PPOPUPMENU  ppopupmenu, PMENUSTATE  pMenuState )

Definition at line 2517 of file ntuser/kernel/menu.c. References _KillTimer(), DF_MENUINUSE, tagDESKTOP::dwDTFlags, FALSE, tagPOPUPMENU::fDesktopMenu, tagMENUSTATE::fDragAndDrop, tagPOPUPMENU::fHideTimer, tagPOPUPMENU::fHierarchyDropped, tagMENUSTATE::fInsideMenuLoop, tagPOPUPMENU::fIsMenuBar, tagMENUSTATE::fModelessMenu, FWINABLE, tagWND::head, HW, IDSYS_MNHIDE, L, Lock, MFMWFP_NOITEM, MNAnimate(), NT_SUCCESS, NULL, tagTHREADINFO::pMenuState, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::ppopupmenuRoot, PtiCurrent, PUDF_ANIMATE, tagTHREADINFO::rpdesk, SetVisible(), tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndActivePopup, tagDESKTOP::spwndMenu, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, SV_UNSET, TEST_PUDF, TestWF, ThreadLockAlways, ThreadUnlock, TRUE, Unlock, Validateppopupmenu, WFVISIBLE, xxxActivateThisWindow(), xxxCleanupDesktopMenu(), xxxClientRevokeDragDrop(), xxxDestroyWindow(), xxxMNDestroyHandler(), xxxSendMenuSelect(), xxxSendMessage(), xxxShowWindow(), and xxxWindowEvent(). Referenced by xxxDestroyThreadInfo(), xxxEndMenu(), xxxMenuWindowProc(), xxxMNCancel(), xxxMNKeyDown(), xxxMNKeyFilter(), xxxMNOpenHierarchy(), and xxxMNSelectItem(). { TL tlpwndNext; TL tlpwnd; TL tlpopup; PTHREADINFO ptiCurrent = PtiCurrent(); PDESKTOP pdesk; PWND pwndNext; Validateppopupmenu(ppopupmenu); /* * Terminate any animation */ MNAnimate(pMenuState, FALSE); /* * If a hierarchy exists, close all childen below us. Do it in reversed * order so savebits work out. */ if (!ppopupmenu->fHierarchyDropped) { /* * Assert that there's no next or it might not get closed */ UserAssert(ppopupmenu->spwndNextPopup == NULL); return; } if (ppopupmenu->fHideTimer) { _KillTimer(ppopupmenu->spwndPopupMenu, IDSYS_MNHIDE); ppopupmenu->fHideTimer = FALSE; } pwndNext = ppopupmenu->spwndNextPopup; if (pwndNext != NULL) { ThreadLockAlways(pwndNext, &tlpwndNext); xxxSendMessage(pwndNext, MN_CLOSEHIERARCHY, 0, 0); /* * If modeless menu, activate the this popup since we're about * to destroy the current active one. We want to keep activation * on a menu window so we can get the keys. Also, modeless menus * are canceled when a non-menu window is activated in their queue */ if (pMenuState->fModelessMenu && pMenuState->fInsideMenuLoop && !ppopupmenu->fIsMenuBar) { ThreadLockAlways(ppopupmenu->spwndPopupMenu, &tlpwnd); xxxActivateThisWindow(ppopupmenu->spwndPopupMenu, 0, 0); ThreadUnlock(&tlpwnd); } if (FWINABLE()) { xxxWindowEvent(EVENT_SYSTEM_MENUPOPUPEND, pwndNext, OBJID_CLIENT, INDEXID_CONTAINER, 0); } /* * If the current thread is not in the right pdesk, then that could * be the cause of the stuck menu bug. * In other words, are we nuking this menu out of context? */ UserAssert(ptiCurrent->pMenuState != NULL); pdesk = ptiCurrent->rpdesk; if (pwndNext == pdesk->spwndMenu) { PPOPUPMENU ppopupmenuReal; UserAssert(pdesk->dwDTFlags & DF_MENUINUSE); /* * If this is our precreated real popup window, * initialize ourselves and just hide. */ xxxShowWindow(pwndNext, SW_HIDE | TEST_PUDF(PUDF_ANIMATE)); /* * Its possible that during Logoff the above xxxShowWindow * won't get prossessed and because this window is a special * window that is owned by they desktop we have to manually mark * it as invisible. */ if (TestWF(pwndNext, WFVISIBLE)) { SetVisible(pwndNext, SV_UNSET); } #ifdef HAVE_MN_GETPPOPUPMENU ppopupmenuReal = (PPOPUPMENU)xxxSendMessage(pwndNext, MN_GETPPOPUPMENU,0, 0L); #else ppopupmenuReal = ((PMENUWND)pwndNext)->ppopupmenu; #endif UserAssert(ppopupmenuReal->fDesktopMenu == TRUE); /* * We don't want this window to be a drop target anymore. * Non cached menu windows revoke it on WM_FINALDESTROY. */ if (pMenuState->fDragAndDrop) { if (!NT_SUCCESS(xxxClientRevokeDragDrop(HW(pwndNext)))) { RIPMSG1(RIP_ERROR, "xxxMNCloseHierarchy: xxxClientRevokeRegisterDragDrop failed:%#p", pwndNext); } } if (ppopupmenuReal != NULL) { xxxMNDestroyHandler(ppopupmenuReal); /* * We used to clear the popup contents here but the popup might be * still in use if this is happening during a callback. So we let * MNFreePopup do that. If it didn't happen during the call above, * it'll happen when MNFlushDestroyedPopups is executed. */ } xxxCleanupDesktopMenu(pwndNext, pdesk); ThreadUnlock(&tlpwndNext); } else if (ThreadUnlock(&tlpwndNext)) { /* * We know this is not the current thread's desktop menu window. * Let's assert that it's not the menu window of another desktop. */ UserAssert(pwndNext != pwndNext->head.rpdesk->spwndMenu); xxxDestroyWindow(pwndNext); } Unlock(&ppopupmenu->spwndNextPopup); ppopupmenu->fHierarchyDropped = FALSE; } if (ppopupmenu->fIsMenuBar) { Unlock(&ppopupmenu->spwndActivePopup); } else { Lock(&(ppopupmenu->ppopupmenuRoot->spwndActivePopup), ppopupmenu->spwndPopupMenu); } if (pMenuState->fInsideMenuLoop && (ppopupmenu->posSelectedItem != MFMWFP_NOITEM)) { /* * Send a menu select as if this item had just been selected. This * allows people to easily update their menu status bars when a * hierarchy from this item has been closed. */ PWND pwnd = ppopupmenu->ppopupmenuRoot->spwndNotify; if (pwnd) { ThreadLockAlways(pwnd, &tlpwnd); ThreadLockAlways(ppopupmenu->spwndPopupMenu, &tlpopup); xxxSendMenuSelect(pwnd, ppopupmenu->spwndPopupMenu, ppopupmenu->spmenu, ppopupmenu->posSelectedItem); ThreadUnlock(&tlpopup); ThreadUnlock(&tlpwnd); } } }

void xxxMNDestroyHandler (  PPOPUPMENU  ppopupmenu  )

Definition at line 880 of file ntuser/kernel/menu.c. References _KillTimer(), BOOL, tagMENU::cItems, FALSE, tagPOPUPMENU::fDelayedFree, tagPOPUPMENU::fDesktopMenu, tagPOPUPMENU::fDestroyed, tagPOPUPMENU::fFlushDelayedFree, tagPOPUPMENU::fHideTimer, tagPOPUPMENU::fIsSysMenu, tagPOPUPMENU::fSendUninit, tagPOPUPMENU::fShowTimer, tagITEM::fState, IDSYS_MNHIDE, IDSYS_MNSHOW, IsRootPopupMenu(), MNFreePopup(), MNIsItemSelected(), NULL, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::ppmDelayedFree, tagPOPUPMENU::ppopupmenuRoot, PtoH, tagMENU::rgItems, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, ThreadLockAlways, ThreadUnlock, TRUE, Validateppopupmenu, and xxxSendMessage(). Referenced by xxxMenuWindowProc(), xxxMNCloseHierarchy(), and xxxMNOpenHierarchy(). { PITEM pItem; TL tlpwndT; if (ppopupmenu == NULL) { /* * This can happen if WM_NCCREATE failed to allocate the ppopupmenu * in xxxMenuWindowProc. */ RIPMSG0(RIP_WARNING, "xxxMNDestroyHandler: NULL \"ppopupmenu\""); return; } #if DBG /* * When destroying a desktop's spwndMenu that is not in use (i.e., the * desktop is going away), the ppopupmenu is not exactly valid (i.e., * we're not in menu mode) but it should be properly NULLed out so * everything should go smoothly */ Validateppopupmenu(ppopupmenu); #endif if (ppopupmenu->spwndNextPopup != NULL) { /* * We used to send the message to spwndNextPopup here. The message should * go to the current popup so it'll close spwndNextPopup (not to the next * to close its next, if any). * I don't see how the current spwndPopupMenu can be NULL but we better * handle it since we never accessed it before. This menu code is tricky... */ PWND pwnd; UserAssert(ppopupmenu->spwndPopupMenu != NULL); pwnd = (ppopupmenu->spwndPopupMenu != NULL ? ppopupmenu->spwndPopupMenu : ppopupmenu->spwndNextPopup); ThreadLockAlways(pwnd, &tlpwndT); xxxSendMessage(pwnd, MN_CLOSEHIERARCHY, 0, 0); ThreadUnlock(&tlpwndT); } if ((ppopupmenu->spmenu!=NULL) && MNIsItemSelected(ppopupmenu)) { /* * Unset the hilite bit on the hilited item. */ if (ppopupmenu->posSelectedItem < ppopupmenu->spmenu->cItems) { /* * this extra check saves Ambiente 1.02 -- they have a menu with * one item in it. When that command is chosen, the app proceeds * to remove that one item -- leaving us in the oh so strange state * of having a valid hMenu with a NULL rgItems. */ pItem = &(ppopupmenu->spmenu->rgItems[ppopupmenu->posSelectedItem]); pItem->fState &= ~MFS_HILITE; } } if (ppopupmenu->fShowTimer) { _KillTimer(ppopupmenu->spwndPopupMenu, IDSYS_MNSHOW); } if (ppopupmenu->fHideTimer) { _KillTimer(ppopupmenu->spwndPopupMenu, IDSYS_MNHIDE); } /* * Send WM_UNINITMENUPOPUP so the menu owner can clean up. */ if (ppopupmenu->fSendUninit && (ppopupmenu->spwndNotify != NULL)) { ThreadLockAlways(ppopupmenu->spwndNotify, &tlpwndT); xxxSendMessage(ppopupmenu->spwndNotify, WM_UNINITMENUPOPUP, (WPARAM)PtoH(ppopupmenu->spmenu), MAKELONG(0, (ppopupmenu->fIsSysMenu ? MF_SYSMENU: 0))); ThreadUnlock(&tlpwndT); } ppopupmenu->fDestroyed = TRUE; if (!ppopupmenu->fDesktopMenu) { if (ppopupmenu->spwndPopupMenu != NULL) { ((PMENUWND)(ppopupmenu->spwndPopupMenu))->ppopupmenu = NULL; } } if (!ppopupmenu->fDelayedFree) { MNFreePopup(ppopupmenu); } else if (ppopupmenu->ppopupmenuRoot != NULL) { ppopupmenu->ppopupmenuRoot->fFlushDelayedFree = TRUE; #if DBG { /* * If this is not the rootpopup, * assert that this popup is linked in the delayed free list */ if (!IsRootPopupMenu(ppopupmenu)) { BOOL fFound = FALSE; PPOPUPMENU ppm = ppopupmenu->ppopupmenuRoot; while (ppm->ppmDelayedFree != NULL) { if (ppm->ppmDelayedFree == ppopupmenu) { fFound = TRUE; break; } ppm = ppm->ppmDelayedFree; } UserAssert(fFound); } } #endif } else { UserAssertMsg1(FALSE, "Leaking ppopupmenu:%p?", ppopupmenu); } }

void xxxMNDismiss (  PMENUSTATE  pMenuState  )

Definition at line 36 of file ntuser/kernel/menu.c. References xxxMNCancel(). Referenced by xxxEndMenu(), xxxEndMenuLoop(), xxxHandleMenuMessages(), xxxMNButtonUp(), xxxMNChar(), xxxMNKeyDown(), and xxxMNKeyFilter(). { xxxMNCancel(pMenuState, 0, 0, 0); }

void xxxMNDismissWithNotify (  PMENUSTATE  pMenuState, PMENU  pmenu, PITEM  pitem, UINT  uPos, LPARAM  lParam )

Definition at line 98 of file ntuser/kernel/menu.c. References tagPOPUPMENU::fIsSysMenu, tagMENUSTATE::fNotifyByPos, MNFadeSelection(), tagMENUSTATE::pGlobalPopupMenu, PtoHq, StartFade(), UINT, tagITEM::wID, and xxxMNCancel(). Referenced by xxxMNButtonUp(), xxxMNDoubleClick(), and xxxMNKeyDown(). { UINT uMsg; UINT uCmd; if (pMenuState->pGlobalPopupMenu->fIsSysMenu) { uMsg = WM_SYSCOMMAND; uCmd = pitem->wID; /* lParam set by caller */ } else if (pMenuState->fNotifyByPos) { uMsg = WM_MENUCOMMAND; uCmd = uPos; lParam = (LPARAM)PtoHq(pmenu); } else { uMsg = WM_COMMAND; uCmd = pitem->wID; lParam = 0; } /* * The menu is about to go away, see if we want to fade out the selection. */ if (MNFadeSelection(pmenu, pitem)) { StartFade(); } /* * Dismiss the menu. */ xxxMNCancel(pMenuState, uMsg, uCmd, lParam); }

BOOL xxxMNDoScroll (  PPOPUPMENU  ppopup, UINT  uArrow, BOOL  fSetTimer )

Definition at line 591 of file ntuser/kernel/menu.c. References _KillTimer(), _SetTimer(), BOOL, FALSE, gpsi, tagMENU::iTop, MFMWFP_DOWNARROW, MFMWFP_UPARROW, NULL, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndPopupMenu, TRUE, and xxxMNSetTop(). Referenced by xxxMenuWindowProc(), xxxMNButtonDown(), xxxMNDoubleClick(), and xxxMNSelectItem(). { int iScrollTop = ppopup->spmenu->iTop; if (uArrow == MFMWFP_UPARROW) { iScrollTop--; } else if (uArrow == MFMWFP_DOWNARROW) { iScrollTop++; } else { return FALSE; } if (!xxxMNSetTop(ppopup, iScrollTop)) { if (!fSetTimer) { _KillTimer(ppopup->spwndPopupMenu, uArrow); } } else { /* * Set this timer just like we do in the scrollbar code: * the first time we wait a little longer. */ _SetTimer(ppopup->spwndPopupMenu, uArrow, (fSetTimer ? gpsi->dtScroll : gpsi->dtScroll / 4), NULL); } return TRUE; }

BOOL xxxMNDoubleClick (  PMENUSTATE  pMenuState, PPOPUPMENU  ppopup, int  idxItem )

Definition at line 2697 of file ntuser/kernel/menu.c. References _GetMenuDefaultItem(), BOOL, tagMENU::cItems, FALSE, tagITEM::fState, msg, NULL, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::ppopupmenuRoot, tagMENU::rgItems, tagPOPUPMENU::spmenu, tagITEM::spSubMenu, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, TestWF, ThreadLock, ThreadUnlock, TRUE, UINT, WFWIN40COMPAT, xxxMNDismissWithNotify(), xxxMNDoScroll(), xxxPeekMessage, and xxxSendMenuSelect(). Referenced by xxxHandleMenuMessages(), and xxxMenuWindowProc(). { PMENU pMenu; PITEM pItem; MSG msg; UINT uPos; /* * This code to swallow double clicks isn't executed! MNLoop will * swallow all double clicks for us. Swallow the up button for the * double dude instead. Word will not be happy if they get a spurious * WM_LBUTTONUP on the menu bar if their code to close the MDI child * doesn't swallow it soon enough. */ /* * Eat the click. */ if (xxxPeekMessage(&msg, NULL, 0, 0, PM_NOYIELD)) { if ((msg.message == WM_LBUTTONUP) || (msg.message == WM_NCLBUTTONUP)) { xxxPeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE); } #if DBG else if (msg.message == WM_LBUTTONDBLCLK || msg.message == WM_NCLBUTTONDBLCLK) { UserAssertMsg0(FALSE, "xxxMNDoubleClick found a double click"); } #endif } /* * Get current item. */ pMenu = ppopup->spmenu; if ((pMenu==NULL) || ((UINT)idxItem >= pMenu->cItems)) { xxxMNDoScroll(ppopup, ppopup->posSelectedItem, FALSE); goto Done; } pItem = pMenu->rgItems + idxItem; uPos = idxItem; /* * Do nothing if item is disabled. */ if (pItem->fState & MFS_GRAYED) goto Done; /* * Traverse the hierarchy down as far as possible. */ do { if (pItem->spSubMenu != NULL) { /* * The item is a popup menu, so continue traversing. */ pMenu = pItem->spSubMenu; idxItem = (UINT)_GetMenuDefaultItem(pMenu, MF_BYPOSITION, 0); if (idxItem != -1) { pItem = pMenu->rgItems + idxItem; uPos = idxItem; continue; } else /* if (lpItem->wID == -1) How do we know this popup has an ID? */ break; } /* * We've found a leaf node of some kind, either a MFS_DEFAULT popup * with a valid cmd ID that has no valid MFS_DEFAULT children, or * a real cmd with MFS_DEFAULT style. * * Exit menu mode and send command ID. */ /* * For old apps we need to generate a WM_MENUSELECT message first. * Old apps, esp. Word 6.0, can't handle double-clicks on maximized * child sys menus because they never get a WM_MENUSELECT for the * item, unlike with normal keyboard/mouse choosing. We need to * fake it so they won't fault. Several VB apps have a similar * problem. */ if (!TestWF(ppopup->ppopupmenuRoot->spwndNotify, WFWIN40COMPAT)) { TL tlpwndNotify, tlpopup; ThreadLock(ppopup->ppopupmenuRoot->spwndNotify, &tlpwndNotify); ThreadLock(ppopup->spwndPopupMenu, &tlpopup); xxxSendMenuSelect(ppopup->ppopupmenuRoot->spwndNotify, ppopup->spwndPopupMenu, pMenu, idxItem); ThreadUnlock(&tlpopup); ThreadUnlock(&tlpwndNotify); } xxxMNDismissWithNotify(pMenuState, pMenu, pItem, uPos, 0); return TRUE; } while (TRUE); Done: return(FALSE); }

LONG_PTR xxxMNFindWindowFromPoint (  PPOPUPMENU  ppopupmenu, PUINT  pIndex, POINTS  screenPt )

Definition at line 3180 of file ntuser/kernel/menu.c. References _HasCaptionIcon(), FALSE, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fIsSysMenu, GetWindowBorders(), IsMFMWFPWindow(), L, MFMWFP_ALTMENU, MFMWFP_NOITEM, MFMWFP_OFFMENU, MNItemHitTest(), NULL, OffsetRect(), PtInRect(), tagWND::rcWindow, RevalidateHwnd, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, SYSMET, TestWF, ThreadLockAlways, ThreadUnlock, TRUE, UINT, WFMINIMIZED, and xxxSendMessage(). Referenced by xxxHandleMenuMessages(), xxxMenuWindowProc(), and xxxMNMouseMove(). { POINT pt; RECT rect; LONG_PTR longHit; UINT itemHit; PWND pwnd; TL tlpwndT; #ifdef USE_MIRRORING int cx; #endif *pIndex = 0; if (ppopupmenu->spwndNextPopup) { /* * Check if this point is on any of our children before checking if it * is on ourselves. */ ThreadLockAlways(ppopupmenu->spwndNextPopup, &tlpwndT); longHit = xxxSendMessage(ppopupmenu->spwndNextPopup, MN_FINDMENUWINDOWFROMPOINT, (WPARAM)&itemHit, MAKELONG(screenPt.x, screenPt.y)); ThreadUnlock(&tlpwndT); /* * If return value is an hwnd, convert to pwnd. */ if (IsMFMWFPWindow(longHit)) { longHit = (LONG_PTR)RevalidateHwnd((HWND)longHit); } if (longHit) { /* * Hit occurred on one of our children. */ *pIndex = itemHit; return longHit; } } if (ppopupmenu->fIsMenuBar) { int cBorders; /* * Check if this point is on the menu bar */ pwnd = ppopupmenu->spwndNotify; if (pwnd == NULL) { return MFMWFP_OFFMENU; } pt.x = screenPt.x; pt.y = screenPt.y; if (ppopupmenu->fIsSysMenu) { if (!_HasCaptionIcon(pwnd)) { /* * no system menu rect to click in if it doesn't have an icon */ return(0L); } /* * Check if this is a click on the system menu icon. */ if (TestWF(pwnd, WFMINIMIZED)) { /* * If the window is minimized, then check if there was a hit in * the client area of the icon's window. */ /* * Mikehar 5/27 * Don't know how this ever worked. If we are the system menu of an icon * we want to punt the menus if the click occurs ANYWHERE outside of the * menu. * Johnc 03-Jun-1992 the next 4 lines were commented out for Mike's * problem above but that made clicking on a minimized window with * the system menu already up, bring down the menu and put it right * up again (bug 10951) because the mnloop wouldn't swallow the mouse * down click message. The problem Mike mentions no longer shows up. */ if (PtInRect(&(pwnd->rcWindow), pt)) { return MFMWFP_NOITEM; } /* * It's an iconic window, so can't be hitting anywhere else. */ return MFMWFP_OFFMENU; } /* * Check if we are hitting on the system menu rectangle on the top * left of windows. */ rect.top = rect.left = 0; rect.right = SYSMET(CXSIZE); rect.bottom = SYSMET(CYSIZE); cBorders = GetWindowBorders(pwnd->style, pwnd->ExStyle, TRUE, FALSE); OffsetRect(&rect, pwnd->rcWindow.left + cBorders*SYSMET(CXBORDER), pwnd->rcWindow.top + cBorders*SYSMET(CYBORDER)); #ifdef USE_MIRRORING //Mirror the rect because the buttons in the left hand side of the window if it mirrored if (TestWF(pwnd, WEFLAYOUTRTL)) { cx = rect.right - rect.left; rect.right = pwnd->rcWindow.right - (rect.left - pwnd->rcWindow.left); rect.left = rect.right - cx; } #endif if (PtInRect(&rect, pt)) { *pIndex = 0; return(MFMWFP_NOITEM); } /* * Check if we hit in the alternate menu if available. */ if (ppopupmenu->spmenuAlternate) { itemHit = MNItemHitTest(ppopupmenu->spmenuAlternate, pwnd, pt); if (itemHit != MFMWFP_NOITEM) { *pIndex = itemHit; return MFMWFP_ALTMENU; } } return MFMWFP_OFFMENU; } else { if (TestWF(ppopupmenu->spwndNotify, WFMINIMIZED)) { /* * If we are minimized, we can't hit on the main menu bar. */ return MFMWFP_OFFMENU; } } } else { pwnd = ppopupmenu->spwndPopupMenu; /* * else this is a popup window and we need to check if we are hitting * anywhere on this popup window. */ pt.x = screenPt.x; pt.y = screenPt.y; if (!PtInRect(&pwnd->rcWindow, pt)) { /* * Point completely outside the popup menu window so return 0. */ return MFMWFP_OFFMENU; } } pt.x = screenPt.x; pt.y = screenPt.y; itemHit = MNItemHitTest(ppopupmenu->spmenu, pwnd, pt); if (ppopupmenu->fIsMenuBar) { /* * If hit is on menu bar but no item is there, treat it as if the user * hit nothing. */ if (itemHit == MFMWFP_NOITEM) { /* * Check if we hit in the alternate menu if available. */ if (ppopupmenu->spmenuAlternate) { itemHit = MNItemHitTest(ppopupmenu->spmenuAlternate, pwnd, pt); if (itemHit != MFMWFP_NOITEM) { *pIndex = itemHit; return MFMWFP_ALTMENU; } } return MFMWFP_OFFMENU; } *pIndex = itemHit; return MFMWFP_NOITEM; } else { /* * If hit is on popup menu but no item is there, itemHit * will be MFMWFP_NOITEM */ *pIndex = itemHit; return (LONG_PTR)pwnd; } return MFMWFP_OFFMENU; }

BOOL xxxMNHideNextHierarchy (  PPOPUPMENU  ppopup  )

Definition at line 2492 of file ntuser/kernel/menu.c. References BOOL, FALSE, L, NULL, tagPOPUPMENU::spwndActivePopup, tagPOPUPMENU::spwndNextPopup, ThreadLockAlways, ThreadUnlock, TRUE, and xxxSendMessage(). Referenced by xxxMNButtonDown(), and xxxMNMouseMove(). { if (ppopup->spwndNextPopup != NULL) { TL tlpwndT; ThreadLockAlways(ppopup->spwndNextPopup, &tlpwndT); if (ppopup->spwndNextPopup != ppopup->spwndActivePopup) xxxSendMessage(ppopup->spwndNextPopup, MN_CLOSEHIERARCHY, 0, 0L); xxxSendMessage(ppopup->spwndNextPopup, MN_SELECTITEM, (WPARAM)-1, 0L); ThreadUnlock(&tlpwndT); return TRUE; } return FALSE; }

void xxxMNKeyDown (  PPOPUPMENU  ppopupmenu, PMENUSTATE  pMenuState, UINT  key )

Definition at line 1251 of file ntuser/kernel/menu.c. References _GetSubMenu(), _IsIconic, BOOL, dir(), FALSE, tagMENUSTATE::fButtonDown, tagMENUSTATE::fDragging, tagPOPUPMENU::fDropNextPopup, tagPOPUPMENU::fHasMenuBar, tagPOPUPMENU::fHierarchyDropped, tagMENUSTATE::fIgnoreButtonUp, tagPOPUPMENU::fIsMenuBar, tagMENUSTATE::fIsSysMenu, tagMENUSTATE::fModelessMenu, tagPOPUPMENU::fRtoL, tagITEM::fState, tagMENUSTATE::fUnderline, GetMenuInheritedContextHelpId(), GETPTI, gwinOldAppHackoMaticFlags, IsRootPopupMenu(), Lock, LockPopupMenu(), MFMWFP_NOITEM, MNFindItemInColumn(), MNFindNextValidItem(), NULL, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::ppopupmenuRoot, tagTHREADINFO::pq, PtiCurrent, PtoH, PtoHq, QF_CAPTURELOCKED, tagQ::QF_flags, RevalidateHmenu, RevalidateHwnd, tagPOPUPMENU::spmenu, tagWND::spmenu, tagWND::spmenuSys, tagITEM::spSubMenu, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, tagPOPUPMENU::spwndPrevPopup, TestWF, ThreadLock, ThreadUnlock, TRUE, UINT, UnlockPopupMenu(), WFCHILD, WFMINIMIZED, WFSYSMENU, tagITEM::wID, WOAHACK_CHECKALTKEYSTATE, WOAHACK_IGNOREALTKEYDOWN, xxxMNCloseHierarchy(), xxxMNDismiss(), xxxMNDismissWithNotify(), xxxMNOpenHierarchy(), xxxMNSelectItem(), xxxMNSetCapture(), xxxMNSwitchToAlternateMenu(), xxxSendHelpMessage(), and xxxSendMessage(). Referenced by xxxHandleMenuMessages(), xxxMenuWindowProc(), and xxxMNChar(). { LRESULT dwMDIMenu; UINT item; BOOL fHierarchyWasDropped = FALSE; TL tlpwndT; PPOPUPMENU ppopupSave; BOOL bFakedKey; UINT keyOrig = key; /* * Blow off keyboard if mouse down. */ if ((pMenuState->fButtonDown) && (key != VK_F1)) { /* * Check if the user wants to cancel dragging. */ if (pMenuState->fDragging && (key == VK_ESCAPE)) { RIPMSG0(RIP_WARNING, "xxxMNKeyDown: ESC while dragging"); pMenuState->fIgnoreButtonUp = TRUE; } return; } switch (key) { case VK_MENU: case VK_F10: { /* * Modeless don't go away when the menu key is hit. They just * ignore it. */ if (pMenuState->fModelessMenu) { return; } if (gwinOldAppHackoMaticFlags & WOAHACK_CHECKALTKEYSTATE) { /* * Winoldapp is telling us to put up/down the system menu. Due to * possible race conditions, we need to check the state of the alt * key before throwing away the menu. */ if (gwinOldAppHackoMaticFlags & WOAHACK_IGNOREALTKEYDOWN) { return; } } xxxMNDismiss(pMenuState); /* * We're going to exit menu mode but the ALT key is down, so clear * pMenuState->fUnderline to cause xxxMNLoop not to erase the underlines */ if (key == VK_MENU) { pMenuState->fUnderline = FALSE; } } return; case VK_ESCAPE: /* * Escape key was hit. Get out of one level of menus. If no active * popups or we are minimized and there are no active popups below * this, we need to get out of menu mode. Otherwise, we popup up * one level in the hierarchy. */ if (ppopupmenu->fIsMenuBar || ppopupmenu == ppopupmenu->ppopupmenuRoot || TestWF(ppopupmenu->ppopupmenuRoot->spwndNotify, WFMINIMIZED)) { xxxMNDismiss(pMenuState); } else { /* * Pop back one level of menus. */ if (ppopupmenu->fHasMenuBar && ppopupmenu->spwndPrevPopup == ppopupmenu->spwndNotify) { PPOPUPMENU ppopupmenuRoot = ppopupmenu->ppopupmenuRoot; ppopupmenuRoot->fDropNextPopup = FALSE; #if 0 /* * We are on a menu bar hierarchy and there is only one popup * visible. We have to cancel this popup and put focus back on * the menu bar. */ if (_IsIconic(ppopupmenuRoot->spwndNotify)) { /* * However, if we are iconic there really is no menu * bar so let's make it easier for users and get out * of menu mode completely. */ xxxMNDismiss(pMenuState); } else #endif /* * If the popup is closed, a modeless menu won't * have a window to get the keys. So modeless menu * cancel the menu at this point. Modal menus go * to the menu bar. */ if (pMenuState->fModelessMenu) { xxxMNDismiss(pMenuState); } else { xxxMNCloseHierarchy(ppopupmenuRoot, pMenuState); } } else { ThreadLock(ppopupmenu->spwndPrevPopup, &tlpwndT); xxxSendMessage(ppopupmenu->spwndPrevPopup, MN_CLOSEHIERARCHY, 0, 0); ThreadUnlock(&tlpwndT); } } return; case VK_UP: case VK_DOWN: if (ppopupmenu->fIsMenuBar) { /* * If we are on the top level menu bar, try to open the popup if * possible. */ if (xxxMNOpenHierarchy(ppopupmenu, pMenuState) == (PWND)-1) return; } else { item = MNFindNextValidItem(ppopupmenu->spmenu, ppopupmenu->posSelectedItem, (key == VK_UP ? -1 : 1), 0); xxxMNSelectItem(ppopupmenu, pMenuState, item); } return; case VK_LEFT: case VK_RIGHT: #ifdef USE_MIRRORING bFakedKey = (!!ppopupmenu->fRtoL) ^ (!!TestWF(ppopupmenu->spwndPopupMenu, WEFLAYOUTRTL)); #else bFakedKey = ppopupmenu->fRtoL; #endif if (bFakedKey) /* * turn the keys around, we drew the menu backwards. */ key = (key == VK_LEFT) ? VK_RIGHT : VK_LEFT; if (!ppopupmenu->fIsMenuBar && (key == VK_RIGHT) && !ppopupmenu->spwndNextPopup) { /* * Try to open the hierarchy at this item if there is one. */ if (xxxMNOpenHierarchy(ppopupmenu, pMenuState) == (PWND)-1) return; if (ppopupmenu->fHierarchyDropped) { return; } } if (ppopupmenu->spwndNextPopup) { fHierarchyWasDropped = TRUE; if ((key == VK_LEFT) && !ppopupmenu->fIsMenuBar) { xxxMNCloseHierarchy(ppopupmenu, pMenuState); return; } } else if (ppopupmenu->fDropNextPopup) fHierarchyWasDropped = TRUE; ppopupSave = ppopupmenu; item = MNFindItemInColumn(ppopupmenu->spmenu, ppopupmenu->posSelectedItem, (key == VK_LEFT ? -1 : 1), (ppopupmenu->fHasMenuBar && ppopupmenu == ppopupmenu->ppopupmenuRoot)); if (item == MFMWFP_NOITEM) { /* * No valid item found in the given direction so send it up to our * parent to handle. */ if (ppopupmenu->fHasMenuBar && ppopupmenu->spwndPrevPopup == ppopupmenu->spwndNotify) { /* * if we turned the key round, then turn it back again. */ if (bFakedKey) key = (key == VK_LEFT) ? VK_RIGHT : VK_LEFT; /* * Go to next/prev item in menu bar since a popup was down and * no item on the popup to go to. */ xxxMNKeyDown(ppopupmenu->ppopupmenuRoot, pMenuState, key); return; } if (ppopupmenu == ppopupmenu->ppopupmenuRoot) { if (!ppopupmenu->fIsMenuBar) { /* * No menu bar associated with this menu so do nothing. */ return; } } else { ThreadLock(ppopupmenu->spwndPrevPopup, &tlpwndT); xxxSendMessage(ppopupmenu->spwndPrevPopup, WM_KEYDOWN, keyOrig, 0); ThreadUnlock(&tlpwndT); return; } } if (!ppopupmenu->fIsMenuBar) { if (item != MFMWFP_NOITEM) { xxxMNSelectItem(ppopupmenu, pMenuState, item); } return; } else { /* * Special handling if keydown occurred on a menu bar. */ if (item == MFMWFP_NOITEM) { if (TestWF(ppopupmenu->spwndNotify, WFSYSMENU)) { PTHREADINFO ptiCurrent = PtiCurrent(); PWND pwndNextMenu; PMENU pmenuNextMenu, pmenuUse; MDINEXTMENU mnm; TL tlpmenuNextMenu; TL tlpwndNextMenu; mnm.hmenuIn = (HMENU)0; mnm.hmenuNext = (HMENU)0; mnm.hwndNext = (HWND)0; /* * We are in the menu bar and need to go up to the system menu * or go from the system menu to the menu bar. */ pmenuNextMenu = ppopupmenu->fIsSysMenu ? _GetSubMenu(ppopupmenu->spmenu, 0) : ppopupmenu->spmenu; mnm.hmenuIn = PtoH(pmenuNextMenu); ThreadLock(ppopupmenu->spwndNotify, &tlpwndT); dwMDIMenu = xxxSendMessage(ppopupmenu->spwndNotify, WM_NEXTMENU, (WPARAM)keyOrig, (LPARAM)&mnm); ThreadUnlock(&tlpwndT); pwndNextMenu = RevalidateHwnd(mnm.hwndNext); if (pwndNextMenu == NULL) goto TryAlternate; /* * If this window belongs to another thread, we cannot * use it. The menu loop won't get any messages * directed to that thread. */ if (GETPTI(pwndNextMenu) != ptiCurrent) { RIPMSG1(RIP_WARNING, "xxxMNKeyDown: Ignoring mnm.hwndNext bacause it belongs to another thread: %#p", pwndNextMenu); goto TryAlternate; } pmenuNextMenu = RevalidateHmenu(mnm.hmenuNext); if (pmenuNextMenu == NULL) goto TryAlternate; ThreadLock(pmenuNextMenu, &tlpmenuNextMenu); ThreadLock(pwndNextMenu, &tlpwndNextMenu); /* * If the system menu is for a minimized MDI child, * make sure the menu is dropped to give the user a * visual clue that they are in menu mode */ if (TestWF(pwndNextMenu, WFMINIMIZED)) fHierarchyWasDropped = TRUE; xxxMNSelectItem(ppopupmenu, pMenuState, MFMWFP_NOITEM); pMenuState->fIsSysMenu = TRUE; UnlockPopupMenu(ppopupmenu, &ppopupmenu->spmenuAlternate); ppopupmenu->fToggle = FALSE; /* * GetSystemMenu(pwnd, FALSE) and pwnd->spmenuSys are * NOT equivalent -- GetSystemMenu returns the 1st submenu * of pwnd->spmenuSys -- make up for that here */ pmenuUse = (((pwndNextMenu->spmenuSys != NULL) && (_GetSubMenu(pwndNextMenu->spmenuSys, 0) == pmenuNextMenu)) ? pwndNextMenu->spmenuSys : pmenuNextMenu); /* * We're going to change the notification window AND the menu. * LockPopupMenu needs to unlock the current pmenu-spwndNotify * but also lock the new pmenu-spwndNotify. Since we cannot * give it the current AND the new pair, we unlock the * current one first, switch the notification window and * then call LockPopupMenu to lock the new pmenu-spwndNotify. */ UserAssert(IsRootPopupMenu(ppopupmenu)); UnlockPopupMenu(ppopupmenu, &ppopupmenu->spmenu); Lock(&ppopupmenu->spwndNotify, pwndNextMenu); Lock(&ppopupmenu->spwndPopupMenu, pwndNextMenu); LockPopupMenu(ppopupmenu, &ppopupmenu->spmenu, pmenuUse); /* * We just switched to a new notification window so * we need to Adjust capture accordingly */ if (!pMenuState->fModelessMenu) { ptiCurrent->pq->QF_flags &= ~QF_CAPTURELOCKED; xxxMNSetCapture(ppopupmenu); } if (!TestWF(pwndNextMenu, WFCHILD) && ppopupmenu->spmenu != NULL) { /* * This window has a system menu and a main menu bar * Set the alternate menu to the appropriate menu */ if (pwndNextMenu->spmenu == ppopupmenu->spmenu) { LockPopupMenu(ppopupmenu, &ppopupmenu->spmenuAlternate, pwndNextMenu->spmenuSys); pMenuState->fIsSysMenu = FALSE; } else { LockPopupMenu(ppopupmenu, &ppopupmenu->spmenuAlternate, pwndNextMenu->spmenu); } } ThreadUnlock(&tlpwndNextMenu); ThreadUnlock(&tlpmenuNextMenu); ppopupmenu->fIsSysMenu = pMenuState->fIsSysMenu; item = 0; } else TryAlternate: if (xxxMNSwitchToAlternateMenu(ppopupmenu)) { /* * go to first or last menu item int ppopup->hMenu * based on 'key' */ int dir = (key == VK_RIGHT) ? 1 : -1; item = MNFindNextValidItem(ppopupmenu->spmenu, MFMWFP_NOITEM, dir, 0); } } if (item != MFMWFP_NOITEM) { /* * we found a new menu item to go to * 1) close up the previous menu if it was dropped * 2) select the new menu item to go to * 3) drop the new menu if the previous menu was dropped */ if (ppopupSave->spwndNextPopup) xxxMNCloseHierarchy(ppopupSave, pMenuState); xxxMNSelectItem(ppopupmenu, pMenuState, item); if (fHierarchyWasDropped) { DropHierarchy: if (xxxMNOpenHierarchy(ppopupmenu, pMenuState) == (PWND)-1) { return; } } } } return; case VK_RETURN: { BOOL fEnabled; PITEM pItem; if (ppopupmenu->posSelectedItem >= ppopupmenu->spmenu->cItems) { xxxMNDismiss(pMenuState); return; } pItem = ppopupmenu->spmenu->rgItems + ppopupmenu->posSelectedItem; fEnabled = !(pItem->fState & MFS_GRAYED); if ((pItem->spSubMenu != NULL) && fEnabled) goto DropHierarchy; /* * If no item is selected, throw away menu and return. */ if (fEnabled) { xxxMNDismissWithNotify(pMenuState, ppopupmenu->spmenu, pItem, ppopupmenu->posSelectedItem, 0); } else { xxxMNDismiss(pMenuState); } return; } case VK_F1: /* Provide context sensitive help. */ { PITEM pItem; pItem = ppopupmenu->spmenu->rgItems + ppopupmenu->posSelectedItem; ThreadLock(ppopupmenu->spwndNotify, &tlpwndT); xxxSendHelpMessage(ppopupmenu->spwndNotify, HELPINFO_MENUITEM, pItem->wID, PtoHq(ppopupmenu->spmenu), GetMenuInheritedContextHelpId(ppopupmenu)); ThreadUnlock(&tlpwndT); break; } } }

void xxxMNMouseMove (  PPOPUPMENU  ppopup, PMENUSTATE  pMenuState, POINTS  ptScreen )

Definition at line 3618 of file ntuser/kernel/menu.c. References FALSE, tagMENUSTATE::fButtonDown, tagMENUSTATE::fInDoDragDrop, tagMENUSTATE::fModelessMenu, tagPOPUPMENU::fTrackMouseEvent, HWq, IsRootPopupMenu(), KEYBDHOLD, L, MFMWFP_ALTMENU, MFMWFP_NOITEM, MFMWFP_OFFMENU, tagMENUSTATE::mnFocus, MNSetTimerToAutoDismiss(), MOUSEHOLD, NULL, tagMENUSTATE::ptMouseLast, PtoH, tagPOPUPMENU::spwndActivePopup, tagPOPUPMENU::spwndNotify, TestWF, ThreadLock, ThreadUnlock, TrackMouseEvent(), TRUE, UINT, WFMINIMIZED, WFVISIBLE, xxxMNButtonDown(), xxxMNFindWindowFromPoint(), xxxMNHideNextHierarchy(), xxxMNSelectItem(), xxxMNSwitchToAlternateMenu(), xxxMNUpdateDraggingInfo(), and xxxSendMessage(). Referenced by xxxHandleMenuMessages(), and xxxMenuWindowProc(). { LONG_PTR cmdHitArea; UINT uFlags; UINT cmdItem; PWND pwnd; TL tlpwndT; if (!IsRootPopupMenu(ppopup)) { RIPMSG0(RIP_ERROR, "MenuMouseMoveHandler() called for a non top most menu"); return; } /* * Ignore mouse moves that aren't really moves. MSTEST jiggles * the mouse for some reason. And windows coming and going will * force mouse moves, to reset the cursor. */ if ((ptScreen.x == pMenuState->ptMouseLast.x) && (ptScreen.y == pMenuState->ptMouseLast.y)) return; pMenuState->ptMouseLast.x = ptScreen.x; pMenuState->ptMouseLast.y = ptScreen.y; /* * Find out where this mouse move occurred. */ cmdHitArea = xxxMNFindWindowFromPoint(ppopup, &cmdItem, ptScreen); /* * If coming from an IDropTarget call out, remember the hit test */ if (pMenuState->fInDoDragDrop) { xxxMNUpdateDraggingInfo(pMenuState, cmdHitArea, cmdItem); } if (pMenuState->mnFocus == KEYBDHOLD) { /* * Ignore mouse moves when in keyboard mode if the mouse isn't over any * menu at all. Also ignore mouse moves if over minimized window, * because we pretend that its entire window is like system menu. */ if ((cmdHitArea == MFMWFP_OFFMENU) || ((cmdHitArea == MFMWFP_NOITEM) && TestWF(ppopup->spwndNotify, WFMINIMIZED))) { return; } pMenuState->mnFocus = MOUSEHOLD; } if (cmdHitArea == MFMWFP_ALTMENU) { /* * User clicked in the other menu so switch to it ONLY IF * MOUSE IS DOWN. Usability testing proves that people frequently * get kicked into the system menu accidentally when browsing the * menu bar. We support the Win3.1 behavior when the mouse is * down however. */ if (pMenuState->fButtonDown) { xxxMNSwitchToAlternateMenu(ppopup); cmdHitArea = MFMWFP_NOITEM; } else goto OverNothing; } if (cmdHitArea == MFMWFP_NOITEM) { /* * Mouse move occurred to an item in the main menu bar. If the item * is different than the one already selected, close up the current * one, select the new one and drop its menu. But if the item is the * same as the one currently selected, we need to pull up any popups * if needed and just keep the current level visible. Hey, this is * the same as a mousedown so lets do that instead. */ xxxMNButtonDown(ppopup, pMenuState, cmdItem, FALSE); return; } else if (cmdHitArea != 0) { /* This is a popup window we moved onto. */ pwnd = (PWND)(cmdHitArea); ThreadLock(pwnd, &tlpwndT); UserAssert(TestWF(pwnd, WFVISIBLE)); /* * Modeless menus don't capture the mouse, so track it to know * when it leaves the popup. */ ppopup = ((PMENUWND)pwnd)->ppopupmenu; if (pMenuState->fModelessMenu && !pMenuState->fInDoDragDrop && !ppopup->fTrackMouseEvent) { TRACKMOUSEEVENT tme; /* tme.cbSize = sizeof(TRACKMOUSEEVENT); Not checked on kernel side */ tme.dwFlags = TME_LEAVE; tme.hwndTrack = PtoH(pwnd); TrackMouseEvent(&tme); ppopup->fTrackMouseEvent = TRUE; /* * We just entered this window so make sure the cursor * is properly set. */ xxxSendMessage(pwnd, WM_SETCURSOR, (WPARAM)HWq(pwnd), MAKELONG(MSGF_MENU, 0)); } /* * Select the item. */ uFlags = (UINT)xxxSendMessage(pwnd, MN_SELECTITEM, (WPARAM)cmdItem, 0L); if ((uFlags & MF_POPUP) && !(uFlags & MFS_GRAYED)) { /* * User moved back onto an item with a hierarchy. Hide the * the dropped popup. */ if (!xxxSendMessage(pwnd, MN_SETTIMERTOOPENHIERARCHY, 0, 0L)) { xxxMNHideNextHierarchy(ppopup); } } ThreadUnlock(&tlpwndT); } else OverNothing: { /* We moved off all menu windows... */ if (ppopup->spwndActivePopup != NULL) { pwnd = ppopup->spwndActivePopup; ThreadLock(pwnd, &tlpwndT); xxxSendMessage(pwnd, MN_SELECTITEM, MFMWFP_NOITEM, 0L); MNSetTimerToAutoDismiss(pMenuState, pwnd); ThreadUnlock(&tlpwndT); } else { xxxMNSelectItem(ppopup, pMenuState, MFMWFP_NOITEM); } } }

PWND xxxMNOpenHierarchy (  PPOPUPMENU  ppopupmenu, PMENUSTATE  pMenuState )

Definition at line 1934 of file ntuser/kernel/menu.c. References _GetAsyncKeyState(), _KillTimer(), BOOL, tagMENU::cItems, ClearMF, ClrWF, CopyOffsetRect(), tagITEM::cxItem, tagITEM::cyItem, DF_MENUINUSE, tagDESKTOP::dwDTFlags, DWORD, tagPOPUPMENU::fAboutToHide, FALSE, tagPOPUPMENU::fDelayedFree, tagPOPUPMENU::fDesktopMenu, tagMENUSTATE::fDragAndDrop, tagPOPUPMENU::fDropNextPopup, tagPOPUPMENU::fDroppedLeft, tagPOPUPMENU::fHasMenuBar, tagPOPUPMENU::fHideTimer, tagPOPUPMENU::fHierarchyDropped, tagMENUSTATE::fInsideMenuLoop, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fIsSysMenu, tagMENUSTATE::fModelessMenu, tagPOPUPMENU::fNoNotify, tagPOPUPMENU::fRtoL, tagPOPUPMENU::fSendUninit, tagPOPUPMENU::fShowTimer, tagMENUSTATE::fUnderline, FWINABLE, HANDLEF_DESTROY, tagWND::head, HMChangeOwnerThread(), hModuleWin, HMPheFromObject, HW, tagPOPUPMENU::iDropDir, IDSYS_MNSHOW, IntersectRect(), KEYBDHOLD, L, Lock, LockPopupMenu(), LPVOID, MENUCLASS, MFMWFP_NOITEM, MFUNDERLINE, tagMENUSTATE::mnFocus, MNSW_SIZE, NT_SUCCESS, NULL, PAS_LEFT, PAS_OUT, PAS_RIGHT, tagDESKTOP::pDeskInfo, PlayEventSound(), tagTHREADINFO::pMenuState, tagPOPUPMENU::posDropped, tagPOPUPMENU::posSelectedItem, tagTHREADINFO::ppi, tagPOPUPMENU::ppmDelayedFree, tagPOPUPMENU::ppopupmenuRoot, tagWINDOWSTATION::pTerm, PtiCurrent, tagTERMINAL::ptiDesktop, PtoHq, PWND_TOP, PWND_TOPMOST, tagMONITOR::rcMonitor, tagWND::rcWindow, tagMENU::rgItems, tagTHREADINFO::rpdesk, tagDESKTOP::rpwinstaParent, SetMF, SetWF, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagITEM::spSubMenu, tagDESKTOPINFO::spwnd, tagPOPUPMENU::spwndActivePopup, tagDESKTOP::spwndMenu, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagWND::spwndOwner, tagPOPUPMENU::spwndPopupMenu, tagPOPUPMENU::spwndPrevPopup, SYSMET, TestMFS, TestMFT, TestWF, ThreadLock, ThreadLockAlways, ThreadUnlock, TIF_DISABLEHOOKS, tagTHREADINFO::TIF_flags, TRUE, Unlock, USER_SOUND_MENUPOPUP, WEFTOPMOST, WFOLDUI, WFVISIBLE, tagITEM::xItem, xxxCleanupDesktopMenu(), xxxClientRegisterDragDrop(), xxxCreateWindowEx(), xxxDestroyWindow(), xxxMNCloseHierarchy(), xxxMNDestroyHandler(), xxxMNPositionHierarchy(), xxxSendMessage(), xxxSetParent(), xxxSetWindowPos(), xxxUpdateWindow(), xxxWindowEvent(), and tagITEM::yItem. Referenced by xxxMenuWindowProc(), xxxMNButtonDown(), xxxMNButtonUp(), xxxMNKeyDown(), and xxxMNKeyFilter(). { PWND ret = 0; PITEM pItem; PWND pwndHierarchy; PPOPUPMENU ppopupmenuHierarchy; LONG sizeHierarchy; int xLeft; int yTop; int cxPopup, cyPopup; TL tlpwndT; TL tlpwndHierarchy; PTHREADINFO ptiCurrent = PtiCurrent(); PDESKTOP pdesk = ptiCurrent->rpdesk; BOOL fSendUninit = FALSE; HMENU hmenuInit; PMONITOR pMonitor; if (ppopupmenu->posSelectedItem == MFMWFP_NOITEM) { /* * No selection so fail. */ return NULL; } if (ppopupmenu->posSelectedItem >= ppopupmenu->spmenu->cItems) return NULL; if (ppopupmenu->fHierarchyDropped) { if (ppopupmenu->fHideTimer) { xxxMNCloseHierarchy(ppopupmenu,pMenuState); } else { /* * Hierarchy already dropped. What are we doing here? */ UserAssert(!ppopupmenu->fHierarchyDropped); return NULL; } } if (ppopupmenu->fShowTimer) { _KillTimer(ppopupmenu->spwndPopupMenu, IDSYS_MNSHOW); ppopupmenu->fShowTimer = FALSE; } /* * Get a pointer to the currently selected item in this menu. */ pItem = &(ppopupmenu->spmenu->rgItems[ppopupmenu->posSelectedItem]); if (pItem->spSubMenu == NULL) goto Exit; /* * Send the initmenupopup message. */ if (!ppopupmenu->fNoNotify) { ThreadLock(ppopupmenu->spwndNotify, &tlpwndT); /* * WordPerfect's Grammatik app doesn't know that TRUE means NON-ZERO, * not 1. So we must use 0 & 1 explicitly for fIsSysMenu here * -- Win95B B#4947 -- 2/13/95 -- jeffbog */ hmenuInit = PtoHq(pItem->spSubMenu); xxxSendMessage(ppopupmenu->spwndNotify, WM_INITMENUPOPUP, (WPARAM)hmenuInit, MAKELONG(ppopupmenu->posSelectedItem, (ppopupmenu->fIsSysMenu ? 1: 0))); ThreadUnlock(&tlpwndT); fSendUninit = TRUE; } /* * B#1517 * Check if we're still in menu loop */ if (!pMenuState->fInsideMenuLoop) { RIPMSG0(RIP_WARNING, "Menu loop ended unexpectedly by WM_INITMENUPOPUP"); ret = (PWND)-1; goto Exit; } /* * The WM_INITMENUPOPUP message may have resulted in a change to the * menu. Make sure the selection is still valid. */ if (ppopupmenu->posSelectedItem >= ppopupmenu->spmenu->cItems) { /* * Selection is out of range, so fail. */ goto Exit; } /* * Get a pointer to the currently selected item in this menu. * Bug #17867 - the call can cause this thing to change, so reload it. */ pItem = &(ppopupmenu->spmenu->rgItems[ppopupmenu->posSelectedItem]); if (TestMFS(pItem, MFS_GRAYED) || (pItem->spSubMenu == NULL) || (pItem->spSubMenu->cItems == 0)) { /* * The item is disabled, no longer a popup, or empty so don't drop. */ /* * No items in menu. */ goto Exit; } /* * Let's make sure that the current thread is in menu mode and * it uses this pMenuState. Otherwise the window we're about to * create (or set the thread to) will point to a different pMenuState */ UserAssert(ptiCurrent->pMenuState == pMenuState); if (ppopupmenu->fIsMenuBar && (pdesk->spwndMenu != NULL) && (!(pdesk->dwDTFlags & DF_MENUINUSE)) && !TestWF(pdesk->spwndMenu, WFVISIBLE)) { pdesk->dwDTFlags |= DF_MENUINUSE; if (HMPheFromObject(pdesk->spwndMenu)->bFlags & HANDLEF_DESTROY) { PPROCESSINFO ppi = pdesk->rpwinstaParent->pTerm->ptiDesktop->ppi; PPROCESSINFO ppiSave; PWND pwndMenu; DWORD dwDisableHooks; /* * the menu window is destroyed -- recreate it * * clear the desktopMenu flag so that the popup is * freed. */ UserAssert(ppopupmenu->fDesktopMenu); ppopupmenu->fDesktopMenu = FALSE; ppopupmenu->fDelayedFree = FALSE; Unlock(&pdesk->spwndMenu); ppiSave = ptiCurrent->ppi; ptiCurrent->ppi = ppi; /* * HACK HACK HACK!!! (adams) In order to create the menu window * with the correct desktop, we set the desktop of the current thread * to the new desktop. But in so doing we allow hooks on the current * thread to also hook this new desktop. This is bad, because we don't * want the menu window to be hooked while it is created. So we * temporarily disable hooks of the current thread or desktop, * and reenable them after switching back to the original desktop. */ dwDisableHooks = ptiCurrent->TIF_flags & TIF_DISABLEHOOKS; ptiCurrent->TIF_flags |= TIF_DISABLEHOOKS; pwndMenu = xxxCreateWindowEx( WS_EX_TOOLWINDOW | WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE, (PLARGE_STRING)MENUCLASS, NULL, WS_POPUP | WS_BORDER, 0, 0, 100, 100, NULL, NULL, hModuleWin, NULL, WINVER); UserAssert(ptiCurrent->TIF_flags & TIF_DISABLEHOOKS); ptiCurrent->TIF_flags = (ptiCurrent->TIF_flags & ~TIF_DISABLEHOOKS) | dwDisableHooks; Lock(&(pdesk->spwndMenu), pwndMenu); UserAssert(((PMENUWND)pwndMenu)->ppopupmenu != NULL); /* * Set the desktopMenu flag to mark that this is the popup * allocated for pdesk->spwndMenu * Unlock spwndPopupMenu to avoid this special case in the common code path. */ ((PMENUWND)pwndMenu)->ppopupmenu->fDesktopMenu = TRUE; Unlock(&((PMENUWND)pwndMenu)->ppopupmenu->spwndPopupMenu); ptiCurrent->ppi = ppiSave; HMChangeOwnerThread(pdesk->spwndMenu, pdesk->rpwinstaParent->pTerm->ptiDesktop); } else { TL tlpwndDesk; ThreadLockAlways(pdesk->spwndMenu, &tlpwndT); ThreadLockAlways(pdesk->pDeskInfo->spwnd, &tlpwndDesk); xxxSetParent(pdesk->spwndMenu, pdesk->pDeskInfo->spwnd); ThreadUnlock(&tlpwndDesk); ThreadUnlock(&tlpwndT); } pwndHierarchy = pdesk->spwndMenu; Lock(&pwndHierarchy->spwndOwner, ppopupmenu->spwndNotify); pwndHierarchy->head.pti = ptiCurrent; /* * Make the topmost state match the menu mode */ if ((TestWF(pdesk->spwndMenu, WEFTOPMOST) && pMenuState->fModelessMenu) || (!TestWF(pdesk->spwndMenu, WEFTOPMOST) && !pMenuState->fModelessMenu)) { ThreadLock(pdesk->spwndMenu, &tlpwndHierarchy); xxxSetWindowPos(pdesk->spwndMenu, (pMenuState->fModelessMenu ? PWND_NOTOPMOST: PWND_TOPMOST), 0,0,0,0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING); ThreadUnlock(&tlpwndHierarchy); } ppopupmenuHierarchy = ((PMENUWND)pwndHierarchy)->ppopupmenu; UserAssert(ppopupmenuHierarchy->fDesktopMenu); /* * clear any leftover data from the last time we used it * Assert that we're not zapping any locks here */ UserAssert(ppopupmenuHierarchy->spwndPopupMenu == NULL); UserAssert(ppopupmenuHierarchy->spwndNextPopup == NULL); UserAssert(ppopupmenuHierarchy->spwndPrevPopup == NULL); UserAssert(ppopupmenuHierarchy->spmenu == NULL); UserAssert(ppopupmenuHierarchy->spmenuAlternate == NULL); UserAssert(ppopupmenuHierarchy->spwndNotify == NULL); UserAssert(ppopupmenuHierarchy->spwndActivePopup == NULL); RtlZeroMemory((PVOID)ppopupmenuHierarchy, sizeof(POPUPMENU)); ppopupmenuHierarchy->fDesktopMenu = TRUE; ppopupmenuHierarchy->posSelectedItem = MFMWFP_NOITEM; Lock(&ppopupmenuHierarchy->spwndPopupMenu, pdesk->spwndMenu); Lock(&(ppopupmenuHierarchy->spwndNotify), ppopupmenu->spwndNotify); LockPopupMenu(ppopupmenuHierarchy, &ppopupmenuHierarchy->spmenu, pItem->spSubMenu); } else { ThreadLock(ppopupmenu->spwndNotify, &tlpwndT); pwndHierarchy = xxxCreateWindowEx( WS_EX_TOOLWINDOW | WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE, (PLARGE_STRING)MENUCLASS, NULL, WS_POPUP | WS_BORDER, 0, 0, 100, 100, ppopupmenu->spwndNotify, NULL, (HANDLE)ppopupmenu->spwndNotify->hModule, (LPVOID)pItem->spSubMenu, WINVER); ThreadUnlock(&tlpwndT); if (!pwndHierarchy) goto Exit; /* * Do this so old apps don't get weird borders on the popups of * hierarchical items! */ ClrWF(pwndHierarchy, WFOLDUI); ppopupmenuHierarchy = ((PMENUWND)pwndHierarchy)->ppopupmenu; } /* * Mark this as fDelayedFree and link it */ ppopupmenuHierarchy->fDelayedFree = TRUE; ppopupmenuHierarchy->ppmDelayedFree = ppopupmenu->ppopupmenuRoot->ppmDelayedFree; ppopupmenu->ppopupmenuRoot->ppmDelayedFree = ppopupmenuHierarchy; #ifdef USE_MIRRORING if (TestWF(ppopupmenu->spwndPopupMenu, WEFLAYOUTRTL)) { SetWF(pwndHierarchy, WEFLAYOUTRTL); } else { ClrWF(pwndHierarchy, WEFLAYOUTRTL); } #endif Lock(&(ppopupmenuHierarchy->spwndNotify), ppopupmenu->spwndNotify); #if DBG /* * We should associate ppopupmenuHierarchy to the same menu we sent the * WM_INITMsENUPOPUP message. Otherwise, the WM_UNINITMENUPOPUP * will go to the wrong window. It would be the app's fault... */ if (!ppopupmenu->fNoNotify && (hmenuInit != PtoHq(pItem->spSubMenu))) { RIPMSG2(RIP_WARNING, "xxxMNOpenHierarchy: bad app changed submenu from %#p to %#p", hmenuInit, PtoHq(pItem->spSubMenu)); } #endif LockPopupMenu(ppopupmenuHierarchy, &ppopupmenuHierarchy->spmenu, pItem->spSubMenu); Lock(&(ppopupmenu->spwndNextPopup), pwndHierarchy); ppopupmenu->posDropped = ppopupmenu->posSelectedItem; Lock(&(ppopupmenuHierarchy->spwndPrevPopup), ppopupmenu->spwndPopupMenu); ppopupmenuHierarchy->ppopupmenuRoot = ppopupmenu->ppopupmenuRoot; ppopupmenuHierarchy->fHasMenuBar = ppopupmenu->fHasMenuBar; ppopupmenuHierarchy->fIsSysMenu = ppopupmenu->fIsSysMenu; ppopupmenuHierarchy->fNoNotify = ppopupmenu->fNoNotify; ppopupmenuHierarchy->fSendUninit = TRUE; ppopupmenuHierarchy->fRtoL = ppopupmenu->fRtoL; /* * The menu window has been created and intialized so if * something fails, the WM_UNINITMENUPOPUP message will * be sent from xxxMNDestroyHandler */ fSendUninit = FALSE; /* * Set/clear the underline flag */ if (pMenuState->fUnderline) { SetMF(ppopupmenuHierarchy->spmenu, MFUNDERLINE); } else { ClearMF(ppopupmenuHierarchy->spmenu, MFUNDERLINE); } ppopupmenuHierarchy->fAboutToHide = FALSE; /* * Find the size of the menu window and actually size it (wParam = 1) */ ThreadLock(pwndHierarchy, &tlpwndHierarchy); sizeHierarchy = (LONG)xxxSendMessage(pwndHierarchy, MN_SIZEWINDOW, MNSW_SIZE, 0); if (!sizeHierarchy) { /* * No size for this menu so zero it and blow off. */ UserAssert(ppopupmenuHierarchy->fDelayedFree); if (ppopupmenuHierarchy->fDesktopMenu) { xxxMNDestroyHandler(ppopupmenuHierarchy); xxxCleanupDesktopMenu(pwndHierarchy, pdesk); } if (ThreadUnlock(&tlpwndHierarchy)) { if (!ppopupmenuHierarchy->fDesktopMenu) { xxxDestroyWindow(pwndHierarchy); } } Unlock(&ppopupmenu->spwndNextPopup); goto Exit; } cxPopup = LOWORD(sizeHierarchy) + 2*SYSMET(CXFIXEDFRAME); cyPopup = HIWORD(sizeHierarchy) + 2*SYSMET(CYFIXEDFRAME); ppopupmenu->fHierarchyDropped = TRUE; /* * Find out the x,y position to drop the hierarchy and the animation * direction */ ppopupmenuHierarchy->iDropDir = xxxMNPositionHierarchy( ppopupmenu, pItem, cxPopup, cyPopup, &xLeft, &yTop, &pMonitor); if (ppopupmenu->fIsMenuBar && _GetAsyncKeyState(VK_LBUTTON) & 0x8000) { /* * If the menu had to be pinned to the bottom of the screen and * the mouse button is down, make sure the mouse isn't over the * menu rect. */ RECT rc; RECT rcParent; int xrightdrop; int xleftdrop; /* * Get rect of hierarchical */ CopyOffsetRect( &rc, &pwndHierarchy->rcWindow, xLeft - pwndHierarchy->rcWindow.left, yTop - pwndHierarchy->rcWindow.top); /* * Get the rect of the menu bar popup item */ rcParent.left = pItem->xItem + ppopupmenu->spwndPopupMenu->rcWindow.left; rcParent.top = pItem->yItem + ppopupmenu->spwndPopupMenu->rcWindow.top; rcParent.right = rcParent.left + pItem->cxItem; rcParent.bottom = rcParent.top + pItem->cyItem; if (IntersectRect(&rc, &rc, &rcParent)) { /* * Oh, oh... The cursor will sit right on top of a menu item. * If the user up clicks, a menu will be accidently selected. * * Calc x position of hierarchical if we dropped it to the * right/left of the menu bar item. */ xrightdrop = ppopupmenu->spwndPopupMenu->rcWindow.left + pItem->xItem + pItem->cxItem + cxPopup; if (xrightdrop > pMonitor->rcMonitor.right) { xrightdrop = 0; } xleftdrop = ppopupmenu->spwndPopupMenu->rcWindow.left + pItem->xItem - cxPopup; if (xleftdrop < pMonitor->rcMonitor.left) { xleftdrop = 0; } if (((SYSMET(MENUDROPALIGNMENT) || TestMFT(pItem, MFT_RIGHTORDER)) && xleftdrop) || !xrightdrop) { xLeft = ppopupmenu->spwndPopupMenu->rcWindow.left + pItem->xItem - cxPopup; ppopupmenuHierarchy->iDropDir = PAS_LEFT; } else if (xrightdrop) { xLeft = ppopupmenu->spwndPopupMenu->rcWindow.left + pItem->xItem + pItem->cxItem; ppopupmenuHierarchy->iDropDir = PAS_RIGHT; } } } /* * Take care of fDropNextPopup (menu bar) or fDroppedLeft (popups) * Set animation flag */ if (ppopupmenu->fIsMenuBar) { /* * Only the first popup being dropped off the menu bar * is animated. */ if (!ppopupmenu->fDropNextPopup) { ppopupmenuHierarchy->iDropDir |= PAS_OUT; } /* * Propagate right-to-left direction. */ if (ppopupmenu->fDroppedLeft || (ppopupmenuHierarchy->iDropDir == PAS_LEFT)) { ppopupmenuHierarchy->fDroppedLeft = TRUE; } /* * Once a popup is dropped from the menu bar, moving to the next * item on the menu bar should drop the popup. */ ppopupmenu->fDropNextPopup = TRUE; } else { /* * Submenus always animate. */ ppopupmenuHierarchy->iDropDir |= PAS_OUT; /* * Is this popup a lefty? */ if (ppopupmenuHierarchy->iDropDir == PAS_LEFT) { ppopupmenuHierarchy->fDroppedLeft = TRUE; } } /* * The previous active dude must be visible */ UserAssert((ppopupmenu->ppopupmenuRoot->spwndActivePopup == NULL) || TestWF(ppopupmenu->ppopupmenuRoot->spwndActivePopup, WFVISIBLE)); /* * This is the new active popup */ Lock(&(ppopupmenu->ppopupmenuRoot->spwndActivePopup), pwndHierarchy); /* * Paint the owner window before the popup menu comes up so that * the proper bits are saved. */ if (ppopupmenuHierarchy->spwndNotify != NULL) { ThreadLockAlways(ppopupmenuHierarchy->spwndNotify, &tlpwndT); xxxUpdateWindow(ppopupmenuHierarchy->spwndNotify); ThreadUnlock(&tlpwndT); } /* * If this is a drag and drop menu, then we need to register the window * as a drop target. */ if (pMenuState->fDragAndDrop) { if (!NT_SUCCESS(xxxClientRegisterDragDrop(HW(pwndHierarchy)))) { RIPMSG1(RIP_ERROR, "xxxMNOpenHierarchy: xxxClientRegisterDragDrop failed:%#p", pwndHierarchy); } } /* * Show the window. Modeless menus are not topmost and get activated. * Modal menus are topmost but don't get activated. */ PlayEventSound(USER_SOUND_MENUPOPUP); xxxSetWindowPos(pwndHierarchy, (pMenuState->fModelessMenu ? PWND_TOP : PWND_TOPMOST), xLeft, yTop, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOOWNERZORDER | (pMenuState->fModelessMenu ? 0 : SWP_NOACTIVATE)); if (FWINABLE()) { xxxWindowEvent(EVENT_SYSTEM_MENUPOPUPSTART, pwndHierarchy, OBJID_CLIENT, INDEXID_CONTAINER, 0); } /* * Select the first item IFF we're in keyboard mode. This fixes a * surprising number of compatibility problems with keyboard macros, * scripts, etc. */ if (pMenuState->mnFocus == KEYBDHOLD) { xxxSendMessage(pwndHierarchy, MN_SELECTITEM, 0, 0L); } /* * This is needed so that popup menus are properly drawn on sys * modal dialog boxes. */ xxxUpdateWindow(pwndHierarchy); ret = pwndHierarchy; ThreadUnlock(&tlpwndHierarchy); Exit: /* * send matching WM_UNINITMENUPOPUP if needed (i.e, something * failed). */ if (fSendUninit && (ppopupmenu->spwndNotify != NULL)) { ThreadLockAlways(ppopupmenu->spwndNotify, &tlpwndT); xxxSendMessage(ppopupmenu->spwndNotify, WM_UNINITMENUPOPUP, (WPARAM)hmenuInit, MAKELONG(0, (ppopupmenu->fIsSysMenu ? MF_SYSMENU : 0))); ThreadUnlock(&tlpwndT); } return ret; }

UINT xxxMNPositionHierarchy (  PPOPUPMENU  ppopup, PITEM  pitem, int  cx, int  cy, int *  px, int *  py, PMONITOR *  ppMonitor )

Definition at line 1683 of file ntuser/kernel/menu.c. References _MonitorFromRect(), _MonitorFromWindow(), BOOL, CopyRect, tagITEM::cxItem, cy, tagITEM::cyItem, tagMENU::dwArrowsOn, tagPOPUPMENU::fDroppedLeft, tagPOPUPMENU::fHierarchyDropped, tagPOPUPMENU::fIsMenuBar, gcyMenuScrollArrow, IsTrayWindow(), max, MFRTL, min, MNGetToppItem(), MSA_OFF, NULL, PAS_DOWN, PAS_HORZ, PAS_LEFT, PAS_RIGHT, PAS_UP, tagMONITOR::rcMonitor, tagWND::rcWindow, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndPopupMenu, SYSMET, TestMF, TestWF, TRUE, UINT, WFMINIMIZED, tagITEM::xItem, xxxSendMinRectMessages(), and tagITEM::yItem. Referenced by xxxMenuWindowProc(), and xxxMNOpenHierarchy(). { int x, y; UINT uPAS; PMONITOR pMonitor; UserAssert(ppopup->fHierarchyDropped && (ppopup->spwndNextPopup != NULL)); if (ppopup->fIsMenuBar) { /* * This is a menu being dropped from the top menu bar. We need to * position it differently than hierarchicals which are dropped from * another popup. */ BOOL fIconic = (TestWF(ppopup->spwndPopupMenu, WFMINIMIZED) != 0); RECT rcWindow; /* * Menu bar popups animate down. */ uPAS = PAS_DOWN; CopyRect(&rcWindow, &ppopup->spwndPopupMenu->rcWindow); if (fIconic && IsTrayWindow(ppopup->spwndPopupMenu)) { xxxSendMinRectMessages(ppopup->spwndPopupMenu, &rcWindow); } /* * x position */ if (!SYSMET(MENUDROPALIGNMENT) && !TestMF(ppopup->spmenu,MFRTL)) { if (fIconic) { x = rcWindow.left; } else { x = rcWindow.left + pitem->xItem; } } else { ppopup->fDroppedLeft = TRUE; if (fIconic) { x = rcWindow.right - cx; } else { x = rcWindow.left + pitem->xItem + pitem->cxItem - cx; } } /* * For a menu bar dropdown, pin to the monitor that owns the * majority of the menu item. Otherwise, pin to the monitor that * owns the minimized window (the tray rect for min-to-tray dudes). */ if (!fIconic) { /* * Use rcWindow as scratch for the menu bar item rect. We want * to pin this menu on whatever monitor owns most of the menu * item clicked on. */ rcWindow.left += pitem->xItem; rcWindow.top += pitem->yItem; rcWindow.right = rcWindow.left + pitem->cxItem; rcWindow.bottom = rcWindow.top + pitem->cyItem; } pMonitor = _MonitorFromRect(&rcWindow, MONITOR_DEFAULTTOPRIMARY); /* * y position */ if (!fIconic) { y = rcWindow.bottom; } else { /* * If the window is iconic, pop the menu up. Since we're * minimized, the sysmenu button doesn't really exist. */ y = rcWindow.top - cy; if (y < pMonitor->rcMonitor.top) { y = rcWindow.bottom; } } /* * Make sure the menu doesn't go off right side of monitor */ x = min(x, pMonitor->rcMonitor.right - cx); #ifdef USE_MIRRORING if (TestWF(ppopup->spwndPopupMenu, WEFLAYOUTRTL)) { x = ppopup->spwndPopupMenu->rcWindow.right - x + ppopup->spwndPopupMenu->rcWindow.left - cx; } #endif } else { /* if (ppopup->fIsMenuBar) */ /* Now position the hierarchical menu window. * We want to overlap by the amount of the frame, to help in the * 3D illusion. */ /* * By default, hierachical popups animate to the right */ uPAS = PAS_RIGHT; x = ppopup->spwndPopupMenu->rcWindow.left + pitem->xItem + pitem->cxItem; /* Note that we DO want the selections in the item and its popup to * align horizontally. */ y = ppopup->spwndPopupMenu->rcWindow.top + pitem->yItem; if (ppopup->spmenu->dwArrowsOn != MSA_OFF) { y += gcyMenuScrollArrow - MNGetToppItem(ppopup->spmenu)->yItem; } /* * Try to make sure the menu doesn't go off right side of the * monitor. If it does, drop it left, overlapping the checkmark * area. Unless it would cover the previous menu... * * Use the monitor that the parent menu is on to keep all hierarchicals * in the same place. */ pMonitor = _MonitorFromWindow( ppopup->spwndPopupMenu, MONITOR_DEFAULTTOPRIMARY); #ifdef USE_MIRRORING if ((!!ppopup->fDroppedLeft) ^ (!!TestWF(ppopup->spwndPopupMenu, WEFLAYOUTRTL))) { #else if (ppopup->fDroppedLeft) { #endif int xTmp; /* * If this menu has dropped left, see if our hierarchy can be made * to drop to the left also. */ xTmp = ppopup->spwndPopupMenu->rcWindow.left + SYSMET(CXFIXEDFRAME) - cx; if (xTmp >= pMonitor->rcMonitor.left) { x = xTmp; uPAS = PAS_LEFT; } } /* * Make sure the menu doesn't go off right side of screen. Make it drop * left if it does. */ if (x + cx > pMonitor->rcMonitor.right) { x = ppopup->spwndPopupMenu->rcWindow.left + SYSMET(CXFIXEDFRAME) - cx; uPAS = PAS_LEFT; } #ifdef USE_MIRRORING if (TestWF(ppopup->spwndPopupMenu, WEFLAYOUTRTL)) { uPAS ^= PAS_HORZ; } #endif } /* else if (ppopup->fIsMenuBar) */ /* * Does the menu extend beyond bottom of monitor? */ UserAssert(pMonitor); if (y + cy > pMonitor->rcMonitor.bottom) { y -= cy; /* * Try to pop above menu bar first */ if (ppopup->fIsMenuBar) { y -= SYSMET(CYMENUSIZE); if (y >= pMonitor->rcMonitor.top) { uPAS = PAS_UP; } } else { /* * Account for nonclient frame above & below */ y += pitem->cyItem + 2*SYSMET(CYFIXEDFRAME); } /* * Make sure that starting point is on a monitor, and all of menu shows. */ if ( (y < pMonitor->rcMonitor.top) || (y + cy > pMonitor->rcMonitor.bottom)) /* * Pin it to the bottom. */ y = pMonitor->rcMonitor.bottom - cy; } /* * Make sure Upper Left corner of menu is always visible. */ x = max(x, pMonitor->rcMonitor.left); y = max(y, pMonitor->rcMonitor.top); /* * Propagate position */ *px = x; *py = y; *ppMonitor = pMonitor; /* * Return animation direction */ return uPAS; }

void xxxMNReleaseCapture (  void   )

Definition at line 181 of file ntuser/kernel/menu.c. References FALSE, tagMENUSTATE::fSetCapture, NULL, tagTHREADINFO::pMenuState, PtiCurrent, QF_CAPTURELOCKED, and xxxReleaseCapture(). Referenced by xxxEndMenu(), xxxMNCancel(), xxxMNLoop(), xxxMNStartMenu(), and xxxTrackPopupMenuEx(). { PTHREADINFO ptiCurrent = PtiCurrent(); /* * Bail if we didn't set capture */ if ((ptiCurrent->pMenuState == NULL) || (! ptiCurrent->pMenuState->fSetCapture)) { return; } ptiCurrent->pMenuState->fSetCapture = FALSE; /* * Unlock capture and release it. */ PtiCurrent()->pq->QF_flags &= ~QF_CAPTURELOCKED; xxxReleaseCapture(); }

PITEM xxxMNSelectItem (  PPOPUPMENU  ppopupmenu, PMENUSTATE  pMenuState, UINT  itemPos )

Definition at line 2818 of file ntuser/kernel/menu.c. References _KillTimer(), tagMENU::cItems, tagMENUSTATE::fAboutToAutoDismiss, tagPOPUPMENU::fAboutToHide, FALSE, tagMENUSTATE::fButtonDown, tagPOPUPMENU::fHasMenuBar, tagPOPUPMENU::fHideTimer, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fIsSysMenu, tagMENUSTATE::fMouseOffMenu, tagPOPUPMENU::fShowTimer, FWINABLE, IDSYS_MNHIDE, IDSYS_MNSHOW, L, Lock, MFMWFP_NOITEM, MNAnimate(), MNIsItemSelected(), MNIsScrollArrowSelected(), MNSetTimerToCloseHierarchy(), NULL, tagPOPUPMENU::posDropped, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::ppopupmenuRoot, tagMENU::rgItems, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndActivePopup, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, tagPOPUPMENU::spwndPrevPopup, ThreadLock, ThreadUnlock, TRUE, xxxMNCloseHierarchy(), xxxMNDoScroll(), xxxMNInvertItem(), xxxSendMenuSelect(), xxxSendMessage(), and xxxWindowEvent(). Referenced by xxxMenuWindowProc(), xxxMNButtonDown(), xxxMNCancel(), xxxMNChar(), xxxMNKeyDown(), xxxMNKeyFilter(), xxxMNMouseMove(), and xxxMNSwitchToAlternateMenu(). { PITEM pItem = NULL; TL tlpwndNotify; TL tlpwndPopup; TL tlpmenu; PWND pwndNotify; PMENU pmenu; if (ppopupmenu->posSelectedItem == itemPos) { /* * If this item is already selectected, just return its flags. */ if ((itemPos != MFMWFP_NOITEM) && (itemPos < ppopupmenu->spmenu->cItems)) { return &(ppopupmenu->spmenu->rgItems[itemPos]); } return NULL; } /* * Terminate any animation */ MNAnimate(pMenuState, FALSE); if (ppopupmenu->fShowTimer) { _KillTimer(ppopupmenu->spwndPopupMenu, IDSYS_MNSHOW); ppopupmenu->fShowTimer = FALSE; } ThreadLock(pmenu = ppopupmenu->spmenu, &tlpmenu); ThreadLock(pwndNotify = ppopupmenu->spwndNotify, &tlpwndNotify); if (ppopupmenu->fAboutToHide) { PPOPUPMENU ppopupPrev = ((PMENUWND)(ppopupmenu->spwndPrevPopup))->ppopupmenu; _KillTimer(ppopupPrev->spwndPopupMenu, IDSYS_MNHIDE); ppopupPrev->fHideTimer = FALSE; if (ppopupPrev->fShowTimer) { _KillTimer(ppopupPrev->spwndPopupMenu, IDSYS_MNSHOW); ppopupPrev->fShowTimer = FALSE; } if (ppopupPrev->posSelectedItem != ppopupPrev->posDropped) { TL tlpmenuPopupMenuPrev; ThreadLock(ppopupPrev->spmenu, &tlpmenuPopupMenuPrev); if (ppopupPrev->posSelectedItem != MFMWFP_NOITEM) { xxxMNInvertItem(ppopupPrev, ppopupPrev->spmenu, ppopupPrev->posSelectedItem, ppopupPrev->spwndNotify, FALSE); } ppopupPrev->posSelectedItem = ppopupPrev->posDropped; xxxMNInvertItem(ppopupPrev, ppopupPrev->spmenu, ppopupPrev->posDropped, ppopupPrev->spwndNotify, TRUE); ThreadUnlock(&tlpmenuPopupMenuPrev); } ppopupmenu->fAboutToHide = FALSE; Lock(&ppopupmenu->ppopupmenuRoot->spwndActivePopup, ppopupmenu->spwndPopupMenu); } if (MNIsItemSelected(ppopupmenu)) { /* * Something else is selected so we need to unselect it. */ if (ppopupmenu->spwndNextPopup) { if (ppopupmenu->fIsMenuBar) { xxxMNCloseHierarchy(ppopupmenu, pMenuState); } else { MNSetTimerToCloseHierarchy(ppopupmenu); } } goto DeselectItem; } else if (MNIsScrollArrowSelected(ppopupmenu)) { _KillTimer(ppopupmenu->spwndPopupMenu, ppopupmenu->posSelectedItem); DeselectItem: xxxMNInvertItem(ppopupmenu, pmenu, ppopupmenu->posSelectedItem, pwndNotify, FALSE); } ppopupmenu->posSelectedItem = itemPos; if (itemPos != MFMWFP_NOITEM) { /* * If an item is selected, no autodismiss plus this means * that the mouse is on the menu */ pMenuState->fAboutToAutoDismiss = pMenuState->fMouseOffMenu = FALSE; if (pMenuState->fButtonDown) { xxxMNDoScroll(ppopupmenu, itemPos, TRUE); } pItem = xxxMNInvertItem(ppopupmenu, pmenu, itemPos, pwndNotify, TRUE); ThreadUnlock(&tlpwndNotify); ThreadUnlock(&tlpmenu); return pItem; } else if (FWINABLE()) { /* * Notify that nothing is now focused in this menu. */ xxxWindowEvent(EVENT_OBJECT_FOCUS, ppopupmenu->spwndPopupMenu, ((ppopupmenu->spwndNotify != ppopupmenu->spwndPopupMenu) ? OBJID_CLIENT : (ppopupmenu->fIsSysMenu ? OBJID_SYSMENU : OBJID_MENU)), 0, 0); } ThreadUnlock(&tlpwndNotify); ThreadUnlock(&tlpmenu); if (ppopupmenu->spwndPrevPopup != NULL) { PPOPUPMENU pp; /* * Get the popupMenu data for the previous menu * Use the root popupMenu if the previous menu is the menu bar */ if (ppopupmenu->fHasMenuBar && (ppopupmenu->spwndPrevPopup == ppopupmenu->spwndNotify)) { pp = ppopupmenu->ppopupmenuRoot; } else { #ifdef HAVE_MN_GETPPOPUPMENU TL tlpwndPrevPopup; ThreadLock(ppopupmenu->spwndPrevPopup, &tlpwndPrevPopup); pp = (PPOPUPMENU)xxxSendMessage(ppopupmenu->spwndPrevPopup, MN_GETPPOPUPMENU, 0, 0L); ThreadUnlock(&tlpwndPrevPopup); #else pp = ((PMENUWND)ppopupmenu->spwndPrevPopup)->ppopupmenu; #endif } /* * Generate a WM_MENUSELECT for the previous menu to re-establish * it's current item as the SELECTED item */ ThreadLock(pp->spwndNotify, &tlpwndNotify); ThreadLock(pp->spwndPopupMenu, &tlpwndPopup); xxxSendMenuSelect(pp->spwndNotify, pp->spwndPopupMenu, pp->spmenu, pp->posSelectedItem); ThreadUnlock(&tlpwndPopup); ThreadUnlock(&tlpwndNotify); } return NULL; }

void xxxMNSetCapture (  PPOPUPMENU  ppopup  )

Definition at line 152 of file ntuser/kernel/menu.c. References tagMENUSTATE::fSetCapture, gpqForeground, tagTHREADINFO::pMenuState, tagTHREADINFO::pq, PtiCurrent, QF_CAPTURELOCKED, tagQ::QF_flags, SCREEN_CAPTURE, tagQ::spwndCapture, tagPOPUPMENU::spwndNotify, TRUE, and xxxCapture(). Referenced by xxxMenuWindowProc(), xxxMNEndMenuState(), xxxMNKeyDown(), and xxxMNStartMenu(). { PTHREADINFO ptiCurrent = PtiCurrent(); /* * Set the capture and lock it so no one will be able to steal it * from us. */ xxxCapture(ptiCurrent, ppopup->spwndNotify, SCREEN_CAPTURE); UserAssert (ptiCurrent->pq->spwndCapture == ppopup->spwndNotify); ptiCurrent->pq->QF_flags |= QF_CAPTURELOCKED; ptiCurrent->pMenuState->fSetCapture = TRUE; #if DBG /* * Unless we're in the foreground, this menu mode won't go away * when the user clicks outside the menu. This is because only * the foreground queue capture sees clicks outside its windows. */ if (ptiCurrent->pq != gpqForeground) { RIPMSG0(RIP_WARNING, "xxxMNSetCapture: Menu mode is not in foreground queue"); } #endif }

BOOL xxxMNSetTop (  PPOPUPMENU  ppopup, int  iNewTop )

Definition at line 495 of file ntuser/kernel/menu.c. References BOOL, tagMENU::cItems, tagITEM::cyItem, tagMENU::cyMax, tagMENU::cyMenu, tagMENU::dwArrowsOn, FALSE, tagMENU::hbrBack, tagMENU::iMaxTop, tagMENU::iTop, MFMWFP_DOWNARROW, MFMWFP_UPARROW, MNDrawArrow(), MNDrawFullNC(), MNGetToppItem(), MSA_ATBOTTOM, MSA_ATTOP, MSA_ON, NULL, tagMENU::rgItems, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndPopupMenu, TRUE, UINT, xxxInvalidateRect(), xxxScrollWindowEx(), and tagITEM::yItem. Referenced by xxxMNDoScroll(), and xxxMNInvertItem(). { PMENU pMenu = ppopup->spmenu; int dy; if (iNewTop < 0) { iNewTop = 0; } else if (iNewTop > pMenu->iMaxTop) { iNewTop = pMenu->iMaxTop; } /* * If no change, done */ if (iNewTop == pMenu->iTop) { return FALSE; } #if DBG /* * We're going to scroll, so validate iMaxTop, cyMax and cyMenu */ UserAssert((pMenu->cyMax == 0) || (pMenu->cyMax >= pMenu->cyMenu)); if ((UINT)pMenu->iMaxTop < pMenu->cItems) { PITEM pitemLast = pMenu->rgItems + pMenu->cItems - 1; PITEM pitemMaxTop = pMenu->rgItems + pMenu->iMaxTop; UINT uHeight = pitemLast->yItem + pitemLast->cyItem - pitemMaxTop->yItem; UserAssert(uHeight <= pMenu->cyMenu); /* * Let's guess a max item height */ UserAssert(pMenu->cyMenu - uHeight <= 2 * pitemLast->cyItem); } else { UserAssert((UINT)pMenu->iMaxTop < pMenu->cItems); } #endif /* * if we've made it this far, the new iTop WILL change -- thus if the * current iTop is at the top it won't be after this change -- same goes * for iTop at the bottom */ if (pMenu->dwArrowsOn == MSA_ATTOP) { pMenu->dwArrowsOn = MSA_ON; if (pMenu->hbrBack == NULL) { MNDrawArrow(NULL, ppopup, MFMWFP_UPARROW); } } else if (pMenu->dwArrowsOn == MSA_ATBOTTOM) { pMenu->dwArrowsOn = MSA_ON; if (pMenu->hbrBack == NULL) { MNDrawArrow(NULL, ppopup, MFMWFP_DOWNARROW); } } UserAssert((UINT)iNewTop < pMenu->cItems); dy = MNGetToppItem(pMenu)->yItem - (pMenu->rgItems + iNewTop)->yItem; if ((dy > 0 ? dy : -dy) > (int)pMenu->cyMenu) { xxxInvalidateRect(ppopup->spwndPopupMenu, NULL, TRUE); } else { xxxScrollWindowEx(ppopup->spwndPopupMenu, 0, dy, NULL, NULL, NULL, NULL, SW_INVALIDATE | SW_ERASE); } pMenu->iTop = iNewTop; if (iNewTop == 0) { pMenu->dwArrowsOn = MSA_ATTOP; if (pMenu->hbrBack == NULL) { MNDrawArrow(NULL, ppopup, MFMWFP_UPARROW); } } else if (iNewTop == pMenu->iMaxTop) { pMenu->dwArrowsOn = MSA_ATBOTTOM; if (pMenu->hbrBack == NULL) { MNDrawArrow(NULL, ppopup, MFMWFP_DOWNARROW); } } if (pMenu->hbrBack != NULL) { MNDrawFullNC(ppopup->spwndPopupMenu, NULL, ppopup); } return TRUE; }

BOOL xxxMNSwitchToAlternateMenu (  PPOPUPMENU  ppopupmenu  )

Definition at line 795 of file ntuser/kernel/menu.c. References BOOL, FALSE, tagPOPUPMENU::fDestroyed, tagPOPUPMENU::fIsMenuBar, tagMENUSTATE::fIsSysMenu, tagPOPUPMENU::fIsSysMenu, FWINABLE, GetpMenuState(), Lock, MFMWFP_NOITEM, MFSYSMENU, NULL, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagWND::spmenuSys, tagMENU::spwndNotify, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, TestMF, TestWF, ThreadLock, ThreadUnlock, TRUE, Unlock, WFSYSMENU, xxxMNSelectItem(), and xxxWindowEvent(). Referenced by xxxHandleMenuMessages(), xxxMNChar(), xxxMNKeyDown(), xxxMNKeyFilter(), and xxxMNMouseMove(). { PMENU pmenuSwap = NULL; PMENUSTATE pMenuState; TL tlpwndPopupMenu; if (!ppopupmenu->fIsMenuBar || !ppopupmenu->spmenuAlternate) { /* * Do nothing if no menu or not top level menu bar. * ppopupmenu->spmenuAlternate can be NULL when an app has * either system menu or menu bar but not both. If that menu * has only one popup that it's not dropped, then hitting * VK_RIGHT or VK_LEFT causes xxxMNKeyDown to end up here. * ppopupmenu->fIsMenuBar can be false when you drop the * system menu of an app with no menu bar; then hit VK_RIGHT * on an item that doesn't have a popup and you'll get here * There might be some other situations like this; in any case * the assertion got to go */ return FALSE; } /* * If we're getting out of menu mode, do nothing */ if (ppopupmenu->fDestroyed) { return FALSE; } /* * Select no items in the current menu. */ ThreadLock(ppopupmenu->spwndPopupMenu, &tlpwndPopupMenu); UserAssert(ppopupmenu->spwndPopupMenu != NULL); pMenuState = GetpMenuState(ppopupmenu->spwndPopupMenu); if (pMenuState == NULL) { RIPMSG0(RIP_ERROR, "xxxMNSwitchToAlternateMenu: pMenuState == NULL"); ThreadUnlock(&tlpwndPopupMenu); return FALSE; } xxxMNSelectItem(ppopupmenu, pMenuState, MFMWFP_NOITEM); UserAssert(ppopupmenu->spmenu->spwndNotify == ppopupmenu->spmenuAlternate->spwndNotify); Lock(&pmenuSwap, ppopupmenu->spmenuAlternate); Lock(&ppopupmenu->spmenuAlternate, ppopupmenu->spmenu); Lock(&ppopupmenu->spmenu, pmenuSwap); Unlock(&pmenuSwap); /* * Set this global because it is used in SendMenuSelect() */ if (!TestWF(ppopupmenu->spwndNotify, WFSYSMENU)) { pMenuState->fIsSysMenu = FALSE; } else if (ppopupmenu->spwndNotify->spmenuSys != NULL) { pMenuState->fIsSysMenu = (ppopupmenu->spwndNotify->spmenuSys == ppopupmenu->spmenu); } else { pMenuState->fIsSysMenu = !!TestMF(ppopupmenu->spmenu, MFSYSMENU); } ppopupmenu->fIsSysMenu = pMenuState->fIsSysMenu; if (FWINABLE()) { xxxWindowEvent(EVENT_SYSTEM_MENUEND, ppopupmenu->spwndNotify, (ppopupmenu->fIsSysMenu ? OBJID_MENU : OBJID_SYSMENU), INDEXID_CONTAINER, 0); xxxWindowEvent(EVENT_SYSTEM_MENUSTART, ppopupmenu->spwndNotify, (ppopupmenu->fIsSysMenu ? OBJID_SYSMENU : OBJID_MENU), INDEXID_CONTAINER, 0); } ThreadUnlock(&tlpwndPopupMenu); return TRUE; }

---