mnchange.c File Reference

#include "precomp.h"

Go to the source code of this file.

Defines
#define	CMENUITEMALLOC   8
#define	CMENUITEMDEALLOC   10
#define	NESTED_MENU_LIMIT   25
Typedefs
typedef BOOL(*	MENUAPIFN )(PMENU, UINT, BOOL, LPMENUITEMINFOW)
Functions
BOOL	xxxSetLPITEMInfo (PMENU pMenu, PITEM pItem, LPMENUITEMINFOW lpmii, PUNICODE_STRING pstr)
PMENU	UnlockSubMenu (PMENU pMenu, PMENU *ppSubMenu)
CHAR	GetMenuDepth (PMENU pMenu, UINT uMaxAllowedDepth)
CHAR	GetMenuAncestors (PMENU pMenu)
BOOL	xxxSetMenuItemInfo (PMENU pMenu, UINT wIndex, BOOL fByPosition, LPMENUITEMINFOW lpmii, PUNICODE_STRING pstrItem)
BOOL	xxxSetMenuInfo (PMENU pMenu, LPCMENUINFO lpmi)
void	NNDeleteAdjustIndex (UINT *puAdjustIndex, UINT uDelIndex)
void	MNDeleteAdjustIndexes (PMENUSTATE pMenuState, PPOPUPMENU ppopup, UINT uiPos)
BOOL	xxxInsertMenuItem (PMENU pMenu, UINT wIndex, BOOL fByPosition, LPMENUITEMINFOW lpmii, PUNICODE_STRING pstrItem)
void	FreeItemBitmap (PITEM pItem)
void	FreeItemString (PMENU pMenu, PITEM pItem)
void	MNFreeItem (PMENU pMenu, PITEM pItem, BOOL fFreeItemPopup)
BOOL	xxxRemoveDeleteMenuHelper (PMENU pMenu, UINT nPosition, DWORD wFlags, BOOL fDeleteMenu)
BOOL	xxxRemoveMenu (PMENU pMenu, UINT nPosition, UINT wFlags)
BOOL	xxxDeleteMenu (PMENU pMenu, UINT nPosition, UINT wFlags)
BOOL	_SetMenuContextHelpId (PMENU pMenu, DWORD dwContextHelpId)
BOOL	_SetMenuFlagRtoL (PMENU pMenu)
PPOPUPMENU	MNGetPopupFromMenu (PMENU pMenu, PMENUSTATE *ppMenuState)
void	xxxMNUpdateShownMenu (PPOPUPMENU ppopup, PITEM pItem, UINT uFlags)

---

Define Documentation

#define CMENUITEMALLOC   8

Definition at line 21 of file mnchange.c. Referenced by xxxInsertMenuItem().

#define CMENUITEMDEALLOC   10

Definition at line 22 of file mnchange.c. Referenced by xxxRemoveDeleteMenuHelper().

#define NESTED_MENU_LIMIT   25

Definition at line 76 of file mnchange.c. Referenced by GetMenuDepth(), and xxxSetLPITEMInfo().

---

Typedef Documentation

typedef BOOL(* MENUAPIFN)(PMENU, UINT, BOOL, LPMENUITEMINFOW)

Definition at line 25 of file mnchange.c.

---

Function Documentation

BOOL _SetMenuContextHelpId (  PMENU  pMenu, DWORD  dwContextHelpId )

