mnstate.c File Reference

#include "precomp.h"

Go to the source code of this file.

Functions
PMENU	xxxGetInitMenuParam (PWND pwndMenu, BOOL *lpfSystem)
void	MNPositionSysMenu (PWND pwnd, PMENU pmenusys)
void	MNFlushDestroyedPopups (PPOPUPMENU ppopupmenu, BOOL fUnlock)
PPOPUPMENU	MNAllocPopup (BOOL fForceAlloc)
VOID	MNFreePopup (PPOPUPMENU ppopupmenu)
BOOL	MNEndMenuStateNotify (PMENUSTATE pMenuState)
void	xxxMNEndMenuState (BOOL fFreePopup)
BOOL	MNCreateAnimationBitmap (PMENUSTATE pMenuState, UINT cx, UINT cy)
void	MNDestroyAnimationBitmap (PMENUSTATE pMenuState)
BOOL	MNSetupAnimationDC (PMENUSTATE pMenuState)
BOOL	xxxUnlockMenuState (PMENUSTATE pMenuState)
PMENUSTATE	xxxMNAllocMenuState (PTHREADINFO ptiCurrent, PTHREADINFO ptiNotify, PPOPUPMENU ppopupmenuRoot)
PMENUSTATE	xxxMNStartMenuState (PWND pwnd, DWORD cmd, LPARAM lParam)
BOOL	xxxMNStartMenu (PPOPUPMENU ppopupmenu, int mn)

---

Function Documentation

PPOPUPMENU MNAllocPopup (  BOOL  fForceAlloc  )

Definition at line 143 of file mnstate.c. References gpopupMenu, PUDF_POPUPINUSE, SET_PUDF, and TEST_PUDF. Referenced by xxxMenuWindowProc(), and xxxMNStartMenuState(). { PPOPUPMENU ppm; if (!fForceAlloc && !TEST_PUDF(PUDF_POPUPINUSE)) { SET_PUDF(PUDF_POPUPINUSE); ppm = &gpopupMenu; } else { ppm = (PPOPUPMENU)UserAllocPoolWithQuota(sizeof(POPUPMENU), TAG_POPUPMENU); } if (ppm) { RtlZeroMemory(ppm, sizeof(POPUPMENU)); } return (ppm); }

BOOL MNCreateAnimationBitmap (  PMENUSTATE  pMenuState, UINT  cx, UINT  cy )

