mnsys.c File Reference

#include "precomp.h"

Go to the source code of this file.

Functions
void	_SetCloseDefault (PMENU pSubMenu)
PWND	FindFakeMDIChild (PWND pwndParent)
PMENU	xxxLoadSysDesktopMenu (PMENU *ppmenu, UINT uMenuId)
PVOID	LockDesktopMenu (PMENU *ppmenu, PMENU pmenu)
PVOID	UnlockDesktopMenu (PMENU *ppmenu)
PMENU	xxxGetSysMenuHandle (PWND pwnd)
PMENU	xxxGetSysMenu (PWND pwnd, BOOL fSubMenu)
BOOL	IsSmallerThanScreen (PWND pwnd)
void	xxxSetSysMenu (PWND pwnd)
PMENU	xxxGetSystemMenu (PWND pwnd, BOOL fRevert)
DWORD	MenuItemState (PMENU pMenu, UINT wCmd, DWORD wFlags, DWORD wMask, PMENU *ppMenu)
DWORD	xxxEnableMenuItem (PMENU pMenu, UINT wIDEnableItem, UINT wEnable)
DWORD	_CheckMenuItem (PMENU pMenu, UINT wIDCheckItem, UINT wCheck)
BOOL	_SetMenuDefaultItem (PMENU pMenu, UINT wID, BOOL fByPosition)
void	SetupFakeMDIAppStuff (PMENU lpMenu, PITEM lpItem)

---

Function Documentation

DWORD _CheckMenuItem (  PMENU  pMenu, UINT  wIDCheckItem, UINT  wCheck )

Definition at line 546 of file mnsys.c. References DWORD, MenuItemState(), NULL, and UINT. Referenced by NtUserCheckMenuItem(). { return MenuItemState(pMenu, wIDCheckItem, wCheck, (UINT)MF_CHECKED, NULL); }

void _SetCloseDefault (  PMENU  pSubMenu  )