Definition at line 999 of file mnchange.c. References BOOL, tagMENU::dwContextHelpId, and TRUE. Referenced by NtUserSetMenuContextHelpId(). { // Set the new context help Id; pMenu->dwContextHelpId = dwContextHelpId; return TRUE; }

BOOL _SetMenuFlagRtoL (  PMENU  pMenu  )

Definition at line 1008 of file mnchange.c. References BOOL, MFRTL, SetMF, and TRUE. Referenced by NtUserSetMenuFlagRtoL(). { // This is a right-to-left menu being created; SetMF(pMenu, MFRTL); return TRUE; }

void FreeItemBitmap (  PITEM  pItem  )

Definition at line 575 of file mnchange.c. References tagITEM::hbmp, NULL, and TestMFS. Referenced by MNFreeItem(), and xxxSetLPITEMInfo(). { // Free up hItem unless it's a bitmap handle or nonexistent. // Apps are responsible for freeing their bitmaps. if ((pItem->hbmp != NULL) && !TestMFS(pItem, MFS_CACHEDBMP)) { /* * Assign ownership of the bitmap to the process that is * destroying the menu to ensure that bitmap will * eventually be destroyed. */ GreSetBitmapOwner((HBITMAP)(pItem->hbmp), OBJECT_OWNER_CURRENT); } // Zap this pointer in case we try to free or reference it again pItem->hbmp = NULL; }

void FreeItemString (  PMENU  pMenu, PITEM  pItem )

Definition at line 598 of file mnchange.c. References DesktopFree, tagMENU::head, tagITEM::lpstr, and NULL. Referenced by MNFreeItem(), and xxxSetLPITEMInfo(). { // Free up Item's string if ((pItem->lpstr != NULL)) { DesktopFree(pMenu->head.rpdesk, pItem->lpstr); } // Zap this pointer in case we try to free or reference it again pItem->lpstr = NULL; }

CHAR GetMenuAncestors (  PMENU  pMenu  )

Definition at line 126 of file mnchange.c. References CHAR, tagMENULIST::pMenu, tagMENULIST::pNext, and tagMENU::pParentMenus. Referenced by xxxSetLPITEMInfo(). { PMENULIST pParentMenu; CHAR uParentAncestors; CHAR retVal = 0; for (pParentMenu = pMenu->pParentMenus; pParentMenu; pParentMenu = pParentMenu->pNext) { uParentAncestors = GetMenuAncestors(pParentMenu->pMenu); if (uParentAncestors > retVal) { retVal = uParentAncestors; } } return retVal+1; }

CHAR GetMenuDepth (  PMENU  pMenu, UINT  uMaxAllowedDepth )

Definition at line 86 of file mnchange.c. References CHAR, tagMENU::cItems, NESTED_MENU_LIMIT, NULL, tagMENU::rgItems, tagITEM::spSubMenu, and UINT. Referenced by xxxSetLPITEMInfo(). { UINT uItems, uMaxDepth = 0, uSubMenuDepth; PITEM pItem; /* * This will prevent us from getting trapped in loops */ if (uMaxAllowedDepth == 0) { return NESTED_MENU_LIMIT; } pItem = pMenu->rgItems; for (uItems = pMenu->cItems; uItems--; pItem++) { if (pItem->spSubMenu != NULL) { uSubMenuDepth = GetMenuDepth(pItem->spSubMenu, uMaxAllowedDepth-1); if (uSubMenuDepth > uMaxDepth) { /* * Don't walk the other submenus if a deep branch was found */ if (uSubMenuDepth >= NESTED_MENU_LIMIT) { return NESTED_MENU_LIMIT; } uMaxDepth = uSubMenuDepth; } } } return uMaxDepth + 1; }

void MNDeleteAdjustIndexes (  PMENUSTATE  pMenuState, PPOPUPMENU  ppopup, UINT  uiPos )

Definition at line 299 of file mnchange.c. References tagPOPUPMENU::fHierarchyDropped, NNDeleteAdjustIndex(), tagPOPUPMENU::posDropped, tagPOPUPMENU::posSelectedItem, tagPOPUPMENU::spwndPopupMenu, tagMENUSTATE::uButtonDownHitArea, tagMENUSTATE::uButtonDownIndex, tagMENUSTATE::uDraggingHitArea, and tagMENUSTATE::uDraggingIndex. Referenced by xxxInsertMenuItem(), and xxxRemoveDeleteMenuHelper(). { /* * Adjust the index of the selected item and the dropped popup, if needed. */ NNDeleteAdjustIndex(&ppopup->posSelectedItem, uiPos); if (ppopup->fHierarchyDropped) { NNDeleteAdjustIndex(&ppopup->posDropped, uiPos); } /* * Adjust uButtonDownIndex and uDraggingIndex if needed */ if (pMenuState->uButtonDownHitArea == (ULONG_PTR)ppopup->spwndPopupMenu) { NNDeleteAdjustIndex(&pMenuState->uButtonDownIndex, uiPos); } if (pMenuState->uDraggingHitArea == (ULONG_PTR)ppopup->spwndPopupMenu) { NNDeleteAdjustIndex(&pMenuState->uDraggingIndex, uiPos); } }

void MNFreeItem (  PMENU  pMenu, PITEM  pItem, BOOL  fFreeItemPopup )

Definition at line 617 of file mnchange.c. References _DestroyMenu(), FreeItemBitmap(), FreeItemString(), tagITEM::spSubMenu, and UnlockSubMenu(). Referenced by _DestroyMenu(), xxxInsertMenuItem(), and xxxRemoveDeleteMenuHelper(). { PMENU pSubMenu; FreeItemBitmap(pItem); FreeItemString(pMenu, pItem); pSubMenu = UnlockSubMenu(pMenu, &(pItem->spSubMenu)); if (pSubMenu) { if (fFreeItemPopup) { _DestroyMenu(pSubMenu); } } }

PPOPUPMENU MNGetPopupFromMenu (  PMENU  pMenu, PMENUSTATE *  ppMenuState )

Definition at line 1027 of file mnchange.c. References FALSE, tagMENUSTATE::fInsideMenuLoop, tagPOPUPMENU::fIsMenuBar, GetpMenuState(), MNAnimate(), NULL, tagMENUSTATE::pGlobalPopupMenu, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndNextPopup, and tagMENU::spwndNotify. Referenced by GetMenuPwnd(), MNFadeSelection(), xxxEnableMenuItem(), xxxInsertMenuItem(), xxxRemoveDeleteMenuHelper(), xxxSetLPITEMInfo(), and xxxSetMenuInfo(). { PPOPUPMENU ppopup; PMENUSTATE pMenuState; /* * If this menu doesn't have a notification window, then * it cannot be in menu mode */ if (pMenu->spwndNotify == NULL) { return NULL; } /* * If no pMenuState, no menu mode */ pMenuState = GetpMenuState(pMenu->spwndNotify); if (pMenuState == NULL) { return NULL; } /* * If not in the menu loop, not yet or no longer in menu mode */ if (!pMenuState->fInsideMenuLoop) { return NULL; } /* * return pMenuState if requested */ if (ppMenuState != NULL) { *ppMenuState = pMenuState; } /* * Starting from the root popup, find the popup associated to this menu */ ppopup = pMenuState->pGlobalPopupMenu; while (ppopup != NULL) { /* * found? */ if (ppopup->spmenu == pMenu) { if (ppopup->fIsMenuBar) { return NULL; } /* * Since the menu is being modified, let's kill any animation. */ MNAnimate(pMenuState, FALSE); return ppopup; } /* * If no more popups, bail */ if (ppopup->spwndNextPopup == NULL) { return NULL; } /* * Next popup */ ppopup = ((PMENUWND)ppopup->spwndNextPopup)->ppopupmenu; } return NULL; }

void NNDeleteAdjustIndex (  UINT *  puAdjustIndex, UINT  uDelIndex )

Definition at line 279 of file mnchange.c. References MFMWFP_NOITEM. Referenced by MNDeleteAdjustIndexes(). { if (*puAdjustIndex == uDelIndex) { *puAdjustIndex = MFMWFP_NOITEM; } else if ((int)*puAdjustIndex > (int)uDelIndex) { (*puAdjustIndex)--; } }

PMENU UnlockSubMenu (  PMENU  pMenu, PMENU *  ppSubMenu )

Definition at line 52 of file mnchange.c. References DesktopFree, tagMENU::head, NULL, PMENULIST, tagMENULIST::pNext, and Unlock. Referenced by MNFreeItem(), and xxxSetLPITEMInfo(). { PMENULIST* pp; PMENULIST pMLFound; if (*ppSubMenu == NULL) { return NULL; } /* * Remove the item from pMenu's pParentsList */ for (pp = &(*ppSubMenu)->pParentMenus; *pp != NULL; pp = &(*pp)->pNext) { if ((*pp)->pMenu == pMenu) { pMLFound = *pp; *pp = (*pp)->pNext; DesktopFree(pMenu->head.rpdesk, pMLFound); break; } } return Unlock(ppSubMenu); }

BOOL xxxDeleteMenu (  PMENU  pMenu, UINT  nPosition, UINT  wFlags )

Definition at line 782 of file mnchange.c. References BOOL, TRUE, and xxxRemoveDeleteMenuHelper(). Referenced by NtUserDeleteMenu(), and xxxCreateWindowEx(). { return xxxRemoveDeleteMenuHelper(pMenu, nPosition, wFlags, TRUE); }

BOOL xxxInsertMenuItem (  PMENU  pMenu, UINT  wIndex, BOOL  fByPosition, LPMENUITEMINFOW  lpmii, PUNICODE_STRING  pstrItem )

Definition at line 323 of file mnchange.c. References BOOL, tagMENU::cAlloced, tagITEM::cch, CheckLock, tagMENU::cItems, CMENUITEMALLOC, tagITEM::cxBmp, tagITEM::cxItem, tagITEM::cyItem, DesktopAlloc(), DesktopFree, DTAG_MENUITEM, tagITEM::dwItemData, FALSE, tagPOPUPMENU::fHierarchyDropped, tagITEM::fState, tagITEM::fType, tagITEM::hbmp, tagITEM::hbmpChecked, tagITEM::hbmpUnchecked, tagMENU::head, ITEM, tagITEM::lpstr, MakeMenuRtoL(), MFISPOPUP, MFMWFP_NOITEM, MFRTL, MNDeleteAdjustIndexes(), MNFreeItem(), MNGetpItemIndex, MNGetPopupFromMenu(), MNIS_MEASUREBMP, MNLookUpItem(), NULL, PBYTE, tagPOPUPMENU::posDropped, tagPOPUPMENU::posSelectedItem, tagMENU::rgItems, tagITEM::spSubMenu, tagPOPUPMENU::spwndPopupMenu, TestMF, TestMFT, ThreadLock, ThreadUnlock, TRUE, tagMENUSTATE::uButtonDownHitArea, tagMENUSTATE::uButtonDownIndex, tagMENUSTATE::uDraggingFlags, tagMENUSTATE::uDraggingHitArea, tagMENUSTATE::uDraggingIndex, UINT, tagITEM::wID, tagITEM::xItem, xxxMNSetGapState(), xxxSetLPITEMInfo(), and tagITEM::yItem. Referenced by NtUserThunkedMenuItemInfo(). { BOOL fRet = TRUE; PITEM pItem; PMENU pMenuItemIsOn; PMENUSTATE pMenuState; PITEM pNewItems; PPOPUPMENU ppopup = NULL; TL tlMenu; UINT uiPos; CheckLock(pMenu); // Find out where the item we are inserting should go. if (wIndex != MFMWFP_NOITEM) { pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn); if (pItem != NULL) { pMenu = pMenuItemIsOn; } else { wIndex = MFMWFP_NOITEM; } } else { pItem = NULL; } /* * keep normal menu items between the MDI system bitmap items */ if (!TestMF(pMenu, MFISPOPUP) && (pMenu->cItems != 0) && (!(lpmii->fMask & MIIM_BITMAP) || (lpmii->hbmpItem > HBMMENU_MBARLAST) || (lpmii->hbmpItem == 0) )) { UINT wSave, w; PITEM pItemWalk; wSave = w = wIndex; if (pItem && !fByPosition) { w = MNGetpItemIndex(pMenu, pItem); w = (UINT)((PBYTE)pItem - (PBYTE)(pMenu->rgItems)) / sizeof(ITEM); } if (!w) { pItemWalk = pMenu->rgItems; if ((pItemWalk->hbmp == HBMMENU_SYSTEM)) { wIndex = 1; } } else { if (w == MFMWFP_NOITEM) { w = pMenu->cItems; } w--; pItemWalk = pMenu->rgItems + w; while (w && (pItemWalk->hbmp) && (pItemWalk->hbmp < HBMMENU_MBARLAST)) { wIndex = w--; pItemWalk--; } } if (wIndex != wSave) { pItem = pMenu->rgItems + wIndex; } } // LATER -- we currently realloc every 10 items. investigate the // performance hit/gain we get from this and adjust accordingly. if (pMenu->cItems >= pMenu->cAlloced) { if (pMenu->rgItems) { pNewItems = (PITEM)DesktopAlloc(pMenu->head.rpdesk, (pMenu->cAlloced + CMENUITEMALLOC) * sizeof(ITEM), DTAG_MENUITEM); if (pNewItems) { RtlCopyMemory(pNewItems, pMenu->rgItems, pMenu->cAlloced * sizeof(ITEM)); #if DEBUGTAGS if (IsDbgTagEnabled(DBGTAG_TrackLocks)) { RelocateMenuLockRecords(pNewItems, pMenu->cItems, ((PBYTE)pNewItems) - (PBYTE)(pMenu->rgItems)); } #endif DesktopFree(pMenu->head.rpdesk, pMenu->rgItems); } } else { pNewItems = (PITEM)DesktopAlloc(pMenu->head.rpdesk, sizeof(ITEM) * CMENUITEMALLOC, DTAG_MENUITEM); } if (pNewItems == NULL) return(FALSE); pMenu->cAlloced += CMENUITEMALLOC; pMenu->rgItems = pNewItems; /* * Now look up the item again since it probably moved when we realloced the * memory. */ if (wIndex != MFMWFP_NOITEM) pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn); } /* * If this menu is being displayed right now and we're not appending * an item, then we need to adjust the positions we keep track of. * We want to do this before moving the items to accomodate the * new one, in case we need to clear the insertion bar */ if ((pItem != NULL) && (ppopup = MNGetPopupFromMenu(pMenu, &pMenuState))) { /* * This menu is active. Adjust the index the selected * item and the dropped popup, if needed */ uiPos = MNGetpItemIndex(pMenu, pItem); if (ppopup->posSelectedItem >= (int)uiPos) { ppopup->posSelectedItem++; } if (ppopup->fHierarchyDropped && (ppopup->posDropped >= (int)uiPos)) { ppopup->posDropped++; } /* * Adjust uButtonDownIndex and uDraggingIndex if needed */ if (pMenuState->uButtonDownHitArea == (ULONG_PTR)ppopup->spwndPopupMenu) { if ((int)pMenuState->uButtonDownIndex >= (int)uiPos) { pMenuState->uButtonDownIndex++; } } if (pMenuState->uDraggingHitArea == (ULONG_PTR)ppopup->spwndPopupMenu) { /* * Check to see if an item is inserted right on the insertion * bar. If so, clean up any present insertion bar state */ if (((int)pMenuState->uDraggingIndex == (int)uiPos) && (pMenuState->uDraggingFlags & MNGOF_TOPGAP)) { xxxMNSetGapState(pMenuState->uDraggingHitArea, pMenuState->uDraggingIndex, pMenuState->uDraggingFlags, FALSE); } if ((int)pMenuState->uDraggingIndex >= (int)uiPos) { pMenuState->uDraggingIndex++; } } } pMenu->cItems++; if (pItem != NULL) { // Move this item up to make room for the one we want to insert. RtlMoveMemory(pItem + 1, pItem, (pMenu->cItems - 1) * sizeof(ITEM) - ((char *)pItem - (char *)pMenu->rgItems)); #if DEBUGTAGS if (IsDbgTagEnabled(DBGTAG_TrackLocks)) { RelocateMenuLockRecords(pItem + 1, (int)(&(pMenu->rgItems[pMenu->cItems]) - (pItem + 1)), sizeof(ITEM)); } #endif } else { // If lpItem is null, we will be inserting the item at the end of the // menu. pItem = pMenu->rgItems + pMenu->cItems - 1; } // Need to zero these fields in case we are inserting this item in the // middle of the item list. pItem->fType = 0; pItem->fState = 0; pItem->wID = 0; pItem->spSubMenu = NULL; pItem->hbmpChecked = NULL; pItem->hbmpUnchecked = NULL; pItem->cch = 0; pItem->dwItemData = 0; pItem->xItem = 0; pItem->yItem = 0; pItem->cxItem = 0; pItem->cyItem = 0; pItem->hbmp = NULL; pItem->cxBmp = MNIS_MEASUREBMP; pItem->lpstr = NULL; /* * We might have reassigned pMenu above, so lock it */ ThreadLock(pMenu, &tlMenu); if (!xxxSetLPITEMInfo(pMenu, pItem, lpmii, pstrItem)) { /* * Reset any of the indexes we might have adjusted above */ if (ppopup != NULL) { MNDeleteAdjustIndexes(pMenuState, ppopup, uiPos); } MNFreeItem(pMenu, pItem, TRUE); // Move things up since we removed/deleted the item RtlMoveMemory(pItem, pItem + 1, pMenu->cItems * (UINT)sizeof(ITEM) + (UINT)((char *)&pMenu->rgItems[0] - (char *)(pItem + 1))); #if DEBUGTAGS if (IsDbgTagEnabled(DBGTAG_TrackLocks)) { RelocateMenuLockRecords(pItem, (int)(&(pMenu->rgItems[pMenu->cItems - 1]) - pItem), -(int)sizeof(ITEM)); } #endif pMenu->cItems--; fRet = FALSE; } else { /* * Like MFT_RIGHTJUSTIFY, this staggers down the menu, * (but we inherit, to make localisation etc MUCH easier). * * MFT_RIGHTORDER is the same value as MFT_SYSMENU. We distinguish * between the two by also looking for MFT_BITMAP. */ if (TestMF(pMenu, MFRTL) || (pItem && TestMFT(pItem, MFT_RIGHTORDER) && !TestMFT(pItem, MFT_BITMAP))) { pItem->fType |= (MFT_RIGHTORDER | MFT_RIGHTJUSTIFY); if (pItem->spSubMenu) { MakeMenuRtoL(pItem->spSubMenu, TRUE); } } } ThreadUnlock(&tlMenu); return fRet; }

void xxxMNUpdateShownMenu (  PPOPUPMENU  ppopup, PITEM  pItem, UINT  uFlags )

Definition at line 1106 of file mnchange.c. References _GetClientRect(), tagMENU::cxMenu, tagITEM::cyItem, tagMENU::cyMenu, tagMENU::dwArrowsOn, DWORD, L, MNGetToppItem(), MNUS_DELETE, MNUS_DRAWFRAME, MSA_OFF, NULL, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndPopupMenu, ThreadLock, ThreadUnlock, TRUE, xxxInvalidateRect(), xxxScrollWindowEx(), xxxSendMessage(), xxxSetWindowPos(), and tagITEM::yItem. Referenced by xxxEnableMenuItem(), xxxRemoveDeleteMenuHelper(), xxxSetLPITEMInfo(), and xxxSetMenuInfo(). { RECT rc; PWND pwnd = ppopup->spwndPopupMenu; PMENU pMenu = ppopup->spmenu; TL tlpwnd; TL tlpmenu; /* * The popup might get destroyed while we callback, so lock this pwnd. */ ThreadLock(pwnd, &tlpwnd); ThreadLock(ppopup->spmenu, &tlpmenu); _GetClientRect(pwnd, &rc); /* * If we need to resize menu window */ if (pMenu->cxMenu == 0) { RECT rcScroll = rc; int cySave = rc.bottom; int cxSave = rc.right; DWORD dwSize; DWORD dwArrowsOnBefore; dwArrowsOnBefore = pMenu->dwArrowsOn; UserAssert(uFlags != 0); dwSize = (DWORD)xxxSendMessage(pwnd, MN_SIZEWINDOW, uFlags, 0L); uFlags &= ~MNUS_DRAWFRAME; /* * If scroll arrows appeared or disappeared, redraw entire client */ if (dwArrowsOnBefore ^ pMenu->dwArrowsOn) { goto InvalidateAll; } rc.right = LOWORD(dwSize); if (pItem != NULL) { if (rc.right != cxSave) { // width changed, redraw everything // BUGBUG -- this could be tuned to just redraw items with // submenus and/or accelerator fields goto InvalidateAll; } else { rc.bottom = pMenu->cyMenu; if (pMenu->dwArrowsOn != MSA_OFF) { if (rc.bottom <= cySave) { rc.top = pItem->yItem - MNGetToppItem(pMenu)->yItem; goto InvalidateRest; } _GetClientRect(pwnd, &rcScroll); } rc.top = rcScroll.top = pItem->yItem - MNGetToppItem(pMenu)->yItem; if ((rc.top >= 0) && (rc.top < (int)pMenu->cyMenu)) { xxxScrollWindowEx(pwnd, 0, rc.bottom - cySave, &rcScroll, &rc, NULL, NULL, SW_INVALIDATE | SW_ERASE); } } /* else of if (rc.right != cxSave) */ } /* if (pItem != NULL) */ } /* if (pMenu->cxMenu == 0) */ if (!(uFlags & MNUS_DELETE)) { if (pItem != NULL) { rc.top = pItem->yItem - MNGetToppItem(pMenu)->yItem; rc.bottom = rc.top + pItem->cyItem; InvalidateRest: if ((rc.top >= 0) && (rc.top < (int)pMenu->cyMenu)) { xxxInvalidateRect(pwnd, &rc, TRUE); } } else { InvalidateAll: xxxInvalidateRect(pwnd, NULL, TRUE); } if (uFlags & MNUS_DRAWFRAME) { xxxSetWindowPos(pwnd, NULL, 0, 0, 0, 0, SWP_DRAWFRAME | SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOOWNERZORDER); } } ThreadUnlock(&tlpmenu); ThreadUnlock(&tlpwnd); }

BOOL xxxRemoveDeleteMenuHelper (  PMENU  pMenu, UINT  nPosition, DWORD  wFlags, BOOL  fDeleteMenu )

Definition at line 644 of file mnchange.c. References BOOL, CheckLock, CMENUITEMDEALLOC, DesktopAlloc(), DesktopFree, DTAG_MENUITEM, FALSE, ITEM, MNDeleteAdjustIndexes(), MNFreeItem(), MNGetpItemIndex, MNGetPopupFromMenu(), MNLookUpItem(), MNUS_DELETE, NULL, PBYTE, TRUE, UINT, and xxxMNUpdateShownMenu(). Referenced by xxxDeleteMenu(), and xxxRemoveMenu(). { PITEM pItem; PITEM pNewItems; PMENU pMenuSave; PMENUSTATE pMenuState; PPOPUPMENU ppopup; UINT uiPos; CheckLock(pMenu); pMenuSave = pMenu; pItem = MNLookUpItem(pMenu, nPosition, (BOOL) (wFlags & MF_BYPOSITION), &pMenu); if (pItem == NULL) { /* * Hack for apps written for Win95. In Win95 the prototype for * this function was with 'WORD nPosition' and because of this * the HIWORD(nPosition) got set to 0. * We are doing this just for system menu commands. */ if (nPosition >= 0xFFFFF000 && !(wFlags & MF_BYPOSITION)) { nPosition &= 0x0000FFFF; pMenu = pMenuSave; pItem = MNLookUpItem(pMenu, nPosition, FALSE, &pMenu); if (pItem == NULL) return FALSE; } else return FALSE; } if (ppopup = MNGetPopupFromMenu(pMenu, &pMenuState)) { /* * This menu is active; since we're about to insert an item, * make sure that any of the positions we've stored are * adjusted properly */ uiPos = MNGetpItemIndex(pMenu, pItem); MNDeleteAdjustIndexes(pMenuState, ppopup, uiPos); } MNFreeItem(pMenu, pItem, fDeleteMenu); /* * Reset the menu size so that it gets recomputed next time. */ pMenu->cyMenu = pMenu->cxMenu = 0; if (pMenu->cItems == 1) { DesktopFree(pMenu->head.rpdesk, pMenu->rgItems); pMenu->cAlloced = 0; pNewItems = NULL; } else { /* * Move things up since we removed/deleted the item */ RtlMoveMemory(pItem, pItem + 1, pMenu->cItems * (UINT)sizeof(ITEM) + (UINT)((char *)&pMenu->rgItems[0] - (char *)(pItem + 1))); #if DEBUGTAGS if (IsDbgTagEnabled(DBGTAG_TrackLocks)) { RelocateMenuLockRecords(pItem, (int)(&(pMenu->rgItems[pMenu->cItems - 1]) - pItem), -(int)sizeof(ITEM)); } #endif /* * We're shrinking so if localalloc fails, just leave the mem as is. */ UserAssert(pMenu->cAlloced >= pMenu->cItems); if ((pMenu->cAlloced - pMenu->cItems) >= CMENUITEMDEALLOC - 1) { pNewItems = (PITEM)DesktopAlloc(pMenu->head.rpdesk, (pMenu->cAlloced - CMENUITEMDEALLOC) * sizeof(ITEM), DTAG_MENUITEM); if (pNewItems != NULL) { RtlCopyMemory(pNewItems, pMenu->rgItems, (pMenu->cAlloced - CMENUITEMDEALLOC) * sizeof(ITEM)); #if DEBUGTAGS if (IsDbgTagEnabled(DBGTAG_TrackLocks)) { RelocateMenuLockRecords(pNewItems, pMenu->cItems - 1, ((PBYTE)pNewItems) - (PBYTE)(pMenu->rgItems)); } #endif DesktopFree(pMenu->head.rpdesk, pMenu->rgItems); pMenu->cAlloced -= CMENUITEMDEALLOC; } else pNewItems = pMenu->rgItems; } else pNewItems = pMenu->rgItems; } pMenu->rgItems = pNewItems; pMenu->cItems--; if (ppopup != NULL) { /* * this menu is currently being displayed -- redisplay the menu with * this item removed */ xxxMNUpdateShownMenu(ppopup, pMenu->rgItems + uiPos, MNUS_DELETE); } return TRUE; }

BOOL xxxRemoveMenu (  PMENU  pMenu, UINT  nPosition, UINT  wFlags )

Definition at line 766 of file mnchange.c. References BOOL, FALSE, and xxxRemoveDeleteMenuHelper(). Referenced by NtUserRemoveMenu(). { return xxxRemoveDeleteMenuHelper(pMenu, nPosition, wFlags, FALSE); }

BOOL NEAR xxxSetLPITEMInfo (  PMENU  pMenu, PITEM  pItem, LPMENUITEMINFOW  lpmii, PUNICODE_STRING  pstr )

Definition at line 796 of file mnchange.c. References _CreateMenu(), _DestroyMenu(), BOOL, tagITEM::cch, CheckLock, ClearMF, ClearMFS, tagITEM::cxBmp, tagMENU::cxMenu, tagMENU::cyMenu, DesktopAlloc(), DesktopFree, DTAG_MENUITEM, DTAG_MENUTEXT, tagITEM::dwItemData, tagITEM::dxTab, FALSE, FreeItemBitmap(), FreeItemString(), tagITEM::fState, tagITEM::fType, GetMenuAncestors(), GetMenuDepth(), tagITEM::hbmp, tagITEM::hbmpChecked, tagITEM::hbmpUnchecked, tagMENU::head, Lock, tagITEM::lpstr, MENULIST, MFISPOPUP, MNGetPopupFromMenu(), MNIS_MEASUREBMP, MNUS_DEFAULT, NESTED_MENU_LIMIT, NULL, tagMENULIST::pMenu, tagMENULIST::pNext, tagMENU::pParentMenus, SetMF, SetMFS, tagITEM::spSubMenu, TRUE, UINT, tagITEM::ulWidth, tagITEM::ulX, UNDERLINE_RECALC, Unlock, UnlockSubMenu(), ValidateHmenu(), tagITEM::wID, and xxxMNUpdateShownMenu(). Referenced by xxxInsertMenuItem(), and xxxSetMenuItemInfo(). { HANDLE hstr; UINT cch; BOOL fRecompute = FALSE; BOOL fRedraw = FALSE; PPOPUPMENU ppopup; CheckLock(pMenu); if (lpmii->fMask & MIIM_FTYPE) { pItem->fType &= ~MFT_MASK; pItem->fType |= lpmii->fType; if (lpmii->fType & MFT_SEPARATOR ) { pItem->fState |= MFS_DISABLED ; } fRecompute = TRUE; fRedraw = (lpmii->fType & MFT_OWNERDRAW); } if (lpmii->fMask & MIIM_STRING) { if (pstrItem->Buffer != NULL) { hstr = (HANDLE)DesktopAlloc(pMenu->head.rpdesk, pstrItem->Length + sizeof(UNICODE_NULL), DTAG_MENUTEXT); if (hstr == NULL) { return FALSE; } try { RtlCopyMemory(hstr, pstrItem->Buffer, pstrItem->Length); } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { DesktopFree(pMenu->head.rpdesk, hstr); return FALSE; } cch = pstrItem->Length / sizeof(WCHAR); /* * We don't need to null terminate the string, since DesktopAlloc * zero-fills for us. */ } else { cch = 0; hstr = NULL; } FreeItemString(pMenu,pItem); pItem->cch = cch; pItem->lpstr = hstr; fRecompute = TRUE; fRedraw = TRUE; } if (lpmii->fMask & MIIM_BITMAP) { FreeItemBitmap(pItem); pItem->hbmp = lpmii->hbmpItem; fRecompute = TRUE; fRedraw = TRUE; pItem->cxBmp = MNIS_MEASUREBMP; /* * If this is one of the special bitmaps, mark it as such */ if ((pItem->hbmp > HBMMENU_MIN) && (pItem->hbmp < HBMMENU_MAX)) { SetMFS(pItem, MFS_CACHEDBMP); } else { ClearMFS(pItem, MFS_CACHEDBMP); } } if (lpmii->fMask & MIIM_ID) { pItem->wID = lpmii->wID; } if (lpmii->fMask & MIIM_DATA) { pItem->dwItemData = lpmii->dwItemData; } if (lpmii->fMask & MIIM_STATE) { /* * Preserve private bits (~MFS_MASK). * Also preserve MFS_HILITE | MFS_DEFAULT if already set; if not set, * let the caller turn them on. */ UserAssert(!(lpmii->fState & ~MFS_MASK)); pItem->fState &= ~MFS_MASK | MFS_HILITE | MFS_DEFAULT; pItem->fState |= lpmii->fState; if (pItem->fType & MFT_SEPARATOR) pItem->fState |= MFS_DISABLED; fRedraw = TRUE; } if (lpmii->fMask & MIIM_CHECKMARKS) { pItem->hbmpChecked = lpmii->hbmpChecked; pItem->hbmpUnchecked = lpmii->hbmpUnchecked; fRedraw = TRUE; } if (lpmii->fMask & MIIM_SUBMENU) { PMENU pSubMenu = NULL; if (lpmii->hSubMenu != NULL) { pSubMenu = ValidateHmenu(lpmii->hSubMenu); } // Free the popup associated with this item, if any and if needed. if (pItem->spSubMenu != pSubMenu) { if (pItem->spSubMenu != NULL) { _DestroyMenu(pItem->spSubMenu); } if (pSubMenu != NULL) { BOOL bMenuCreated = FALSE; /* * Fix MSTest that sets a submenu to itself by giving it a different handle. * So the loop is broken and we won't fail their call later * MCostea #243374 */ if (pSubMenu == pMenu) { pSubMenu = _CreateMenu(); if (!pSubMenu) { return FALSE; } bMenuCreated = TRUE; } /* * Link the submenu and then check for loops */ Lock(&(pItem->spSubMenu), pSubMenu); SetMF(pItem->spSubMenu, MFISPOPUP); /* * We just added a submenu. Check to see if the menu tree is not * unreasonable deep and there is no loop forming. * This will prevent us from running out of stack * MCostea #226460 */ if (GetMenuDepth(pSubMenu, NESTED_MENU_LIMIT) + GetMenuAncestors(pMenu) >= NESTED_MENU_LIMIT) { FailInsertion: RIPMSG1(RIP_WARNING, "The menu hierarchy is very deep or has a loop %#p", pMenu); ClearMF(pItem->spSubMenu, MFISPOPUP); Unlock(&(pItem->spSubMenu)); if (bMenuCreated) { _DestroyMenu(pSubMenu); } return FALSE; } /* * Add pMenu to the pSubMenu->pParentMenus list */ { PMENULIST pMenuList = DesktopAlloc(pMenu->head.rpdesk, sizeof(MENULIST), DTAG_MENUITEM); if (!pMenuList) { goto FailInsertion; } pMenuList->pMenu = pMenu; pMenuList->pNext = pSubMenu->pParentMenus; pSubMenu->pParentMenus = pMenuList; } } else { UnlockSubMenu(pMenu, &(pItem->spSubMenu)); } fRedraw = TRUE; } } // For support of the old way of defining a separator i.e. if it is not a string // or a bitmap or a ownerdraw, then it must be a separator. // This should prpbably be moved to MIIOneWayConvert -jjk if (!(pItem->fType & (MFT_OWNERDRAW | MFT_SEPARATOR)) && (pItem->lpstr == NULL) && (pItem->hbmp == NULL)) { pItem->fType = MFT_SEPARATOR; pItem->fState|=MFS_DISABLED; } if (fRecompute) { pItem->dxTab = 0; pItem->ulX = UNDERLINE_RECALC; pItem->ulWidth = 0; // Set the size of this menu to be 0 so that it gets recomputed with this // new item... pMenu->cyMenu = pMenu->cxMenu = 0; if (fRedraw) { if (ppopup = MNGetPopupFromMenu(pMenu, NULL)) { // this menu is currently being displayed -- redisplay the menu, // recomputing if necessary xxxMNUpdateShownMenu(ppopup, pItem, MNUS_DEFAULT); } } } return TRUE; }

BOOL xxxSetMenuInfo (  PMENU  pMenu, LPCMENUINFO  lpmi )

Definition at line 204 of file mnchange.c. References BOOL, CheckLock, tagMENU::cItems, tagMENU::cxMenu, tagMENU::cyMax, tagMENU::cyMenu, tagMENU::dwArrowsOn, tagMENU::dwContextHelpId, tagMENU::dwMenuData, FALSE, tagMENU::fFlags, tagMENU::hbrBack, MNGetPopupFromMenu(), MNUS_DEFAULT, MNUS_DRAWFRAME, MSA_OFF, NULL, tagMENU::rgItems, tagITEM::spSubMenu, ThreadLock, ThreadUnlock, TRUE, UINT, and xxxMNUpdateShownMenu(). Referenced by NtUserThunkedMenuInfo(). { PPOPUPMENU ppopup; BOOL fRecompute = FALSE; BOOL fRedraw = FALSE; UINT uFlags = MNUS_DEFAULT; PITEM pItem; UINT uItems; TL tlSubMenu; CheckLock(pMenu); if (lpmi->fMask & MIM_STYLE) { pMenu->fFlags ^= (pMenu->fFlags ^ lpmi->dwStyle) & MNS_VALID; fRecompute = TRUE; } if (lpmi->fMask & MIM_MAXHEIGHT) { pMenu->cyMax = lpmi->cyMax; fRecompute = TRUE; } if (lpmi->fMask & MIM_BACKGROUND) { pMenu->hbrBack = lpmi->hbrBack; fRedraw = TRUE; if (pMenu->dwArrowsOn != MSA_OFF) { uFlags |= MNUS_DRAWFRAME; } } if (lpmi->fMask & MIM_HELPID) { pMenu->dwContextHelpId = lpmi->dwContextHelpID; } if (lpmi->fMask & MIM_MENUDATA) { pMenu->dwMenuData = lpmi->dwMenuData; } /* * Do we need to set this for all submenus? */ if (lpmi->fMask & MIM_APPLYTOSUBMENUS) { pItem = pMenu->rgItems; for (uItems = pMenu->cItems; uItems--; pItem++) { if (pItem->spSubMenu != NULL) { ThreadLock(pItem->spSubMenu, &tlSubMenu); xxxSetMenuInfo(pItem->spSubMenu, lpmi); ThreadUnlock(&tlSubMenu); } } } if (fRecompute) { // Set the size of this menu to be 0 so that it gets recomputed with this // new item... pMenu->cyMenu = pMenu->cxMenu = 0; } if (fRecompute || fRedraw) { if (ppopup = MNGetPopupFromMenu(pMenu, NULL)) { // this menu is currently being displayed -- redisplay the menu, // recomputing if necessary xxxMNUpdateShownMenu(ppopup, NULL, uFlags); } } return TRUE; }

BOOL xxxSetMenuItemInfo (  PMENU  pMenu, UINT  wIndex, BOOL  fByPosition, LPMENUITEMINFOW  lpmii, PUNICODE_STRING  pstrItem )

Definition at line 146 of file mnchange.c. References BOOL, CheckLock, FALSE, MakeMenuRtoL(), MFRTL, MNLookUpItem(), NULL, TestMF, TRUE, and xxxSetLPITEMInfo(). Referenced by NtUserThunkedMenuItemInfo(). { PITEM pItem; CheckLock(pMenu); pItem = MNLookUpItem(pMenu, wIndex, fByPosition,NULL); if (pItem == NULL) { /* * Word doesn't like not finding SC_TASKLIST -- so it that's what * they're looking for, let's pretend we changed it. */ if (!fByPosition && (wIndex == SC_TASKLIST)) return TRUE; /* * Item not found. Return false. */ RIPERR0(ERROR_MENU_ITEM_NOT_FOUND, RIP_WARNING, "ModifyMenu: Menu item not found"); return FALSE; } /* * we need to treat MFT_RIGHTORDER separately as this is propogated down * to the entire menu not just to this item so that we stay in ssync. This * is pretty similar to the use of MFT_RIGHTJUST, we actually do the * propogation because we need the flag in all sorts of places, not just * in MBC_RightJustifyMenu() */ /* * See ValidateMENUITEMINFO in client\clmenu.c will add more flags to fMask if it use to be MIIM_TYPE * Then fMask will not be any more == MIIM_TYPE. */ if (lpmii->fMask & MIIM_TYPE) { BOOL bRtoL = (lpmii->fType & MFT_RIGHTORDER) ? TRUE : FALSE; if (bRtoL || TestMF(pMenu, MFRTL)) { MakeMenuRtoL(pMenu, bRtoL); } } return xxxSetLPITEMInfo(pMenu, pItem, lpmii, pstrItem); }

---