Definition at line 389 of file mnstate.c. References BOOL, cy, FALSE, gpDispInfo, tagMENUSTATE::hbmAni, tagDISPLAYINFO::hdcScreen, NULL, and TRUE. Referenced by xxxMenuWindowProc(). { HBITMAP hbm = GreCreateCompatibleBitmap(gpDispInfo->hdcScreen, cx, cy); if (hbm == NULL) { RIPMSG0(RIP_WARNING, "MNSetupAnimationBitmap: Failed to create hbmAni"); return FALSE; } #if DBG if (pMenuState->hdcAni == NULL) { RIPMSG0(RIP_WARNING, "MNCreateAnimationBitmap: hdcAni is NULL"); } if (pMenuState->hbmAni != NULL) { RIPMSG0(RIP_WARNING, "MNCreateAnimationBitmap: hbmAni already exists"); } #endif GreSelectBitmap(pMenuState->hdcAni, hbm); pMenuState->hbmAni = hbm; return TRUE; }

void MNDestroyAnimationBitmap (  PMENUSTATE  pMenuState  )

Definition at line 414 of file mnstate.c. References tagMENUSTATE::hbmAni, and NULL. Referenced by MNAnimate(), and xxxMNEndMenuState(). { GreSelectBitmap(pMenuState->hdcAni, GreGetStockObject(PRIV_STOCK_BITMAP)); UserVerify(GreDeleteObject(pMenuState->hbmAni)); pMenuState->hbmAni = NULL; }

BOOL MNEndMenuStateNotify (  PMENUSTATE  pMenuState  )

Definition at line 234 of file mnstate.c. References BOOL, FALSE, GETPTI, NULL, tagMENUSTATE::pGlobalPopupMenu, tagTHREADINFO::pMenuState, tagMENUSTATE::pmnsPrev, tagMENUSTATE::ptiMenuStateOwner, tagPOPUPMENU::spwndNotify, and TRUE. Referenced by xxxDestroyWindow(), and xxxMNEndMenuState(). { PTHREADINFO ptiNotify; if (pMenuState->pGlobalPopupMenu->spwndNotify != NULL) { ptiNotify = GETPTI(pMenuState->pGlobalPopupMenu->spwndNotify); if (ptiNotify != pMenuState->ptiMenuStateOwner) { /* * Later5.0 GerardoB. xxxMNStartMenuState no longer allows this. * This is dead code that I'll remove eventually */ UserAssert(ptiNotify == pMenuState->ptiMenuStateOwner); UserAssert(ptiNotify->pMenuState == pMenuState); UserAssert(pMenuState->pmnsPrev == NULL); ptiNotify->pMenuState = NULL; return TRUE; } } return FALSE; }

void MNFlushDestroyedPopups (  PPOPUPMENU  ppopupmenu, BOOL  fUnlock )

Definition at line 91 of file mnstate.c. References FALSE, tagPOPUPMENU::fDelayedFree, tagPOPUPMENU::fDestroyed, IsRootPopupMenu(), MNFreePopup(), NULL, tagPOPUPMENU::ppmDelayedFree, and tagPOPUPMENU::ppopupmenuRoot. Referenced by MNFreePopup(), and xxxMNLoop(). { PPOPUPMENU ppmDestroyed, ppmFree; UserAssert(IsRootPopupMenu(ppopupmenu)); /* * Walk ppmDelayedFree */ ppmDestroyed = ppopupmenu; while (ppmDestroyed->ppmDelayedFree != NULL) { /* * If it's marked as destroyed, unlink it and free it */ if (ppmDestroyed->ppmDelayedFree->fDestroyed) { ppmFree = ppmDestroyed->ppmDelayedFree; ppmDestroyed->ppmDelayedFree = ppmFree->ppmDelayedFree; UserAssert(ppmFree != ppmFree->ppopupmenuRoot); MNFreePopup(ppmFree); } else { /* * fUnlock is TRUE if the root popup is being destroyed; if * so, reset fDelayedFree and unlink it */ if (fUnlock) { /* * This means that the root popup is going away before * some of the hierarchical popups have been destroyed. * This can happen if someone destroys one of the menu * windows breaking the spwndNextPopup chain. */ ppmDestroyed->ppmDelayedFree->fDelayedFree = FALSE; /* * Stop here so we can figure how this happened. */ UserAssert(ppmDestroyed->ppmDelayedFree->fDelayedFree); ppmDestroyed->ppmDelayedFree = ppmDestroyed->ppmDelayedFree->ppmDelayedFree; } else { /* * Not fDestroyed so move to the next one. */ ppmDestroyed = ppmDestroyed->ppmDelayedFree; } /* fUnlock */ } /* fDestroyed */ } /* while ppmDelayedFree */ }

VOID MNFreePopup (  PPOPUPMENU  ppopupmenu  )

Definition at line 165 of file mnstate.c. References CLEAR_PUDF, DF_MENUINUSE, tagDESKTOP::dwDTFlags, tagPOPUPMENU::fDesktopMenu, tagPOPUPMENU::fFreed, tagPOPUPMENU::fIsMenuBar, FNID_MENU, GETFNID, gpopupMenu, IsRootPopupMenu(), MNFlushDestroyedPopups(), NULL, tagPOPUPMENU::ppopupmenuRoot, PtiCurrent, PUDF_POPUPINUSE, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagPOPUPMENU::spwndActivePopup, tagDESKTOP::spwndMenu, tagPOPUPMENU::spwndNextPopup, tagPOPUPMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, tagPOPUPMENU::spwndPrevPopup, TEST_PUDF, TRUE, Unlock, UnlockPopupMenu(), Validateppopupmenu, and VOID(). Referenced by MNFlushDestroyedPopups(), xxxMNDestroyHandler(), xxxMNEndMenuState(), and xxxMNStartMenuState(). { Validateppopupmenu(ppopupmenu); if (IsRootPopupMenu(ppopupmenu)) { MNFlushDestroyedPopups (ppopupmenu, TRUE); } #if DBG /* * If this is not a cached menu and it corresponds to a menu window, * then the reference to the popup must be cleared at this point since * we're going to free this popup */ if (ppopupmenu->spwndPopupMenu != NULL) { if (!ppopupmenu->fDesktopMenu && !ppopupmenu->fIsMenuBar) { UserAssert(GETFNID(ppopupmenu->spwndPopupMenu) == FNID_MENU); UserAssert(((PMENUWND)ppopupmenu->spwndPopupMenu)->ppopupmenu == NULL); } } #endif Unlock(&ppopupmenu->spwndPopupMenu); /* * if spwndNextPopup is not NULL, we're breaking the chain and spwndNext won't * get closed. I won't remove the unlock since it has * always been there. */ UserAssert(ppopupmenu->spwndNextPopup == NULL); Unlock(&ppopupmenu->spwndNextPopup); Unlock(&ppopupmenu->spwndPrevPopup); UnlockPopupMenu(ppopupmenu, &ppopupmenu->spmenu); UnlockPopupMenu(ppopupmenu, &ppopupmenu->spmenuAlternate); Unlock(&ppopupmenu->spwndNotify); Unlock(&ppopupmenu->spwndActivePopup); #if DBG if (!ppopupmenu->fDesktopMenu) { ppopupmenu->fFreed = TRUE; } else { PDESKTOP pdesk = PtiCurrent()->rpdesk; UserAssert(pdesk->dwDTFlags & DF_MENUINUSE); UserAssert(((PMENUWND)pdesk->spwndMenu)->ppopupmenu == ppopupmenu); } #endif if (ppopupmenu->fDesktopMenu) { PtiCurrent()->rpdesk->dwDTFlags &= ~DF_MENUINUSE; /* The desktop menu window points to this popup so don't leave bogus stuff in it */ ppopupmenu->ppopupmenuRoot = NULL; } else if (ppopupmenu == &gpopupMenu) { UserAssert(TEST_PUDF(PUDF_POPUPINUSE)); CLEAR_PUDF(PUDF_POPUPINUSE); } else { UserFreePool(ppopupmenu); } }

void MNPositionSysMenu (  PWND  pwnd, PMENU  pmenusys )

Definition at line 25 of file mnstate.c. References tagMENU::cItems, tagITEM::cxItem, tagITEM::cyItem, FALSE, GetWindowBorders(), Lock, NULL, OffsetRect(), tagMENU::rgItems, tagMENU::spwndNotify, SYSMET, TestMF, TestWF, TRUE, WEFTOOLWINDOW, WFMINIMIZED, tagITEM::xItem, and tagITEM::yItem. Referenced by xxxMNInvertItem(), xxxMNKeyFilter(), xxxMNStartMenu(), and xxxSetSystemMenu(). { RECT rc; PITEM pItem; if (pmenusys == NULL) { RIPERR0(ERROR_INVALID_HANDLE, RIP_WARNING, "Invalid menu handle pmenusys (NULL) to MNPositionSysMenu"); return; } /* * Whoever positions the menu becomes the owner */ if (pwnd != pmenusys->spwndNotify) { Lock(&pmenusys->spwndNotify, pwnd); } /* * Setup the SysMenu hit rectangle. */ rc.top = rc.left = 0; if (TestWF(pwnd, WEFTOOLWINDOW)) { rc.right = SYSMET(CXSMSIZE); rc.bottom = SYSMET(CYSMSIZE); } else { rc.right = SYSMET(CXSIZE); rc.bottom = SYSMET(CYSIZE); } if (!TestWF(pwnd, WFMINIMIZED)) { int cBorders; cBorders = GetWindowBorders(pwnd->style, pwnd->ExStyle, TRUE, FALSE); OffsetRect(&rc, cBorders*SYSMET(CXBORDER), cBorders*SYSMET(CYBORDER)); } /* * Offset the System popup menu. */ if (!TestMF(pmenusys, MF_POPUP) && (pmenusys->cItems > 0)) { pItem = pmenusys->rgItems; if (pItem) { pItem->yItem = rc.top; pItem->xItem = rc.left; pItem->cyItem = rc.bottom - rc.top; pItem->cxItem = rc.right - rc.left; } } else // BOGUS -- MF_POPUP should never be set on a MENU -- only a MENU ITEM UserAssert(FALSE); }

BOOL MNSetupAnimationDC (  PMENUSTATE  pMenuState  )

Definition at line 425 of file mnstate.c. References BOOL, FALSE, ghMenuFont, gMenuState, gpDispInfo, tagDISPLAYINFO::hdcScreen, NULL, and TRUE. Referenced by FinalUserInit(), and xxxMNAllocMenuState(). { pMenuState->hdcAni = GreCreateCompatibleDC(gpDispInfo->hdcScreen); if (pMenuState->hdcAni == NULL) { RIPMSG0(RIP_WARNING, "MNSetupAnimationDC: Failed to create hdcAnimate"); UserAssert(pMenuState != &gMenuState); return FALSE; } GreSelectFont(pMenuState->hdcAni, ghMenuFont); return TRUE; }

PMENU xxxGetInitMenuParam (  PWND  pwndMenu, BOOL *  lpfSystem )

Definition at line 808 of file mnstate.c. References CheckLock, tagMENU::cItems, FALSE, NULL, tagWND::spmenu, TestWF, TestwndChild, TRUE, WFMINIMIZED, and xxxGetSysMenu(). Referenced by xxxMNStartMenu(). { // // Find out what menu we should be sending in WM_INITMENU: // If minimized/child/empty menubar, use system menu // CheckLock(pwndMenu); if (TestWF(pwndMenu, WFMINIMIZED) || TestwndChild(pwndMenu) || (pwndMenu->spmenu == NULL) || !pwndMenu->spmenu->cItems) { if (lpfSystem != NULL) *lpfSystem = TRUE; return(xxxGetSysMenu(pwndMenu, FALSE)); } else { if (lpfSystem != NULL) *lpfSystem = FALSE; return(pwndMenu->spmenu); } }

PMENUSTATE xxxMNAllocMenuState (  PTHREADINFO  ptiCurrent, PTHREADINFO  ptiNotify, PPOPUPMENU  ppopupmenuRoot )

Definition at line 458 of file mnstate.c. References BOOL, DBGIncModalMenuCount, gMenuState, IncSFWLockCount(), MENUANIDC, MENUSTATE, MNSetupAnimationDC(), NULL, PBYTE, tagMENUSTATE::pGlobalPopupMenu, tagTHREADINFO::pMenuState, tagMENUSTATE::pmnsPrev, PtiCurrent, tagMENUSTATE::ptiMenuStateOwner, PUDF_MENUSTATEINUSE, tagTHREADINFO::rpdesk, SET_PUDF, TEST_PUDF, TRUE, and xxxMNEndMenuState(). Referenced by xxxMNStartMenuState(), and xxxTrackPopupMenuEx(). { BOOL fAllocate; PMENUSTATE pMenuState; UserAssert(PtiCurrent() == ptiCurrent); UserAssert(ptiCurrent->rpdesk == ptiNotify->rpdesk); /* * If gMenuState is already taken, allocate one. */ fAllocate = TEST_PUDF(PUDF_MENUSTATEINUSE); if (fAllocate) { pMenuState = (PMENUSTATE)UserAllocPoolWithQuota(sizeof(MENUSTATE), TAG_MENUSTATE); if (pMenuState == NULL) { return NULL; } } else { /* * Use chache global which already has the animation DC setup */ SET_PUDF(PUDF_MENUSTATEINUSE); pMenuState = &gMenuState; UserAssert(gMenuState.hdcAni != NULL); GreSetDCOwner(gMenuState.hdcAni, OBJECT_OWNER_CURRENT); } /* * Prevent anyone from changing the foreground while this menu is active */ IncSFWLockCount(); DBGIncModalMenuCount(); /* * Initialize pMenuState. * Animation DC stuff is already setup so don't zero init it. */ RtlZeroMemory(pMenuState, sizeof(MENUSTATE) - sizeof(MENUANIDC)); pMenuState->pGlobalPopupMenu = ppopupmenuRoot; pMenuState->ptiMenuStateOwner = ptiCurrent; /* * Save previous state, if any. Then set new state */ pMenuState->pmnsPrev = ptiCurrent->pMenuState; ptiCurrent->pMenuState = pMenuState; if (ptiNotify != ptiCurrent) { UserAssert(ptiNotify->pMenuState == NULL); ptiNotify->pMenuState = pMenuState; } /* * If the menustate was allocated, set up animation stuff. * This is done here because in case of failure, MNEndMenuState * will find ptiCurrent->pMenuState properly. */ if (fAllocate) { RtlZeroMemory((PBYTE)pMenuState + sizeof(MENUSTATE) - sizeof(MENUANIDC), sizeof(MENUANIDC)); if (!MNSetupAnimationDC(pMenuState)) { xxxMNEndMenuState(TRUE); return NULL; } } return pMenuState; }

void xxxMNEndMenuState (  BOOL  fFreePopup  )

Definition at line 265 of file mnstate.c. References CLEAR_PUDF, DBGDecModalMenuCount, DecSFWLockCount(), DF_MENUINUSE, tagDESKTOP::dwDTFlags, tagMENUSTATE::dwLockCount, FALSE, tagPOPUPMENU::fDelayedFree, tagPOPUPMENU::fDestroyed, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fIsTrackPopup, tagMENUSTATE::fModelessMenu, GetpMenuState(), GETPTI, gMenuState, tagMENUSTATE::hbmAni, MNDestroyAnimationBitmap(), MNEndMenuStateNotify(), MNFreePopup(), NULL, tagMENUSTATE::pGlobalPopupMenu, tagTHREADINFO::pMenuState, tagMENUSTATE::pmnsPrev, PtiCurrent, tagDESKTOP::PtiList, tagMENUSTATE::ptiMenuStateOwner, PUDF_MENUSTATEINUSE, tagTHREADINFO::rpdesk, tagPOPUPMENU::spwndActivePopup, tagDESKTOP::spwndMenu, TEST_PUDF, tagMENUSTATE::uButtonDownHitArea, tagMENUSTATE::uDraggingHitArea, UnlockMFMWFPWindow(), xxxActivateThisWindow(), and xxxMNSetCapture(). Referenced by xxxCallHandleMenuMessages(), xxxDestroyThreadInfo(), xxxMenuWindowProc(), xxxMNAllocMenuState(), xxxSysCommand(), xxxTrackPopupMenuEx(), and xxxUnlockMenuState(). { PTHREADINFO ptiCurrent = PtiCurrent(); PMENUSTATE pMenuState; pMenuState = ptiCurrent->pMenuState; UserAssert(ptiCurrent->pMenuState != NULL); UserAssert(ptiCurrent == pMenuState->ptiMenuStateOwner); /* * If the menu is locked, someone doesn't want it to go just yet. */ if (pMenuState->dwLockCount != 0) { RIPMSG1(RIP_WARNING, "xxxMNEndMenuState Locked:%#p", pMenuState); return; } MNEndMenuStateNotify(pMenuState); /* * pMenuState->pGlobalPopupMenu could be NULL if xxxMNAllocMenuState failed */ if (pMenuState->pGlobalPopupMenu != NULL) { if (fFreePopup) { UserAssert(pMenuState->pGlobalPopupMenu->fIsMenuBar || pMenuState->pGlobalPopupMenu->fDestroyed); MNFreePopup(pMenuState->pGlobalPopupMenu); } else { /* * This means that we're ending the menustate but the popup menu * window is still around. This can happen when called from * xxxDestroyThreadInfo. */ UserAssert(pMenuState->pGlobalPopupMenu->fIsTrackPopup); pMenuState->pGlobalPopupMenu->fDelayedFree = FALSE; } } /* * Unlock MFMWFP windows. */ UnlockMFMWFPWindow(&pMenuState->uButtonDownHitArea); UnlockMFMWFPWindow(&pMenuState->uDraggingHitArea); /* * Restore the previous state, if any */ ptiCurrent->pMenuState = pMenuState->pmnsPrev; /* * This (modal) menu mode is off */ if (!pMenuState->fModelessMenu) { DecSFWLockCount(); DBGDecModalMenuCount(); } if (pMenuState->hbmAni != NULL) { MNDestroyAnimationBitmap(pMenuState); } /* * Free the menu state */ if (pMenuState == &gMenuState) { UserAssert(TEST_PUDF(PUDF_MENUSTATEINUSE)); CLEAR_PUDF(PUDF_MENUSTATEINUSE); GreSetDCOwner(gMenuState.hdcAni, OBJECT_OWNER_PUBLIC); } else { if (pMenuState->hdcAni != NULL) { GreDeleteDC(pMenuState->hdcAni); } UserFreePool(pMenuState); } /* * If returning to a modeless menu, make sure have activation * If returning to a modal menu, make sure we have capture */ if (ptiCurrent->pMenuState != NULL) { if (ptiCurrent->pMenuState->fModelessMenu) { xxxActivateThisWindow(ptiCurrent->pMenuState->pGlobalPopupMenu->spwndActivePopup, 0, 0); } else { xxxMNSetCapture(ptiCurrent->pMenuState->pGlobalPopupMenu); } } #if DBG /* * If this thread is not in menu mode anymore, it must not be using * the desktop menu */ if ((ptiCurrent->pMenuState == NULL) && (ptiCurrent->rpdesk->spwndMenu != NULL)) { UserAssert(ptiCurrent != GETPTI(ptiCurrent->rpdesk->spwndMenu)); } /* * If someone is using the menu window, it must be in menu mode */ if (ptiCurrent->rpdesk->dwDTFlags & DF_MENUINUSE) { UserAssert(GetpMenuState(ptiCurrent->rpdesk->spwndMenu) != NULL); } /* * No pti should point to this pMenuState anymore * If guModalMenuStateCount is zero, all pMenuState must be NULL or modeless */ { PLIST_ENTRY pHead, pEntry; PTHREADINFO ptiT; pHead = &(ptiCurrent->rpdesk->PtiList); for (pEntry = pHead->Flink; pEntry != pHead; pEntry = pEntry->Flink) { ptiT = CONTAINING_RECORD(pEntry, THREADINFO, PtiLink); UserAssert(ptiT->pMenuState != pMenuState); if (guModalMenuStateCount == 0) { UserAssert(ptiT->pMenuState == NULL || ptiT->pMenuState->fModelessMenu); } } } #endif }

BOOL xxxMNStartMenu (  PPOPUPMENU  ppopupmenu, int  mn )

Definition at line 677 of file mnstate.c. References _GetKeyState(), BOOL, FALSE, tagMENUSTATE::fAutoDismiss, tagMENUSTATE::fButtonAlwaysDown, tagMENUSTATE::fButtonDown, tagPOPUPMENU::fDestroyed, tagMENUSTATE::fDragAndDrop, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fIsSysMenu, tagMENUSTATE::fIsSysMenu, tagPOPUPMENU::fIsTrackPopup, tagMENUSTATE::fMenuStarted, tagMENUSTATE::fModelessMenu, tagPOPUPMENU::fNoNotify, tagMENUSTATE::fNotifyByPos, FWINABLE, GetpMenuState(), HWq, IsRootPopupMenu(), L, LockPopupMenu(), tagMENUSTATE::mnFocus, MNPositionSysMenu(), NT_SUCCESS, NULL, PtoH, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagPOPUPMENU::spwndNotify, TestMF, ThreadLock, ThreadUnlock, TRUE, xxxClientLoadOLE(), xxxGetInitMenuParam(), xxxGetSysMenu(), xxxMNRecomputeBarIfNeeded(), xxxMNReleaseCapture(), xxxMNSetCapture(), xxxSendMessage(), and xxxWindowEvent(). Referenced by xxxMNKeyFilter(), xxxMNLoop(), and xxxTrackPopupMenuEx(). { PWND pwndMenu; PMENU pMenu; PMENUSTATE pMenuState; TL tlpwndMenu; TL tlpmenu; UserAssert(IsRootPopupMenu(ppopupmenu)); if (ppopupmenu->fDestroyed) { return FALSE; } pwndMenu = ppopupmenu->spwndNotify; ThreadLock(pwndMenu, &tlpwndMenu); pMenuState = GetpMenuState(pwndMenu); if (pMenuState == NULL) { RIPMSG0(RIP_ERROR, "xxxMNStartMenu: pMenuState == NULL"); ThreadUnlock(&tlpwndMenu); return FALSE; } pMenuState->mnFocus = mn; pMenuState->fMenuStarted = TRUE; pMenuState->fButtonDown = pMenuState->fButtonAlwaysDown = ((_GetKeyState(VK_LBUTTON) & 0x8000) != 0); xxxMNSetCapture(ppopupmenu); xxxSendMessage(pwndMenu, WM_SETCURSOR, (WPARAM)HWq(pwndMenu), MAKELONG(MSGF_MENU, 0)); if (ppopupmenu->fIsMenuBar) { BOOL fSystemMenu; pMenu = xxxGetInitMenuParam(pwndMenu, &fSystemMenu); if (pMenu == NULL) { pMenuState->fMenuStarted = FALSE; xxxMNReleaseCapture(); ThreadUnlock(&tlpwndMenu); return(FALSE); } LockPopupMenu(ppopupmenu, &ppopupmenu->spmenu, pMenu); ppopupmenu->fIsSysMenu = (fSystemMenu != 0); if (!fSystemMenu) { pMenu = xxxGetSysMenu(pwndMenu, FALSE); LockPopupMenu(ppopupmenu, &ppopupmenu->spmenuAlternate, pMenu); } } pMenuState->fIsSysMenu = (ppopupmenu->fIsSysMenu != 0); if (!ppopupmenu->fNoNotify) { if (ppopupmenu->fIsTrackPopup && ppopupmenu->fIsSysMenu) { pMenu = xxxGetInitMenuParam(pwndMenu, NULL); } else { pMenu = ppopupmenu->spmenu; } xxxSendMessage(pwndMenu, WM_INITMENU, (WPARAM)PtoH(pMenu), 0L); } if (!ppopupmenu->fIsTrackPopup) { if (ppopupmenu->fIsSysMenu) { MNPositionSysMenu(pwndMenu, ppopupmenu->spmenu); } else if (ppopupmenu->fIsMenuBar) { ThreadLock(ppopupmenu->spmenu, &tlpmenu); xxxMNRecomputeBarIfNeeded(pwndMenu, ppopupmenu->spmenu); ThreadUnlock(&tlpmenu); MNPositionSysMenu(pwndMenu, ppopupmenu->spmenuAlternate); } } /* * If returning TRUE, set menu style in pMenuState */ if (!ppopupmenu->fDestroyed) { if (TestMF(ppopupmenu->spmenu, MNS_MODELESS)) { pMenuState->fModelessMenu = TRUE; } if (TestMF(ppopupmenu->spmenu, MNS_DRAGDROP)) { if (NT_SUCCESS(xxxClientLoadOLE())) { pMenuState->fDragAndDrop = TRUE; } } if (TestMF(ppopupmenu->spmenu, MNS_AUTODISMISS)) { pMenuState->fAutoDismiss = TRUE; } if (TestMF(ppopupmenu->spmenu, MNS_NOTIFYBYPOS)) { pMenuState->fNotifyByPos = TRUE; } } /* * Bogus! We don't always know that this is the system menu. We * will frequently pass on an OBJID_MENU even when you hit Alt+Space. * * Hence, MNSwitchToAlternate will send a EVENT_SYSTEM_MENUEND for the * menu bar and an EVENT_SYSTEM_MENUSTART for the sysmenu when we "switch". */ if (FWINABLE()) { xxxWindowEvent(EVENT_SYSTEM_MENUSTART, pwndMenu, (ppopupmenu->fIsSysMenu ? OBJID_SYSMENU : (ppopupmenu->fIsMenuBar ? OBJID_MENU : OBJID_WINDOW)), INDEXID_CONTAINER, 0); } ThreadUnlock(&tlpwndMenu); return !ppopupmenu->fDestroyed; }

PMENUSTATE xxxMNStartMenuState (  PWND  pwnd, DWORD  cmd, LPARAM  lParam )

Definition at line 540 of file mnstate.c. References _PostMessage(), CheckLock, FALSE, tagPOPUPMENU::fHasMenuBar, tagPOPUPMENU::fIsMenuBar, tagPOPUPMENU::fRtoL, GETPTI, L, Lock, MFMWFP_NOITEM, MFRTL, MNAllocPopup(), MNFreePopup(), NULL, tagTHREADINFO::pMenuState, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::ppopupmenuRoot, PtiCurrent, tagWND::spmenu, tagPOPUPMENU::spwndNotify, tagWND::spwndParent, tagPOPUPMENU::spwndPopupMenu, TestMF, TestWF, TestwndChild, ThreadLockAlways, ThreadUnlock, TRUE, WEFRTLREADING, WFSYSMENU, xxxMNAllocMenuState(), and xxxSendMessage(). Referenced by xxxSysCommand(). { PPOPUPMENU ppopupmenu; PTHREADINFO ptiCurrent, ptiNotify; PMENUSTATE pMenuState; TL tlpwnd; PWND pwndT; CheckLock(pwnd); /* * Bail if the current thread is already in menu mode */ ptiCurrent = PtiCurrent(); if (ptiCurrent->pMenuState != NULL) { return NULL; } /* * If pwnd is not owned by ptiCurrent, the _PostMessage call below might * send us in a loop */ UserAssert(ptiCurrent == GETPTI(pwnd)); /* * If this is not a child window, use the active window on its queue */ if (!TestwndChild(pwnd)) { pwnd = GETPTI(pwnd)->pq->spwndActive; } else { /* * Search up the parents for a window with a System Menu. */ while (TestwndChild(pwnd)) { if (TestWF(pwnd, WFSYSMENU)) { break; } pwnd = pwnd->spwndParent; } } if (pwnd == NULL) { return NULL; } if (!TestwndChild(pwnd) && (pwnd->spmenu != NULL)) { goto hasmenu; } if (!TestWF(pwnd, WFSYSMENU)) { return NULL; } hasmenu: /* * If the owner/notification window was created by another thread, * make sure that it's not in menu mode already * This can happen if PtiCurrent() is attached to other threads, one of * which created pwnd. */ ptiNotify = GETPTI(pwnd); if (ptiNotify->pMenuState != NULL) { return NULL; } /* * If the notification window is owned by another thread, * then the menu loop wouldn't get any keyboard or mouse * messages because we set capture to the notification window. * So we pass the WM_SYSCOMMAND to that thread and bail */ if (ptiNotify != ptiCurrent) { RIPMSG2(RIP_WARNING, "Passing WM_SYSCOMMAND SC_*MENU from thread %#p to %#p", ptiCurrent, ptiNotify); _PostMessage(pwnd, WM_SYSCOMMAND, cmd, lParam); return NULL; } /* * Allocate ppoupmenu and pMenuState */ ppopupmenu = MNAllocPopup(FALSE); if (ppopupmenu == NULL) { return NULL; } pMenuState = xxxMNAllocMenuState(ptiCurrent, ptiNotify, ppopupmenu); if (pMenuState == NULL) { MNFreePopup(ppopupmenu); return NULL; } ppopupmenu->fIsMenuBar = TRUE; ppopupmenu->fHasMenuBar = TRUE; Lock(&(ppopupmenu->spwndNotify), pwnd); ppopupmenu->posSelectedItem = MFMWFP_NOITEM; Lock(&(ppopupmenu->spwndPopupMenu), pwnd); ppopupmenu->ppopupmenuRoot = ppopupmenu; pwndT = pwnd; while( TestwndChild(pwndT) ) pwndT = pwndT->spwndParent; if (pwndT->spmenu) ppopupmenu->fRtoL = TestMF(pwndT->spmenu, MFRTL) ?TRUE:FALSE; else { // // no way to know, no menu, but there is a system menu. Thus arrow // keys are really not important. however lets take the next best // thing just to be safe // ppopupmenu->fRtoL = TestWF(pwnd, WEFRTLREADING) ?TRUE :FALSE; } /* * Notify the app we are entering menu mode. wParam is always 0 since this * procedure will only be called for menu bar menus not TrackPopupMenu * menus. */ ThreadLockAlways(pwnd, &tlpwnd); xxxSendMessage(pwnd, WM_ENTERMENULOOP, 0, 0L); ThreadUnlock(&tlpwnd); return pMenuState; }

BOOL xxxUnlockMenuState (  PMENUSTATE  pMenuState  )

Definition at line 441 of file mnstate.c. References BOOL, tagMENUSTATE::dwLockCount, ExitMenuLoop(), FALSE, tagMENUSTATE::pGlobalPopupMenu, TRUE, and xxxMNEndMenuState(). Referenced by xxxMenuWindowProc(), xxxMNDragLeave(), and xxxMNDragOver(). { UserAssert(pMenuState->dwLockCount != 0); (pMenuState->dwLockCount)--; if ((pMenuState->dwLockCount == 0) && ExitMenuLoop(pMenuState, pMenuState->pGlobalPopupMenu)) { xxxMNEndMenuState(TRUE); return TRUE; } return FALSE; }

---