Definition at line 654 of file mnsys.c. References _SetMenuDefaultItem(). Referenced by SetupFakeMDIAppStuff(), and xxxSetSysMenu(). { if (!_SetMenuDefaultItem(pSubMenu, SC_CLOSE, MF_BYCOMMAND)) { // // Bloody hell. Let's try a couple other values. // * Project -- 0x7000 less // * FoxPro -- 0xC070 // if (!_SetMenuDefaultItem(pSubMenu, SC_CLOSE - 0x7000, MF_BYCOMMAND)) _SetMenuDefaultItem(pSubMenu, 0xC070, MF_BYCOMMAND); } }

BOOL _SetMenuDefaultItem (  PMENU  pMenu, UINT  wID, BOOL  fByPosition )

Definition at line 567 of file mnsys.c. References BOOL, tagMENU::cItems, ClearMFS, FALSE, MFMWFP_NOITEM, MNLookUpItem(), NULL, tagMENU::rgItems, SetMFS, TestMFS, TestMFT, TRUE, UINT, tagITEM::ulWidth, tagITEM::ulX, and UNDERLINE_RECALC. Referenced by _SetCloseDefault(), NtUserSetMenuDefaultItem(), xxxDefWindowProc(), and xxxSetSysMenu(). { UINT iItem; UINT cItems; PITEM pItem; PITEM pItemFound; PMENU pMenuFound; // // We need to check if wId actually exists on this menu. 0xFFFF means // clear all default items. // if (wID != MFMWFP_NOITEM) { pItemFound = MNLookUpItem(pMenu, wID, fByPosition, &pMenuFound); // item must be on same menu and can't be a separator if ((pItemFound == NULL) || (pMenuFound != pMenu) || TestMFT(pItemFound, MFT_SEPARATOR)) return(FALSE); } else pItemFound = NULL; pItem = pMenu->rgItems; cItems = pMenu->cItems; // Walk the menu list, clearing MFS_DEFAULT from all other items, and // setting MFS_DEFAULT on the requested one. for (iItem = 0; iItem < cItems; iItem++, pItem++) { // // Note we don't change the state of lpItemFound if it exists. This // is so that below, where we try to set the default, we can tell // if we need to recalculate the underline. // if (TestMFS(pItem, MFS_DEFAULT) && (pItem != pItemFound)) { // // We are changing the default item. As such, it will be drawn // with a different font than the one used to calculate it, if // the menu has already been drawn once. We need to ensure // that the underline gets drawn in the right place the next // time the menu comes up. Cause it to recalculate. // // We do NOT do this if the item // (a) isn't default--otherwise we'll recalculate the // underline for every system menu item every time we go into // menu mode because sysmenu init will call SetMenuDefaultItem. // (b) isn't the item we're going to set as the default. // That way we don't recalculate the underline when the item // isn't changing state. // ClearMFS(pItem, MFS_DEFAULT); pItem->ulX = UNDERLINE_RECALC; pItem->ulWidth = 0; } } if (wID != MFMWFP_NOITEM) { if (!TestMFS(pItemFound, MFS_DEFAULT)) { // // We are changing from non-default to default. Clear out // the underline info. If the menu has never painted, this // won't do anything. But it matters a lot if it has. // SetMFS(pItemFound, MFS_DEFAULT); pItemFound->ulX = UNDERLINE_RECALC; pItemFound->ulWidth = 0; } } return(TRUE); }

PWND FindFakeMDIChild (  PWND  pwndParent  )

Definition at line 678 of file mnsys.c. References NULL, tagWND::spmenuSys, tagWND::spwndChild, tagWND::spwndNext, TestWF, WFCHILD, WFMAXIMIZED, and WFVISIBLE. Referenced by SetupFakeMDIAppStuff(). { PWND pwndReturn; // Skip invisible windows and their descendants if (!TestWF(pwnd, WFVISIBLE)) return(NULL); // Did we hit pay dirt? if (TestWF(pwnd, WFCHILD) && (TestWF(pwnd, WFMAXIMIZED) || (pwnd->spmenuSys))) return(pwnd); // Check our children for (pwnd = pwnd->spwndChild; pwnd; pwnd = pwnd->spwndNext) { pwndReturn = FindFakeMDIChild(pwnd); if (pwndReturn) return(pwndReturn); } return(NULL); }

BOOL IsSmallerThanScreen (  PWND  pwnd  )

Definition at line 208 of file mnsys.c. References _MonitorFromWindow(), BOOL, FALSE, tagWND::rcWindow, tagMONITOR::rcWork, and TRUE. Referenced by xxxSetSysMenu(), and zzzChangeStates(). { int dxMax, dyMax; PMONITOR pMonitor; pMonitor = _MonitorFromWindow(pwnd, MONITOR_DEFAULTTOPRIMARY); dxMax = pMonitor->rcWork.right - pMonitor->rcWork.left; dyMax = pMonitor->rcWork.bottom - pMonitor->rcWork.top; if ((pwnd->rcWindow.right - pwnd->rcWindow.left < dxMax) || (pwnd->rcWindow.bottom - pwnd->rcWindow.top < dyMax)) { return TRUE; } return FALSE; }

PVOID LockDesktopMenu (  PMENU *  ppmenu, PMENU  pmenu )

Definition at line 74 of file mnsys.c. References tagMENU::cItems, HMChangeOwnerProcess, Lock, MFDESKTOP, NULL, PtiCurrent, tagMENU::rgItems, SetMF, tagITEM::spSubMenu, and UINT. Referenced by xxxGetScrollMenu(), and xxxLoadSysDesktopMenu(). { PMENU pSubMenu; PTHREADINFO ptiDesktop; /* * We only load desktop sys menus once. */ UserAssert(*ppmenu == NULL); if (pmenu == NULL) { return NULL; } SetMF(pmenu, MFDESKTOP); /* * This is awful but this is the real owner of this object. We used to set it * to NULL but that was forcing us to handle the NULL owner all over the place */ ptiDesktop = PtiCurrent()->rpdesk->rpwinstaParent->pTerm->ptiDesktop; HMChangeOwnerProcess(pmenu, ptiDesktop); pSubMenu = pmenu->rgItems->spSubMenu; UserAssert(pSubMenu != NULL); SetMF(pSubMenu, MFDESKTOP); HMChangeOwnerProcess(pSubMenu, ptiDesktop); #if DBG { /* * Assert that there are no other submenus that would need to be * marked as MFDESKTOP. */ PITEM pitem; UINT uItems; UserAssert(pmenu->cItems == 1); pitem = pSubMenu->rgItems; uItems = pSubMenu->cItems; while (uItems--) { UserAssert(pitem->spSubMenu == NULL); pitem++; } } #endif return Lock(ppmenu, pmenu); }

DWORD MenuItemState (  PMENU  pMenu, UINT  wCmd, DWORD  wFlags, DWORD  wMask, PMENU *  ppMenu )

Definition at line 455 of file mnsys.c. References BOOL, DWORD, tagITEM::fState, MNLookUpItem(), and NULL. Referenced by _CheckMenuItem(), and xxxEnableMenuItem(). { PITEM pItem; DWORD wRet; /* * Get a pointer the the menu item */ if ((pItem = MNLookUpItem(pMenu, wCmd, (BOOL) (wFlags & MF_BYPOSITION), ppMenu)) == NULL) return (DWORD)-1; /* * Return previous state */ wRet = pItem->fState & wMask; /* * Set new state */ pItem->fState ^= ((wRet ^ wFlags) & wMask); return wRet; }

void SetupFakeMDIAppStuff (  PMENU  lpMenu, PITEM  lpItem )

Definition at line 724 of file mnsys.c. References _GetMenuDefaultItem(), _SetCloseDefault(), tagITEM::dwItemData, FindFakeMDIChild(), HWq, L, tagITEM::spSubMenu, tagMENU::spwndNotify, TestWF, TRUE, and WFWIN40COMPAT. Referenced by xxxRealDrawMenuItem(). { PMENU pSubMenu; PWND pwndParent; PWND pwndChild; if (!(pSubMenu = lpItem->spSubMenu)) return; pwndParent = lpMenu->spwndNotify; // // Set up the default menu item. Project and FoxPro renumber their // IDs so we do some special stuff for them, among others. // if (!TestWF(pwndParent, WFWIN40COMPAT)) { if (_GetMenuDefaultItem(pSubMenu, TRUE, GMDI_USEDISABLED) == -1L) _SetCloseDefault(pSubMenu); } // // Don't touch the HIWORD if we don't find an HWND. That way apps // like Excel which have starting-up maxed children can benefit a little. // The first time the menu bar is redrawn, the child isn't visible/ // around (they add the item too early). But if it redraws later, or // you max a child, the icon will kick in. // if (pwndChild = FindFakeMDIChild(pwndParent)) { lpItem->dwItemData = (ULONG_PTR)HWq(pwndChild); // lpItem->dwTypeData = MAKELONG(LOWORD(lpItem->dwTypeData), HW16(hwndChild)); } }

PVOID UnlockDesktopMenu (  PMENU *  ppmenu  )

Definition at line 124 of file mnsys.c. References ClearMF, MFDESKTOP, NULL, TestMF, and Unlock. Referenced by xxxDesktopThread(). { UserAssert(*ppmenu != NULL); UserAssert(TestMF(*ppmenu, MFDESKTOP)); ClearMF(*ppmenu, MFDESKTOP); UserAssert(TestMF((*ppmenu)->rgItems->spSubMenu, MFDESKTOP)); ClearMF((*ppmenu)->rgItems->spSubMenu, MFDESKTOP); return Unlock(ppmenu); }

DWORD xxxEnableMenuItem (  PMENU  pMenu, UINT  wIDEnableItem, UINT  wEnable )

Definition at line 494 of file mnsys.c. References CheckLock, DWORD, MenuItemState(), MFAPPSYSMENU, MNGetPopupFromMenu(), MNUS_DEFAULT, NULL, tagMENU::spwndNotify, TestMF, ThreadLock, ThreadUnlock, xxxMNUpdateShownMenu(), and xxxRedrawTitle(). Referenced by NtUserEnableMenuItem(), and xxxSetSysMenu(). { DWORD dres; PMENU pRealMenu; PPOPUPMENU ppopup; CheckLock(pMenu); dres = MenuItemState(pMenu, wIDEnableItem, wEnable, MFS_GRAYED, &pRealMenu); /* * If enabling/disabling a system menu item, redraw the caption buttons */ if (TestMF(pMenu, MFAPPSYSMENU) && (pMenu->spwndNotify != NULL)) { TL tlpwnd; switch (wIDEnableItem) { case SC_SIZE: case SC_MOVE: case SC_MINIMIZE: case SC_MAXIMIZE: case SC_CLOSE: case SC_RESTORE: ThreadLock(pMenu->spwndNotify, &tlpwnd); xxxRedrawTitle(pMenu->spwndNotify, DC_BUTTONS); ThreadUnlock(&tlpwnd); } } /* 367162: If the menu is already being displayed we need to redraw it */ if(pRealMenu && (ppopup = MNGetPopupFromMenu(pRealMenu, NULL))){ xxxMNUpdateShownMenu(ppopup, NULL, MNUS_DEFAULT); } return dres; }

PMENU xxxGetSysMenu (  PWND  pwnd, BOOL  fSubMenu )

Definition at line 189 of file mnsys.c. References _GetSubMenu(), CheckLock, NULL, xxxGetSysMenuHandle(), and xxxSetSysMenu(). Referenced by xxxDefWindowProc(), xxxDWP_NCMouse(), xxxDWP_SetCursor(), xxxGetInitMenuParam(), xxxGetMenuBarInfo(), and xxxMNStartMenu(). { PMENU pMenu; CheckLock(pwnd); xxxSetSysMenu(pwnd); if ((pMenu = xxxGetSysMenuHandle(pwnd)) != NULL) { if (fSubMenu) pMenu = _GetSubMenu(pMenu, 0); } return(pMenu); }

PMENU xxxGetSysMenuHandle (  PWND  pwnd  )

Definition at line 142 of file mnsys.c. References CheckLock, tagWND::head, HWq, ID_SYSMENU, NtUserCallHwndLock(), NULL, PtiCurrent, tagWND::spmenuSys, TestWF, TIF_INCLEANUP, TIF_SYSTEMTHREAD, WFSYSMENU, and xxxLoadSysDesktopMenu(). Referenced by xxxGetSysMenu(), xxxHandleNCMouseGuys(), xxxMNCanClose(), xxxMNInvertItem(), xxxMNLoop(), and xxxSetSysMenu(). { PMENU pMenu; CheckLock(pwnd); if (TestWF(pwnd, WFSYSMENU)) { pMenu = pwnd->spmenuSys; /* * If the window doesn't have a System Menu, use the default one. */ if (pMenu == NULL) { /* * Grab the menu from the desktop. If the desktop menu * has not been loaded and this is not a system thread, * load it now. Callbacks cannot be made from a system * thread or when a thread is in cleanup. */ pMenu = pwnd->head.rpdesk->spmenuSys; /* * Do not do callbacks if the thread is exiting. We ran into this when * destroying a thread's window and the window it was promoting to * foreground was a hard error popup. */ if (pMenu == NULL && !(PtiCurrent()->TIF_flags & (TIF_SYSTEMTHREAD | TIF_INCLEANUP))) { pMenu = xxxLoadSysDesktopMenu (&pwnd->head.rpdesk->spmenuSys, ID_SYSMENU); } } } else { pMenu = NULL; } return pMenu; }

PMENU xxxGetSystemMenu (  PWND  pwnd, BOOL  fRevert )

Definition at line 368 of file mnsys.c. References _DestroyMenu(), _GetSubMenu(), CheckLock, tagPOPUPMENU::fIsSysMenu, tagPOPUPMENU::fIsTrackPopup, GetpGlobalPopupMenu(), ID_DIALOGSYSMENU, ID_SYSMENU, Lock, LockWndMenu(), MFAPPSYSMENU, MFSYSMENU, NULL, SetMF, tagPOPUPMENU::spmenu, tagPOPUPMENU::spmenuAlternate, tagWND::spmenuSys, tagPOPUPMENU::spwndNotify, tagMENU::spwndNotify, tagPOPUPMENU::spwndPopupMenu, TestMF, TestWF, UINT, UnlockWndMenu(), WFSYSMENU, and xxxLoadSysMenu(). Referenced by NtUserGetSystemMenu(), and xxxCreateWindowEx(). { PMENU pmenu; CheckLock(pwnd); /* * Should we start with a fresh copy? */ pmenu = pwnd->spmenuSys; if (fRevert) { /* * Destroy the old system menu. */ if ((pmenu != NULL) && !TestMF(pmenu, MFSYSMENU)) { if (UnlockWndMenu(pwnd, &pwnd->spmenuSys)) { _DestroyMenu(pmenu); } } } else { /* * Do we need to load a new system menu? */ if (((pmenu == NULL) || TestMF(pmenu, MFSYSMENU)) && TestWF(pwnd, WFSYSMENU)) { PPOPUPMENU pGlobalPopupMenu; UINT uMenuId = (pwnd->spmenuSys == NULL ? ID_SYSMENU : ID_DIALOGSYSMENU); pmenu = xxxLoadSysMenu(uMenuId); if (pmenu == NULL) { RIPMSG1(RIP_WARNING, "_GetSystemMenu: xxxLoadSysMenu Failed. pwnd:%#p", pwnd); } LockWndMenu(pwnd, &pwnd->spmenuSys, pmenu); pmenu = pwnd->spmenuSys; pGlobalPopupMenu = GetpGlobalPopupMenu(pwnd); if ((pGlobalPopupMenu != NULL) && !pGlobalPopupMenu->fIsTrackPopup && (pGlobalPopupMenu->spwndPopupMenu == pwnd)) { UserAssert(pGlobalPopupMenu->spwndNotify == pwnd); if (pGlobalPopupMenu->fIsSysMenu) { Lock(&pGlobalPopupMenu->spmenu, pmenu); } else { Lock(&pGlobalPopupMenu->spmenuAlternate, pmenu); } } } } /* * Return the handle to the system menu. */ if (pwnd->spmenuSys != NULL) { /* * The app is probably going to modify this menu and then we'll need to * redraw the caption buttons. Hence we need to store the window pointer * in this pmenu or we won't be able to know what window to repaint. * The bogus thing is that we cannot call LockWndMenu here because this is * not the actual pmenuSys. */ pmenu = _GetSubMenu(pwnd->spmenuSys, 0); if (pmenu) { SetMF(pmenu, MFAPPSYSMENU); Lock(&pmenu->spwndNotify, pwnd); } return pmenu; } return NULL; }

PMENU xxxLoadSysDesktopMenu (  PMENU *  ppmenu, UINT  uMenuId )

Definition at line 30 of file mnsys.c. References _DestroyMenu(), LockDesktopMenu(), MFSYSMENU, NULL, SetMF, TestMF, and xxxLoadSysMenu(). Referenced by xxxGetSysMenuHandle(), xxxSetDialogSystemMenu(), and xxxTranslateAccelerator(). { PMENU pmenu; /* * This should only be called when the menu hasn't been loaded */ UserAssert(*ppmenu == NULL); pmenu = xxxLoadSysMenu(uMenuId); if (pmenu == NULL) { return NULL; } /* * If someone beat us loading the menu, destroy this one * and return the one already loaded */ if (*ppmenu != NULL) { UserAssert(TestMF(*ppmenu, MFSYSMENU)); RIPMSG1(RIP_WARNING, "LoadSysDesktopMenu: Menu loaded during callback. ppmenu:%#p", ppmenu); _DestroyMenu(pmenu); return *ppmenu; } /* * Mark it, lock it and done */ SetMF(pmenu, MFSYSMENU); LockDesktopMenu(ppmenu, pmenu); return pmenu; }

void xxxSetSysMenu (  PWND  pwnd  )

Definition at line 232 of file mnsys.c. References _GetSubMenu(), _SetCloseDefault(), _SetMenuDefaultItem(), BOOL, BYTE, CheckLock, FALSE, IsSmallerThanScreen(), IsTrayWindow(), LOBYTE, MFSYSMENU, MNLookUpItem(), NULL, TestMF, TestMFS, TestWF, ThreadLockAlways, ThreadUnlock, UINT, WEFDLGMODALFRAME, WEFTOOLWINDOW, WFBORDERMASK, WFCHILD, WFDLGFRAME, WFMAXBOX, WFMAXIMIZED, WFMINBOX, WFMINIMIZED, WFSIZEBOX, xxxEnableMenuItem(), and xxxGetSysMenuHandle(). Referenced by xxxGetSysMenu(), xxxHandleNCMouseGuys(), and xxxTranslateAccelerator(). { PMENU pMenu; UINT wSize; UINT wMinimize; UINT wMaximize; UINT wMove; UINT wRestore; UINT wDefault; BOOL fFramedDialogBox; TL tlmenu; CheckLock(pwnd); /* * Get the handle of the current system menu. */ if ((pMenu = xxxGetSysMenuHandle(pwnd)) != NULL) { pMenu = _GetSubMenu(pMenu, 0); if (!pMenu) return; ThreadLockAlways(pMenu, &tlmenu); /* * System modal window: no size, icon, zoom, or move. */ // No system modal windows on NT. // wSize = wMaximize = wMinimize = wMove = // (UINT)((_GetSysModalWindow() == NULL) || hTaskLockInput ? 0: MFS_GRAYED); wSize = wMaximize = wMinimize = wMove = 0; wRestore = MFS_GRAYED; // // Default menu command is close. // wDefault = SC_CLOSE; /* * Minimized exceptions: no minimize, restore. */ // we need to reverse these because VB has a "special" window // that is both minimized but without a minbox. if (TestWF(pwnd, WFMINIMIZED)) { wRestore = 0; wMinimize = MFS_GRAYED; wSize = MFS_GRAYED; wDefault = SC_RESTORE; if (IsTrayWindow(pwnd)) wMove = MFS_GRAYED; } else if (!TestWF(pwnd, WFMINBOX)) wMinimize = MFS_GRAYED; /* * Maximized exceptions: no maximize, restore. */ if (!TestWF(pwnd, WFMAXBOX)) wMaximize = MFS_GRAYED; else if (TestWF(pwnd, WFMAXIMIZED)) { wRestore = 0; /* * If the window is maximized but it isn't larger than the * screen, we allow the user to move the window around the * desktop (but we don't allow resizing). */ wMove = MFS_GRAYED; if (!TestWF(pwnd, WFCHILD)) { if (IsSmallerThanScreen(pwnd)) { wMove = 0; } } wSize = MFS_GRAYED; wMaximize = MFS_GRAYED; } if (!TestWF(pwnd, WFSIZEBOX)) wSize = MFS_GRAYED; /* * Are we dealing with a framed dialog box with a sys menu? * Dialogs with min/max/size boxes get a regular system menu * (as opposed to the dialog menu) */ fFramedDialogBox = (((TestWF(pwnd, WFBORDERMASK) == (BYTE)LOBYTE(WFDLGFRAME)) || (TestWF(pwnd, WEFDLGMODALFRAME))) && !TestWF(pwnd, WFSIZEBOX | WFMINBOX | WFMAXBOX)); if (!fFramedDialogBox) { xxxEnableMenuItem(pMenu, (UINT)SC_SIZE, wSize); if (!TestWF(pwnd, WEFTOOLWINDOW)) { xxxEnableMenuItem(pMenu, (UINT)SC_MINIMIZE, wMinimize); xxxEnableMenuItem(pMenu, (UINT)SC_MAXIMIZE, wMaximize); xxxEnableMenuItem(pMenu, (UINT)SC_RESTORE, wRestore); } } xxxEnableMenuItem(pMenu, (UINT)SC_MOVE, wMove); #if DBG /* * Assert that nobody managed to change the desktop menus. */ if (TestMF(pMenu, MFSYSMENU)) { PITEM pItem = MNLookUpItem(pMenu, SC_CLOSE, FALSE, NULL); UserAssert((pItem != NULL) && !TestMFS(pItem, MFS_GRAYED)); } #endif if (wDefault == SC_CLOSE) _SetCloseDefault(pMenu); else _SetMenuDefaultItem(pMenu, wDefault, MF_BYCOMMAND); ThreadUnlock(&tlmenu); } }

---