mncomput.c File Reference

#include "precomp.h"

Go to the source code of this file.

Functions
DWORD	MNRecalcTabStrings (HDC, PMENU, UINT, UINT, DWORD, DWORD)
BOOL	xxxMNGetBitmapSize (LPITEM pItem, PWND pwndNotify)
BOOL	xxxMNItemSize (PMENU pMenu, PWND pwndNotify, HDC hdc, PITEM pItem, BOOL fPopup, LPPOINT lppt)
int	xxxMNCompute (PMENU pMenu, PWND pwndNotify, DWORD yMenuTop, DWORD xMenuLeft, DWORD cxMax, LPDWORD lpdwMenuHeight)
void	MBC_RightJustifyMenu (PMENU pMenu)
int	xxxMenuBarCompute (PMENU pMenu, PWND pwndNotify, DWORD yMenuTop, DWORD xMenuLeft, int cxMax)
void	xxxMNRecomputeBarIfNeeded (PWND pwndNotify, PMENU pMenu)
PWND	GetMenuPwnd (PWND pwnd, PMENU pmenu)
BOOL	xxxGetMenuItemRect (PWND pwnd, PMENU pMenu, UINT uIndex, LPRECT lprcScreen)
UINT	MNItemHitTest (PMENU pMenu, PWND pwnd, POINT pt)
int	xxxMenuItemFromPoint (PWND pwnd, PMENU pMenu, POINT ptScreen)
PMENU	MakeMenuRtoL (PMENU pMenu, BOOL bRtoL)

---

Function Documentation

PWND GetMenuPwnd (  PWND  pwnd, PMENU  pmenu )

Definition at line 893 of file mncomput.c. References FNID_MENU, GETFNID, MFISPOPUP, MNGetPopupFromMenu(), NULL, tagPOPUPMENU::spmenu, tagPOPUPMENU::spwndPopupMenu, and TestMF. Referenced by xxxGetMenuItemRect(), and xxxMenuItemFromPoint(). { if (TestMF(pmenu, MFISPOPUP)) { if ((pwnd == NULL) || (GETFNID(pwnd) != FNID_MENU)) { PPOPUPMENU ppopup = MNGetPopupFromMenu(pmenu, NULL); if (ppopup != NULL) { UserAssert(ppopup->spmenu == pmenu); pwnd = ppopup->spwndPopupMenu; } } } return pwnd; }

PMENU MakeMenuRtoL (  PMENU  pMenu, BOOL  bRtoL )

Definition at line 995 of file mncomput.c. References tagMENU::cItems, ClearMF, ClearMFT, MFRTL, tagMENU::rgItems, SetMF, SetMFT, and tagITEM::spSubMenu. Referenced by xxxInsertMenuItem(), and xxxSetMenuItemInfo(). { PITEM pItem; int cItem; if (bRtoL) SetMF(pMenu,MFRTL); else ClearMF(pMenu,MFRTL); for (cItem = 0; cItem < (int)pMenu->cItems; cItem++) { pItem = pMenu->rgItems + cItem; if (bRtoL) { SetMFT(pItem, MFT_RIGHTJUSTIFY); SetMFT(pItem, MFT_RIGHTORDER); } else { ClearMFT(pItem, MFT_RIGHTJUSTIFY); ClearMFT(pItem, MFT_RIGHTORDER); } if (pItem->spSubMenu) MakeMenuRtoL(pItem->spSubMenu, bRtoL); } return pMenu; }

void MBC_RightJustifyMenu (  PMENU  pMenu  )

Definition at line 571 of file mncomput.c. References BOOL, tagMENU::cItems, tagITEM::cxItem, tagMENU::cxMenu, tagITEM::cyItem, DWORD, tagITEM::hbmp, IsMDIItem(), MFMWFP_NOITEM, MFRTL, tagMENU::rgItems, tagMENU::spwndNotify, TestMF, TestMFT, TestWF, WFWIN40COMPAT, tagITEM::xItem, and tagITEM::yItem. Referenced by xxxMenuBarCompute(). { PITEM pItem; int cItem; int iFirstRJItem = MFMWFP_NOITEM; DWORD xMenuPos; DWORD yPos; DWORD xPosStart; DWORD xPosEnd; int cItemEnd; int cItemStart; BOOL bIsWin95; // // need to compensate for MDI menus. need to do all here as Win31/Hebrew did // this. also screwed up computation, anything non-text was not moved. // if (pMenu->cItems == 0) return; pItem = (PITEM)&pMenu->rgItems[0]; cItemStart = 0; if (TestMF(pMenu,MFRTL)) { bIsWin95 = TestWF(pMenu->spwndNotify, WFWIN40COMPAT); while( cItemStart < (int)pMenu->cItems ) { if (bIsWin95) { //(not time critical) // // deal with fake MDI dude. // if (!cItemStart && IsMDIItem(pItem)) goto StillFindStart; else break; } if( TestMFT(pItem, MFT_BITMAP) ) { if ( pItem->hbmp > (HBITMAP)HBMMENU_MAX ) break; else goto StillFindStart; } if (!TestMFT(pItem, MFT_OWNERDRAW) ) break; StillFindStart: cItemStart++; pItem = pMenu->rgItems + cItemStart; } // // anything before cItems should be left where it is! Now need to find // the last item to fool with. // cItemEnd = pMenu->cItems - 1; pItem = pMenu->rgItems + cItemEnd; while( cItemEnd > cItemStart ) { if (bIsWin95) { // // fake mdi dudes // if (IsMDIItem(pItem)) goto StillFindEnd; else break; } if ( !TestMFT(pItem, MFT_BITMAP) && !TestMFT(pItem, MFT_OWNERDRAW) ) break; StillFindEnd: cItemEnd --; pItem = pMenu->rgItems + cItemEnd; } yPos = pMenu->rgItems[0].yItem; xMenuPos = pMenu->cxMenu ; xPosStart = xMenuPos; // for 2nd row onward xPosEnd = pMenu->rgItems[cItemStart].xItem ; for (cItem = pMenu->cItems-1; cItem > cItemEnd; cItem--) { // // force any MDI dudes back to the top line again. // pItem = pMenu->rgItems + cItem; xMenuPos = pItem->xItem = xMenuPos - pItem->cxItem; pItem->yItem = yPos; } for( cItem = cItemStart; cItem <= cItemEnd; cItem++ ) { pItem = pMenu->rgItems + cItem; if (xMenuPos - pItem->cxItem > xPosEnd) { xMenuPos -= pItem->cxItem; } else { xMenuPos = xPosStart - pItem->cxItem; yPos += pItem->cyItem; xPosEnd = 0; } pItem->xItem = xMenuPos; pItem->yItem = yPos; } } else { // B#4055 // Use signed arithmetic so comparison cItem >= iFirstRJItem won't // cause underflow. for (cItem = 0; cItem < (int)pMenu->cItems; cItem++) { // Find the first item which is right justified. if (TestMFT((pMenu->rgItems + cItem), MFT_RIGHTJUSTIFY)) { iFirstRJItem = cItem; xMenuPos = pMenu->cxMenu + pMenu->rgItems[0].xItem; for (cItem = (int)pMenu->cItems - 1; cItem >= iFirstRJItem; cItem--) { pItem = pMenu->rgItems + cItem; xMenuPos -= pItem->cxItem; if (pItem->xItem < xMenuPos) pItem->xItem = xMenuPos; } return; } } } }

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

Definition at line 2983 of file ntuser/kernel/menu.c. { 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); }

DWORD MNRecalcTabStrings (  HDC  , PMENU  , UINT  , UINT  , DWORD  , DWORD  )

Definition at line 796 of file mncomput.c. References CALL_LPK, CheckLock, tagMENU::cItems, DWORD, FindCharPosition(), gcxMenuFontChar, gpsi, NULL, OBI_MENUCHECK, PtiCurrentShared, tagMENU::rgItems, TestMFT, TextPointer, UINT, and xxxClientGetTextExtentPointW(). Referenced by xxxMNCompute(). { UINT i; UINT cOwnerDraw; int adx; int maxWidth = 0; int cx; PITEM pItem; CheckLock(pMenu); xTab += hCount; if ((iBeg >= pMenu->cItems) || (iBeg > iEnd)) goto SeeYa; cOwnerDraw = 0; for (i = iBeg, pItem = pMenu->rgItems + iBeg; i < iEnd; pItem++, i++) { adx = 0; /* * Subtract hCount to make dxTab relative to start of column for * multi-column menus. */ pItem->dxTab = xTab - hCount; // Skip non-string or empty string items if ((pItem->lpstr != NULL) && !TestMFT(pItem, MFT_OWNERDRAW)) { LPWSTR lpString = TextPointer(pItem->lpstr); int tp; SIZE size; // Are there any tabs? tp = FindCharPosition(lpString, TEXT('\t')); if (tp < (int) pItem->cch) { PTHREADINFO ptiCurrent = PtiCurrentShared(); if (CALL_LPK(ptiCurrent)) { xxxClientGetTextExtentPointW(hdc, lpString + tp + 1, pItem->cch - tp - 1, &size); } else { GreGetTextExtentW(hdc, lpString + tp + 1, pItem->cch - tp - 1, &size, GGTE_WIN3_EXTENT); } adx = gcxMenuFontChar + size.cx; } } else if (TestMFT(pItem, MFT_OWNERDRAW)) cOwnerDraw++; adx += xTab; if (adx > maxWidth) maxWidth = adx; } /* * Add on space for hierarchical arrow. So basically, popup menu items * can have 4 columns: * (1) Checkmark * (2) Text * (3) Tabbed text for accel * (4) Hierarchical arrow * * But, we only do this if at least one item isn't ownerdraw * and if there's at least one submenu in the popup. */ if (cOwnerDraw != (iEnd - iBeg)) { maxWidth += gcxMenuFontChar + gpsi->oembmi[OBI_MENUCHECK].cx; } cx = maxWidth - hCount; for (i = iBeg, pItem = pMenu->rgItems + iBeg; i < iEnd; pItem++, i++) pItem->cxItem = cx; SeeYa: return(maxWidth); }

BOOL xxxGetMenuItemRect (  PWND  pwnd, PMENU  pMenu, UINT  uIndex, LPRECT  lprcScreen )

Definition at line 911 of file mncomput.c. References BOOL, CheckLock, tagMENU::cItems, tagITEM::cxItem, tagITEM::cyItem, FALSE, GetMenuPwnd(), MFISPOPUP, NULL, OffsetRect(), tagWND::rcClient, tagWND::rcWindow, tagMENU::rgItems, SetRectEmpty, TestMF, TestWF, TRUE, WFWIN50COMPAT, tagITEM::xItem, xxxMNRecomputeBarIfNeeded(), and tagITEM::yItem. Referenced by NtUserGetMenuItemRect(). { PITEM pItem; int dx, dy; CheckLock(pwnd); CheckLock(pMenu); SetRectEmpty(lprcScreen); if (uIndex >= pMenu->cItems) return(FALSE); /* * Raid #315084: Compatiblity with NT4/Win95/98 * * WordPerfect does a long complex way to calc the menu rect * by calling this API. It calls GetMenuItemRect() with the app's * window. */ if (pwnd == NULL || TestWF(pwnd, WFWIN50COMPAT)) { pwnd = GetMenuPwnd(pwnd, pMenu); } /* * If no pwnd, no go. * IMPORTANT: for MFISPOPUP we might get a different pwnd but we don't lock * it because we won't call back */ if (pwnd == NULL) { return FALSE; } if (TestMF(pMenu, MFISPOPUP)) { dx = pwnd->rcClient.left; dy = pwnd->rcClient.top; } else { xxxMNRecomputeBarIfNeeded(pwnd, pMenu); dx = pwnd->rcWindow.left; dy = pwnd->rcWindow.top; } if (uIndex >= pMenu->cItems) return(FALSE); pItem = pMenu->rgItems + uIndex; lprcScreen->right = pItem->cxItem; lprcScreen->bottom = pItem->cyItem; OffsetRect(lprcScreen, dx + pItem->xItem, dy + pItem->yItem); return(TRUE); }

int xxxMenuBarCompute (  PMENU  pMenu, PWND  pwndNotify, DWORD  yMenuTop, DWORD  xMenuLeft, int  cxMax )

Definition at line 706 of file mncomput.c. References CheckLock, DWORD, MBC_RightJustifyMenu(), MFISPOPUP, SYSMET, TestMF, and xxxMNCompute(). Referenced by xxxCalcClientRect(), xxxDrawMenuBarTemp(), xxxMenuBarDraw(), and xxxMNRecomputeBarIfNeeded(). { int size; /* menuHeight is set by MNCompute when dealing with a top level menu and * not all items in the menu bar have the same height. Thus, by setting * menuHeight, MNCompute is called a second time to set every item to the * same height. The actual value stored in menuHeight is the maximum * height of all the menu bar items */ DWORD menuHeight = 0; CheckLock(pwndNotify); CheckLock(pMenu); size = xxxMNCompute(pMenu, pwndNotify, yMenuTop, xMenuLeft, cxMax, &menuHeight); if (!TestMF(pMenu, MFISPOPUP)) { if (menuHeight != 0) { /* * Add a border for the multi-row case. */ size = xxxMNCompute(pMenu, pwndNotify, yMenuTop, xMenuLeft, cxMax, &menuHeight); } /* * Right justification of HELP items is only needed on top level * menus. */ MBC_RightJustifyMenu(pMenu); } /* * There's an extra border underneath the menu bar, if it's not empty! */ return(size ? size + SYSMET(CYBORDER) : size); }

int xxxMenuItemFromPoint (  PWND  pwnd, PMENU  pMenu, POINT  ptScreen )

Definition at line 972 of file mncomput.c. References CheckLock, GetMenuPwnd(), MFISPOPUP, MFMWFP_NOITEM, MNItemHitTest(), NULL, TestMF, and xxxMNRecomputeBarIfNeeded(). Referenced by NtUserMenuItemFromPoint(). { CheckLock(pwnd); CheckLock(pMenu); /* * If no pwnd, no go. * IMPORTANT: for MFISPOPUP we might get a different pwnd but we don't lock * it because we won't call back */ pwnd = GetMenuPwnd(pwnd, pMenu); if (pwnd == NULL) { return MFMWFP_NOITEM; } if (!TestMF(pMenu, MFISPOPUP)) { xxxMNRecomputeBarIfNeeded(pwnd, pMenu); } return(MNItemHitTest(pMenu, pwnd, ptScreen)); }

int xxxMNCompute (  PMENU  pMenu, PWND  pwndNotify, DWORD  yMenuTop, DWORD  xMenuLeft, DWORD  cxMax, LPDWORD  lpdwMenuHeight )

Definition at line 233 of file mncomput.c. References _GetDCEx(), _ReleaseDC(), BOOL, CH_HELPPREFIX, CheckLock, tagMENU::cItems, tagITEM::cxItem, tagMENU::cxMenu, tagMENU::cxTextAlign, tagITEM::cyItem, tagMENU::cyMenu, tagTHREADINFO::dwExpWinVer, DWORD, FALSE, tagMENU::fFlags, gcxMenuFontChar, ghMenuFont, gpsi, tagITEM::hbmp, INT, L, Lock, tagITEM::lpstr, max, MFISPOPUP, MFMULTIROW, MNLEFTMARGIN, MNRecalcTabStrings(), MNXSPACE, NULL, OBI_MENUCHECK, PtiCurrent, tagMENU::rgItems, tagMENU::spwndNotify, SYSMET, TestMF, TestMFT, TestWF, TextPointer, TRUE, UINT, VER40, WFWIN40COMPAT, tagITEM::xItem, xxxMNItemSize(), and tagITEM::yItem. Referenced by xxxMenuBarCompute(), and xxxMenuWindowProc(). { UINT cItem; DWORD cxItem; DWORD cyItem; DWORD cyItemKeep; DWORD yPopupTop; INT cMaxWidth; DWORD cMaxHeight; UINT cItemBegCol; DWORD temp; int ret; PITEM pCurItem; POINT ptMNItemSize; BOOL fOwnerDrawItems; BOOL fMenuBreak; LPWSTR lpsz; BOOL fPopupMenu; DWORD menuHeight = 0; HDC hdc; HFONT hOldFont; PTHREADINFO ptiCurrent = PtiCurrent(); BOOL fStringAndBitmapItems; CheckLock(pMenu); CheckLock(pwndNotify); /* * Whoever computes the menu, becomes the owner. */ if (pwndNotify != pMenu->spwndNotify) { Lock(&pMenu->spwndNotify, pwndNotify); } if (lpdwMenuHeight != NULL) menuHeight = *lpdwMenuHeight; /* * Empty menus have a height of zero. */ ret = 0; if (pMenu->cItems == 0) return ret; hdc = _GetDCEx(NULL, NULL, DCX_WINDOW | DCX_CACHE); hOldFont = GreSelectFont(hdc, ghMenuFont); /* * Try to make a non-multirow menu first. */ pMenu->fFlags &= (~MFMULTIROW); fPopupMenu = TestMF(pMenu, MFISPOPUP); if (fPopupMenu) { /* * Reset the menu bar height to 0 if this is a popup since we are * being called from menu.c MN_SIZEWINDOW. */ menuHeight = 0; } else if (pwndNotify != NULL) { pMenu->cxMenu = cxMax; } /* * Initialize the computing variables. */ cMaxWidth = cyItemKeep = 0L; cItemBegCol = 0; cyItem = yPopupTop = yMenuTop; cxItem = xMenuLeft; pCurItem = (PITEM)&pMenu->rgItems[0]; /* * cxTextAlign is used to align the text in all items; this is useful * in popup menus that mix text only items with bitmap-text items. It's * set to the max bitmap width plus some spacing. * Do this for new menus wich use string AND bitmaps on the same item */ fStringAndBitmapItems = FALSE; pMenu->cxTextAlign = 0; /* * Process each item in the menu. */ fOwnerDrawItems = FALSE; for (cItem = 0; cItem < pMenu->cItems; cItem++) { /* * If it's not a separator, find the dimensions of the object. */ if (TestMFT(pCurItem, MFT_SEPARATOR) && ( !TestMFT(pCurItem, MFT_OWNERDRAW) || (LOWORD(ptiCurrent->dwExpWinVer) < VER40)) ) { /* * If version is less than 4.0 don't test the MFT_OWNERDRAW * flag. Bug 21922; App MaxEda has both separator and Ownerdraw * flags on. In 3.51 we didn't test the OwnerDraw flag */ // // This is a separator. It's drawn as wide as the menu area, // leaving some space above and below. Since the menu area is // the max of the items' widths, we set our width to 0 so as not // to affect the result. // pCurItem->cxItem = 0; pCurItem->cyItem = SYSMET(CYMENUSIZE) / 2; } else { /* * Are we using NT5 strings and bitmaps? */ fStringAndBitmapItems |= ((pCurItem->hbmp != NULL) && (pCurItem->lpstr != NULL)); /* * Get the item's X and Y dimensions. */ if (xxxMNItemSize(pMenu, pwndNotify, hdc, pCurItem, fPopupMenu, &ptMNItemSize)) fOwnerDrawItems = TRUE; pCurItem->cxItem = ptMNItemSize.x; pCurItem->cyItem = ptMNItemSize.y; if (!fPopupMenu && ((pCurItem->hbmp == NULL) || (pCurItem->lpstr != NULL))) { pCurItem->cxItem += gcxMenuFontChar * 2; } } if (menuHeight != 0) pCurItem->cyItem = menuHeight; /* * If this is the first item, initialize cMaxHeight. */ if (cItem == 0) cMaxHeight = pCurItem->cyItem; /* * Is this a Pull-Down menu? */ if (fPopupMenu) { /* * If this item has a break or is the last item... */ if ((fMenuBreak = TestMFT(pCurItem, MFT_BREAK)) || pMenu->cItems == cItem + (UINT)1) { /* * Keep cMaxWidth around if this is not the last item. */ temp = cMaxWidth; if (pMenu->cItems == cItem + (UINT)1) { if ((int)(pCurItem->cxItem) > cMaxWidth) temp = pCurItem->cxItem; } /* * Get new width of string from RecalcTabStrings. */ temp = MNRecalcTabStrings(hdc, pMenu, cItemBegCol, (UINT)(cItem + (fMenuBreak ? 0 : 1)), temp, cxItem); /* * If this item has a break, account for it. */ if (fMenuBreak) { // // Add on space for the etch and a border on either side. // NOTE: For old apps that do weird stuff with owner // draw, keep 'em happy by adding on the same amount // of space we did in 3.1. // if (fOwnerDrawItems && !TestWF(pwndNotify, WFWIN40COMPAT)) cxItem = temp + SYSMET(CXBORDER); else cxItem = temp + 2 * SYSMET(CXEDGE); /* * Reset the cMaxWidth to the current item. */ cMaxWidth = pCurItem->cxItem; /* * Start at the top. */ cyItem = yPopupTop; /* * Save the item where this column begins. */ cItemBegCol = cItem; /* * If this item is also the last item, recalc for this * column. */ if (pMenu->cItems == (UINT)(cItem + 1)) { temp = MNRecalcTabStrings(hdc, pMenu, cItem, (UINT)(cItem + 1), cMaxWidth, cxItem); } } /* * If this is the last entry, supply the width. */ if (pMenu->cItems == cItem + (UINT)1) pMenu->cxMenu = temp; } pCurItem->xItem = cxItem; pCurItem->yItem = cyItem; cyItem += pCurItem->cyItem; if (cyItemKeep < cyItem) cyItemKeep = cyItem; } else { /* * This a Top Level menu, not a Pull-Down. */ /* * Adjust right aligned items before testing for multirow */ if (pCurItem->lpstr != NULL) { lpsz = TextPointer(pCurItem->lpstr); if ((lpsz != NULL) && (*lpsz == CH_HELPPREFIX)) { pCurItem->cxItem -= gcxMenuFontChar; } } /* * If this is a new line or a menu break. */ if ((TestMFT(pCurItem, MFT_BREAK)) || (((cxItem + pCurItem->cxItem + gcxMenuFontChar) > pMenu->cxMenu) && (cItem != 0))) { cyItem += cMaxHeight; cxItem = xMenuLeft; cMaxHeight = pCurItem->cyItem; pMenu->fFlags |= MFMULTIROW; } pCurItem->yItem = cyItem; pCurItem->xItem = cxItem; cxItem += pCurItem->cxItem; } if (cMaxWidth < (int)(pCurItem->cxItem)) cMaxWidth = pCurItem->cxItem; if (cMaxHeight != pCurItem->cyItem) { if (cMaxHeight < pCurItem->cyItem) cMaxHeight = pCurItem->cyItem; if (!fPopupMenu) menuHeight = cMaxHeight; } if (!fPopupMenu) cyItemKeep = cyItem + cMaxHeight; pCurItem++; } /* of for loop */ /* * Determine where the strings should be drawn so they are aligned * The alignment is only for popup (vertical) menus (see xxxRealDrawMenuItem) * The actual space depends on the MNS_NOCHECK and MNS_CHECKORBMP styles * Multicolumn menus don't get aligment (now that we have scrollbars, multicolum is out) */ if (!fStringAndBitmapItems || (cItemBegCol != 0)) { pMenu->cxTextAlign = 0; } else if (TestMF(pMenu, MNS_NOCHECK)) { pMenu->cxTextAlign += MNXSPACE; } else if (TestMF(pMenu, MNS_CHECKORBMP)) { pMenu->cxTextAlign = max(pMenu->cxTextAlign, (UINT)gpsi->oembmi[OBI_MENUCHECK].cx); pMenu->cxTextAlign += MNXSPACE; } else { pMenu->cxTextAlign += gpsi->oembmi[OBI_MENUCHECK].cx + MNXSPACE; } /* * Add the left margin */ if (pMenu->cxTextAlign != 0) { pMenu->cxTextAlign += MNLEFTMARGIN; } if (cItemBegCol && pMenu->cItems && TestMFT(((PITEM)&pMenu->rgItems[0]), MFT_RIGHTJUSTIFY)) { // // multi-column, if we are in RtoL mode, reverse the columns // pCurItem = (PITEM)&pMenu->rgItems[0]; for (cItem = 0; cItem < pMenu->cItems; cItem++) { pCurItem->xItem = pMenu->cxMenu - (pCurItem->xItem + pCurItem->cxItem); pCurItem++; } } GreSelectFont(hdc, hOldFont); _ReleaseDC(hdc); pMenu->cyMenu = cyItemKeep - yMenuTop; ret = pMenu->cyMenu; if (lpdwMenuHeight != NULL) *lpdwMenuHeight = menuHeight; return ret; }

BOOL xxxMNGetBitmapSize (  LPITEM  pItem, PWND  pwndNotify )

Definition at line 27 of file mncomput.c. References BOOL, tagITEM::cxBmp, tagITEM::cyBmp, tagITEM::dwItemData, FALSE, gpsi, LPITEM, MNIS_MEASUREBMP, TRUE, UINT, tagITEM::wID, and xxxSendMessage(). Referenced by xxxMNItemSize(). { MEASUREITEMSTRUCT mis; if (pItem->cxBmp != MNIS_MEASUREBMP) { return FALSE; } // Send a measure item message to the owner mis.CtlType = ODT_MENU; mis.CtlID = 0; mis.itemID = pItem->wID; mis.itemWidth = 0; // After scrollable menus // mis32.itemHeight= gcyMenuFontChar; mis.itemHeight= (UINT)gpsi->cySysFontChar; mis.itemData = pItem->dwItemData; xxxSendMessage(pwndNotify, WM_MEASUREITEM, 0, (LPARAM)&mis); pItem->cxBmp = mis.itemWidth; pItem->cyBmp = mis.itemHeight; return TRUE; }

BOOL xxxMNItemSize (  PMENU  pMenu, PWND  pwndNotify, HDC  hdc, PITEM  pItem, BOOL  fPopup, LPPOINT  lppt )

Definition at line 62 of file mncomput.c. References BOOL, CheckLock, tagITEM::cxBmp, tagMENU::cxTextAlign, tagITEM::cyBmp, DWORD, FindCharPosition(), gcxMenuFontChar, gcyMenuFontChar, gcyMenuFontExternLeading, ghMenuFontDef, gpsi, tagITEM::hbmp, tagITEM::lpstr, max, MFISPOPUP, MNIS_MEASUREBMP, MNLEFTMARGIN, MNXSPACE, NULL, OBI_MENUCHECK, SYSMET, TestMF, TestMFS, TestMFT, TextPointer, xxxMNGetBitmapSize(), and xxxPSMGetTextExtent(). Referenced by xxxMNCompute(). { BITMAP bmp; int width = 0; int height = 0; DWORD xRightJustify; LPWSTR lpMenuString; HFONT hfnOld; int tcExtra; UNREFERENCED_PARAMETER(pMenu); CheckLock(pMenu); CheckLock(pwndNotify); if (!fPopup) { /* * Save off the height of the top menu bar since we will used this often * if the pItem is not in a popup. (ie. it is in the top level menu bar) */ height = SYSMET(CYMENUSIZE); } hfnOld = NULL; if (TestMFS(pItem, MFS_DEFAULT)) { if (ghMenuFontDef) hfnOld = GreSelectFont(hdc, ghMenuFontDef); else { tcExtra = GreGetTextCharacterExtra(hdc); GreSetTextCharacterExtra(hdc, tcExtra + 1 + (gcxMenuFontChar / gpsi->cxSysFontChar)); } } /* * Compute bitmap dimensions if needed */ if (pItem->hbmp != NULL) { if (pItem->hbmp == HBMMENU_CALLBACK) { xxxMNGetBitmapSize(pItem, pwndNotify); } else if (pItem->cxBmp == MNIS_MEASUREBMP) { if (TestMFS(pItem, MFS_CACHEDBMP)) { pItem->cxBmp = SYSMET(CXMENUSIZE); pItem->cyBmp = SYSMET(CYMENUSIZE); if (pItem->hbmp == HBMMENU_SYSTEM) { pItem->cxBmp += SYSMET(CXEDGE); /* * Chicago/Memphis only stretch the width, * not the height. NT Bug 124779. FritzS */ // pItem->cyBmp += SYSMET(CXEDGE); } } else { if (GreExtGetObjectW(pItem->hbmp, sizeof(BITMAP), (LPSTR)&bmp)) { pItem->cxBmp = bmp.bmWidth; pItem->cyBmp = bmp.bmHeight; } else { /* * If the bitmap is not useable, this is as good a default * as any. */ pItem->cxBmp = SYSMET(CXMENUSIZE); pItem->cyBmp = SYSMET(CYMENUSIZE); } } } width = pItem->cxBmp; /* * Remember the max bitmap width to align the text in all items. */ pMenu->cxTextAlign = max(pMenu->cxTextAlign, (DWORD)width); /* * In menu bars, we force the item to be at least CYMNSIZE. * Fixes many, many problems w/ apps that fake own MDI. */ if (fPopup) { height = pItem->cyBmp; } else { height = max((int)pItem->cyBmp, height); } } else if (TestMFT(pItem, MFT_OWNERDRAW)) { // This is an ownerdraw item -- the width and height are stored in // cxBmp and cyBmp xxxMNGetBitmapSize(pItem, pwndNotify); width = pItem->cxBmp; // // Ignore height with menu bar now--that's set by user. // if (fPopup) { height = pItem->cyBmp; // If this item has a popup (hierarchical) menu associated with it, then // reserve room for the bitmap that tells the user that a hierarchical // menu exists here. // B#2966, t-arthb UserAssert(fPopup == (TestMF(pMenu, MFISPOPUP) != 0)); width = width + (gcxMenuFontChar << 1); } } if ((pItem->lpstr != NULL) && (!TestMFT(pItem, MFT_OWNERDRAW)) ) { SIZE size; /* * This menu item contains a string */ /* * We want to keep the menu bar height if this isn't a popup. */ if (fPopup) { /* The thickness of mnemonic underscore is CYBORDER and the gap * between the characters and the underscore is another CYBORDER */ height = max(height, gcyMenuFontChar + gcyMenuFontExternLeading + SYSMET(CYEDGE)); } lpMenuString = TextPointer(pItem->lpstr); xRightJustify = FindCharPosition(lpMenuString, TEXT('\t')); xxxPSMGetTextExtent(hdc, lpMenuString, xRightJustify, &size); if (width) { width += MNXSPACE + size.cx; } else { width = size.cx; } } if (fPopup && !TestMFT(pItem, MFT_OWNERDRAW)) { /* * Add on space for checkmark, then horz spacing for default & disabled * plus some left margin. */ if (TestMF(pMenu, MNS_CHECKORBMP) || !TestMF(pMenu, MNS_NOCHECK)) { width += gpsi->oembmi[OBI_MENUCHECK].cx; } width += MNXSPACE + MNLEFTMARGIN + 2; height += 2; } if (TestMFS(pItem, MFS_DEFAULT)) { if (hfnOld) GreSelectFont(hdc, hfnOld); else GreSetTextCharacterExtra(hdc, tcExtra); } /* * Loword contains width, high word contains height of item. */ lppt->x = width; lppt->y = height; return(TestMFT(pItem, MFT_OWNERDRAW)); }

void xxxMNRecomputeBarIfNeeded (  PWND  pwndNotify, PMENU  pMenu )

Definition at line 758 of file mncomput.c. References CheckLock, tagMENU::cxMenu, tagMENU::cyMenu, FALSE, GetCaptionHeight(), GetWindowBorders(), MFISPOPUP, MFSYSMENU, tagWND::rcWindow, tagMENU::spwndNotify, SYSMET, TestMF, TRUE, and xxxMenuBarCompute(). Referenced by xxxGetMenuItemRect(), xxxHiliteMenuItem(), xxxHotTrackMenu(), xxxMenuItemFromPoint(), and xxxMNStartMenu(). { int cxFrame; int cyFrame; UserAssert(!TestMF(pMenu, MFISPOPUP)); CheckLock(pwndNotify); CheckLock(pMenu); if (!TestMF(pMenu, MFSYSMENU) && ((pMenu->spwndNotify != pwndNotify) || !pMenu->cxMenu || !pMenu->cyMenu)) { int cBorders; cBorders = GetWindowBorders(pwndNotify->style, pwndNotify->ExStyle, TRUE, FALSE); cxFrame = cBorders * SYSMET(CXBORDER); cyFrame = cBorders * SYSMET(CYBORDER); cyFrame += GetCaptionHeight(pwndNotify); // The width passed in this call was larger by cxFrame; // Fix for Bug #11466 - Fixed by SANKAR - 01/06/92 -- xxxMenuBarCompute(pMenu, pwndNotify, cyFrame, cxFrame, (pwndNotify->rcWindow.right - pwndNotify->rcWindow.left) - cxFrame * 2); } }

---