/**************************** Module Header ********************************\ * Module Name: mndraw.c * * Copyright (c) 1985 - 1999, Microsoft Corporation * * Menu Painting Routines * * History: * 10-10-90 JimA Cleanup. * 03-18-91 IanJa Window revalidation added \***************************************************************************/ #include "precomp.h" #pragma hdrstop #define SRCSTENCIL 0x00B8074AL #define MENU_STRLEN 255 /***************************************************************************\ * MNIsCachedBmpOnly * * 04/02/97 GerardoB Created \***************************************************************************/ __inline BOOL MNIsCachedBmpOnly( PITEM pItem) { return TestMFS(pItem, MFS_CACHEDBMP) && (pItem->lpstr == NULL); } /***************************************************************************\ * MNDrawHilite * * Don't draw the hilite if: * The insertion bar is on (MFS_GAPDROP) * or this is a cached bitmap (close, min, max, etc) with no text * * 08/12/96 GerardoB Ported From Memphis. \***************************************************************************/ BOOL MNDrawHilite( PITEM pItem) { return TestMFS(pItem, MFS_HILITE) && !TestMFS(pItem, MFS_GAPDROP) && !MNIsCachedBmpOnly(pItem); } /***************************************************************************\ * MNDrawMenu3DHotTracking * * 03/10/97 yutakas created * 04/07/97 vadimg ported from Memphis \***************************************************************************/ VOID MNDrawMenu3DHotTracking( HDC hdc, PMENU pMenu, PITEM pItem) { HBRUSH hbrTopLeft, hbrBottomRight; BOOL fDrawEdge; UserAssertMsg0(!MNIsFlatMenu(), "3D Hot Tracking not valid for flat menus"); if (pItem->hbmp && TestMFS(pItem, MFS_CACHEDBMP)) { return; } fDrawEdge = FALSE; if (!TestMF(pMenu, MFISPOPUP)) { if (TestMFS(pItem, MFS_HILITE)) { hbrTopLeft = SYSHBR(3DSHADOW); hbrBottomRight = SYSHBR(3DHILIGHT); SetMFS(pItem, MFS_HOTTRACKDRAWN); fDrawEdge = TRUE; } else if (TestMFS(pItem, MFS_HOTTRACK)) { hbrTopLeft = SYSHBR(3DHILIGHT); hbrBottomRight = SYSHBR(3DSHADOW); SetMFS(pItem, MFS_HOTTRACKDRAWN); fDrawEdge = TRUE; } else if (TestMFS(pItem, MFS_HOTTRACKDRAWN)) { if (pMenu->hbrBack == NULL) { hbrTopLeft = SYSHBR(MENU); hbrBottomRight = SYSHBR(MENU); } else { hbrTopLeft = pMenu->hbrBack; hbrBottomRight = pMenu->hbrBack; } ClearMFS(pItem, MFS_HOTTRACKDRAWN); fDrawEdge = TRUE; } } if (fDrawEdge) { int x = pItem->xItem, y = pItem->yItem; int cx = pItem->cxItem, cy = pItem->cyItem; HBRUSH hbrOld = GreSelectBrush(hdc, hbrTopLeft); GrePatBlt(hdc, x, y, cx - CXMENU3DEDGE, CYMENU3DEDGE, PATCOPY); GrePatBlt(hdc, x, y, CXMENU3DEDGE, cy - CYMENU3DEDGE, PATCOPY); GreSelectBrush(hdc, hbrBottomRight); GrePatBlt(hdc, x, y + cy - CYMENU3DEDGE, cx - CXMENU3DEDGE, CYMENU3DEDGE, PATCOPY); GrePatBlt(hdc, x + cx - CYMENU3DEDGE, y, CXMENU3DEDGE, cy, PATCOPY); GreSelectBrush(hdc, hbrOld); } } /***************************************************************************\ * MNDrawArrow * * Redraws the specified arrow (uArrow) in a scrollable menu (ppopup) to reflect * its current state of enabled or disabled, drawing it in HOTLIGHT if fOn is * TRUE. * * 08/12/96 GerardoB Ported From Memphis. \***************************************************************************/ VOID MNDrawArrow( HDC hdcIn, PPOPUPMENU ppopup, UINT uArrow) { PWND pwnd = ppopup->spwndPopupMenu; HDC hdc; int x, y; DWORD dwBmp; DWORD dwAtCheck; DWORD dwState; if (ppopup->spmenu->dwArrowsOn == MSA_OFF) { return; } if (hdcIn == NULL) { hdc = _GetDCEx(pwnd, NULL, DCX_USESTYLE | DCX_WINDOW | DCX_LOCKWINDOWUPDATE); } else { hdc = hdcIn; } x = SYSMET(CXFIXEDFRAME); if (!TestMF(ppopup->spmenu, MNS_NOCHECK)) { /* * Win9x: x += MNByteAlignItem(oemInfo.bm[OBI_MENUCHECK].cx); */ x += gpsi->oembmi[OBI_MENUCHECK].cx; } else { x += SYSMET(CXEDGE) * 2; } if (uArrow == MFMWFP_UPARROW) { y = SYSMET(CXFIXEDFRAME); dwBmp = OBI_MENUARROWUP; dwAtCheck = MSA_ATTOP; dwState = DFCS_MENUARROWUP; } else { y = pwnd->rcWindow.bottom - pwnd->rcWindow.top - SYSMET(CYFIXEDFRAME) - gcyMenuScrollArrow; dwBmp = OBI_MENUARROWDOWN; dwAtCheck = MSA_ATBOTTOM; dwState = DFCS_MENUARROWDOWN; } if (ppopup->spmenu->dwArrowsOn == dwAtCheck) { /* * go 2 ahead to inactive state bitmap */ dwBmp += 2; dwState |= DFCS_INACTIVE; } if (ppopup->spmenu->hbrBack != NULL) { /* * For menus with background brushes, we can't do a straight blt * of the scroll arrows 'cause the background wouldn't be right; * need to call DrawFrameControl with DFCS_TRANSPARENT instead. */ RECT rc; rc.top = y; rc.left = x; rc.right = x + gpsi->oembmi[OBI_MENUARROWUP].cx; rc.bottom = y + gpsi->oembmi[OBI_MENUARROWUP].cy; DrawFrameControl(hdc, &rc, DFC_MENU, dwState | DFCS_TRANSPARENT); } else { BitBltSysBmp(hdc, x, y, dwBmp); BitBltSysBmp(hdc, x, y, dwBmp); } if (hdcIn == NULL) { _ReleaseDC(hdc); } } /***************************************************************************\ * DrawOutline * * Draws an outline of a specified thickness using a given brush. * * History: * 03-03-00 JStall - Created \***************************************************************************/ VOID DrawOutline( HDC hdc, int x, int y, int w, int h, int nThick, HBRUSH hbrFill) { POLYPATBLT rgPPB[4]; /* Left */ rgPPB[0].x = x; rgPPB[0].y = y; rgPPB[0].cx = nThick; rgPPB[0].cy = h; rgPPB[0].BrClr.hbr = hbrFill; /* Top */ rgPPB[1].x = x; rgPPB[1].y = y; rgPPB[1].cx = w; rgPPB[1].cy = nThick; rgPPB[1].BrClr.hbr = hbrFill; /* Right */ rgPPB[2].x = x + w - nThick; rgPPB[2].y = y; rgPPB[2].cx = nThick; rgPPB[2].cy = h; rgPPB[2].BrClr.hbr = hbrFill; /* Bottom */ rgPPB[3].x = x; rgPPB[3].y = y + h - nThick; rgPPB[3].cx = w; rgPPB[3].cy = nThick; rgPPB[3].BrClr.hbr = hbrFill; GrePolyPatBlt(hdc, PATCOPY, rgPPB, 4, PPB_BRUSH); } /***************************************************************************\ * MNDrawEdge * * Draws the edge of the menu for flat-menus. The given rectangle can * optionally be modified to exclude the drawn area. * * History: * 03-03-00 JStall - Created \***************************************************************************/ VOID MNDrawEdge( PMENU pmenu, HDC hdc, RECT *prcDraw, UINT nFlags) { int nWidth, nHeight, nBorder, nTemp; HBRUSH hbr; UserAssertMsg0(MNIsFlatMenu(), "Should only be called for flat menus"); nWidth = prcDraw->right - prcDraw->left; nHeight = prcDraw->bottom - prcDraw->top; nBorder = SYSMET(CXBORDER); /* * Draw the flat outline around the menu */ DrawOutline(hdc, 0, 0, nWidth, nHeight, nBorder, SYSHBR(BTNSHADOW)); /* * Draw inside the menu */ nTemp = 2 * nBorder; if (pmenu->hbrBack == NULL) { hbr = SYSHBR(MENU); } else { hbr = pmenu->hbrBack; } DrawOutline(hdc, nBorder, nBorder, nWidth - nTemp, nHeight - nTemp, nTemp, hbr); /* * Adjust the given rectangle from the equivalent calls for 3D-menus * when the non-client area is drawn by DefWindowProc. DrawEdge will * inset the rectangle 2 times. (once for the inner and once for the * outer) With the additional InflateRect() the rectangle gets * insetted 3 times total. */ if (nFlags == BF_ADJUST) { nTemp = -3 * nBorder; InflateRect(prcDraw, nTemp, nTemp); } } /***************************************************************************\ * MNDrawFullNC * * Performs the custom nonclient painting needed for scrollable menus. * Assumes that the given menu is a scrollable menu. * * History: * 08-14-96 GerardoB - Ported from Memphis \***************************************************************************/ VOID MNDrawFullNC( PWND pwnd, HDC hdcIn, PPOPUPMENU ppopup) { RECT rc; HDC hdc; HBRUSH hbrOld; int yTop, yBottom; POINT ptOrg; if (hdcIn == NULL) { hdc = _GetDCEx(pwnd, NULL, DCX_USESTYLE | DCX_WINDOW | DCX_LOCKWINDOWUPDATE); } else { hdc = hdcIn; } rc.left = rc.top = 0; rc.right = pwnd->rcWindow.right - pwnd->rcWindow.left; rc.bottom = pwnd->rcWindow.bottom - pwnd->rcWindow.top; if (MNIsFlatMenu()) { MNDrawEdge(ppopup->spmenu, hdcIn, &rc, BF_ADJUST); } else { DrawEdge(hdc, &rc, EDGE_RAISED, (BF_RECT | BF_ADJUST)); DrawFrame(hdc, &rc, 1, DF_3DFACE); InflateRect(&rc, -SYSMET(CXBORDER), -SYSMET(CYBORDER)); } yTop = rc.top; yBottom = rc.bottom - gcyMenuScrollArrow; GreGetBrushOrg(hdc, &ptOrg); if (ppopup->spmenu->hbrBack != NULL) { GreSetBrushOrg(hdc, 0, -(int)MNGetToppItem(ppopup->spmenu)->yItem, NULL); hbrOld = GreSelectBrush(hdc, ppopup->spmenu->hbrBack); } else { hbrOld = GreSelectBrush(hdc, SYSHBR(MENU)); } rc.right -= rc.left; GrePatBlt(hdc, rc.left, yTop, rc.right, gcyMenuScrollArrow, PATCOPY); MNDrawArrow(hdc, ppopup, MFMWFP_UPARROW); GrePatBlt(hdc, rc.left, yBottom, rc.right, gcyMenuScrollArrow, PATCOPY); MNDrawArrow(hdc, ppopup, MFMWFP_DOWNARROW); GreSetBrushOrg(hdc, ptOrg.x, ptOrg.y, NULL); GreSelectBrush(hdc, hbrOld); if (hdcIn == NULL) { _ReleaseDC(hdc); } } /***************************************************************************\ * MNEraseBackground * * Erases the background making sure that the background pattern (i.e, watermark) * aligns with the pattern in the nonclient area. * * History: * 08-23-96 GerardoB - Created \***************************************************************************/ VOID MNEraseBackground( HDC hdc, PMENU pmenu, int x, int y, int cx, int cy) { BOOL fSetOrg; HBRUSH hbrOld; POINT ptOrg; UserAssert(pmenu->hbrBack != NULL); fSetOrg = TRUE; GreGetBrushOrg(hdc, &ptOrg); /* * If we have scrollbars */ if (pmenu->dwArrowsOn != MSA_OFF) { /* * If not drawing on the client area only */ if (TestMF(pmenu, MFWINDOWDC)) { ptOrg.x = 0; ptOrg.y = -(int)MNGetToppItem(pmenu)->yItem; } else { ptOrg.x = -MNXBORDER; ptOrg.y = -MNYBORDER - gcyMenuScrollArrow - MNGetToppItem(pmenu)->yItem; } } else { if (TestMF(pmenu, MFWINDOWDC)) { ptOrg.x = MNXBORDER; ptOrg.y = MNYBORDER; } else { fSetOrg = FALSE; } } if (fSetOrg) { GreSetBrushOrg(hdc, ptOrg.x, ptOrg.y, &ptOrg); } hbrOld = GreSelectBrush(hdc, pmenu->hbrBack); GrePatBlt(hdc, x, y, cx, cy, PATCOPY); if (fSetOrg) { GreSetBrushOrg(hdc, ptOrg.x, ptOrg.y, NULL); } GreSelectBrush(hdc, hbrOld); } /***************************************************************************\ * MNAnimate * * If fIterate is TRUE, then perform the next iteration in the menu animation * sequence. If fIterate is FALSE, terminate the animation sequence. * * History: * 07-23-96 GerardoB - fixed up for 5.0 \***************************************************************************/ VOID MNAnimate( PMENUSTATE pMenuState, BOOL fIterate) { DWORD dwTimeElapsed; int x, y, xOff, yOff, xLast, yLast; if (TestFadeFlags(FADE_MENU)) { if (!fIterate) { StopFade(); } return; } /* * If we're not animating, bail */ if (pMenuState->hdcWndAni == NULL) { return; } /* * The active popup must be visible. It's supposed to be the * window we're animating */ UserAssert(TestWF(pMenuState->pGlobalPopupMenu->spwndActivePopup, WFVISIBLE)); /* * End animation if asked to do so, if it's taking too long * or someone is waiting for the critical section */ dwTimeElapsed = NtGetTickCount() - pMenuState->dwAniStartTime; if (!fIterate || (dwTimeElapsed > CMS_QANIMATION) || (ExGetExclusiveWaiterCount(gpresUser) > 0) || (ExGetSharedWaiterCount(gpresUser) > 0)) { GreBitBlt(pMenuState->hdcWndAni, 0, 0, pMenuState->cxAni, pMenuState->cyAni, pMenuState->hdcAni, 0, 0, SRCCOPY | NOMIRRORBITMAP, 0xFFFFFF); goto AnimationCompleted; } /* * Remember current animation point and calculate new one */ xLast = pMenuState->ixAni; yLast = pMenuState->iyAni; if (pMenuState->iAniDropDir & PAS_HORZ) { pMenuState->ixAni = MultDiv(gcxMenuFontChar, dwTimeElapsed, CMS_QANIMATION / 20); if (pMenuState->ixAni > pMenuState->cxAni) { pMenuState->ixAni = pMenuState->cxAni; } } if (pMenuState->iAniDropDir & PAS_VERT) { pMenuState->iyAni = MultDiv(gcyMenuFontChar, dwTimeElapsed, CMS_QANIMATION / 10); if (pMenuState->iyAni > pMenuState->cyAni) { pMenuState->iyAni = pMenuState->cyAni; } } /* * if no change -- bail out */ if ((pMenuState->ixAni == xLast) && (pMenuState->iyAni == yLast)) { return; } /* * Calculate source and dest coordinates */ if (pMenuState->iAniDropDir & PAS_LEFT) { x = pMenuState->cxAni - pMenuState->ixAni; xOff = 0; } else { xOff = pMenuState->cxAni - pMenuState->ixAni; x = 0; } if (pMenuState->iAniDropDir & PAS_UP) { y = pMenuState->cyAni - pMenuState->iyAni; yOff = 0; } else { yOff = pMenuState->cyAni - pMenuState->iyAni; y = 0; } /* * Do it */ GreBitBlt(pMenuState->hdcWndAni, x, y, pMenuState->ixAni, pMenuState->iyAni, pMenuState->hdcAni, xOff, yOff, SRCCOPY | NOMIRRORBITMAP, 0xFFFFFF); /* * Check if we're done */ if ((pMenuState->cxAni == pMenuState->ixAni) && (pMenuState->cyAni == pMenuState->iyAni)) { AnimationCompleted: MNDestroyAnimationBitmap(pMenuState); _ReleaseDC(pMenuState->hdcWndAni); pMenuState->hdcWndAni = NULL; _KillTimer(pMenuState->pGlobalPopupMenu->spwndActivePopup, IDSYS_MNANIMATE); } } /***************************************************************************\ * DrawMenuItemCheckMark() - * * Draws the proper check mark for the given item. Note that ownerdraw * items should NOT be passed to this procedure, otherwise we'd draw a * checkmark for them when they are already going to take care of it. * * Returns TRUE is a bitmap was drawn (or at least we attempted to draw it). * * History: \***************************************************************************/ BOOL DrawMenuItemCheckMark( HDC hdc, PITEM pItem, int xPos) { int yCenter; HBITMAP hbm; DWORD textColorSave; DWORD bkColorSave; BOOL fChecked; POEMBITMAPINFO pOem; BOOL fRet = TRUE; DWORD dwFlags = BC_INVERT; UserAssert(hdc != ghdcMem2); pOem = gpsi->oembmi + OBI_MENUCHECK; yCenter = pItem->cyItem - pOem->cy; if (yCenter < 0) yCenter = 0; yCenter /= 2; fChecked = TestMFS(pItem, MFS_CHECKED); if (hbm = (fChecked) ? pItem->hbmpChecked : pItem->hbmpUnchecked) { HBITMAP hbmSave; // Use the app supplied bitmaps. if (hbmSave = GreSelectBitmap(ghdcMem2, hbm)) { textColorSave = GreSetTextColor(hdc, 0x00000000L); bkColorSave = GreSetBkColor (hdc, 0x00FFFFFFL); if (TestMFT(pItem, MFT_RIGHTORDER)) xPos = pItem->cxItem - pOem->cx; GreBitBlt(hdc, xPos, yCenter, pOem->cx, pOem->cy, ghdcMem2, 0, 0, SRCSTENCIL, 0x00FFFFFF); GreSetTextColor(hdc, textColorSave); GreSetBkColor(hdc, bkColorSave); GreSelectBitmap(ghdcMem2, hbmSave); } } else if (fChecked) { if (TestMFT(pItem, MFT_RADIOCHECK)) pOem = gpsi->oembmi + OBI_MENUBULLET; if (TestMFT(pItem, MFT_RIGHTORDER)) xPos = pItem->cxItem - pOem->cx; // 389917: Mirror active menu's check mark if hdc is mirroed. if ((GreGetLayout(hdc) & LAYOUT_RTL) && (hdc != gpDispInfo->hdcGray)) { dwFlags |= BC_NOMIRROR; } BltColor(hdc, NULL, HDCBITS(), xPos, yCenter, pOem->cx, pOem->cy, pOem->x, pOem->y, dwFlags); } else { fRet = FALSE; } return fRet; } /***************************************************************************\ * xxxDrawItemtUnderline * * Draws or hides an underline for a menu item * * 07/23/96 vadimg separated into a separate routine \***************************************************************************/ VOID xxxDrawItemUnderline( PITEM pItem, HDC hdc, int xLeft, int yTop, LPWSTR pszMenu, LONG lResLo) { int cx; PTHREADINFO ptiCurrent = PtiCurrentShared(); // // LOWORD of result is 0xFFFF if there is no underlined character. // Therefore ulX must be valid or be UNDERLINE_RECALC because the item // or menu mode changed. // // Bail out if there isn't one. // if (lResLo == 0xFFFF) { return; } // // For proportional fonts, or if an LPK is installed, find starting // point of underline. // if ((pItem->ulX == UNDERLINE_RECALC) || (PpiCurrent()->dwLpkEntryPoints & LPK_INSTALLED)) { if (lResLo != 0) { SIZE size; if (CALL_LPK(ptiCurrent)) { xxxClientGetTextExtentPointW(hdc, pszMenu, lResLo, &size); } else { GreGetTextExtentW(hdc, pszMenu, lResLo, &size, GGTE_WIN3_EXTENT); } pItem->ulX = size.cx - gcxMenuFontOverhang; } else pItem->ulX = 0; } xLeft += pItem->ulX; // // Adjust for proportional font when setting the length of the underline // and height of text. // // Calculate underline width. if (!pItem->ulWidth) { SIZE size; if (CALL_LPK(ptiCurrent)) { xxxClientGetTextExtentPointW(hdc, pszMenu + lResLo, 1, &size); } else { GreGetTextExtentW(hdc, pszMenu + lResLo, 1, &size, GGTE_WIN3_EXTENT); } pItem->ulWidth = size.cx - gcxMenuFontOverhang; } cx = pItem->ulWidth; // Get ascent of text (units above baseline) so that underline can be drawn // below the text yTop += gcyMenuFontAscent; // Proper brush should be selected into dc. GrePatBlt(hdc, xLeft, yTop, pItem->ulWidth, SYSMET(CYBORDER), PATCOPY); } /***************************************************************************\ * xxxDrawMenuItemText * * Draws menu text with underline. \***************************************************************************/ VOID xxxDrawMenuItemText( PITEM pItem, HDC hdc, int xLeft, int yTop, LPWSTR lpsz, int cch, BOOL fShowUnderlines) { LONG result; WCHAR szMenu[MENU_STRLEN], *pchOut; PTHREADINFO ptiCurrent = PtiCurrentShared(); TL tl; if (cch > MENU_STRLEN) { pchOut = (WCHAR*)UserAllocPool((cch+1) * sizeof(WCHAR), TAG_RTL); if (pchOut == NULL) return; ThreadLockPool(ptiCurrent, pchOut, &tl); } else { pchOut = szMenu; } result = GetPrefixCount(lpsz, cch, pchOut, cch); if (CALL_LPK(ptiCurrent)) { xxxClientExtTextOutW(hdc, xLeft, yTop, 0, NULL, pchOut, cch - HIWORD(result), NULL); } else { GreExtTextOutW(hdc, xLeft, yTop, 0, NULL, pchOut, cch - HIWORD(result), NULL); } if (fShowUnderlines || TEST_BOOL_ACCF(ACCF_KEYBOARDPREF) || TestEffectInvertUP(KEYBOARDCUES) || (GetAppCompatFlags2(VER40) & GACF2_KCOFF)) { if (CALL_LPK(ptiCurrent)) { xxxPSMTextOut(hdc, xLeft, yTop, lpsz, cch, DT_PREFIXONLY); } else{ xxxDrawItemUnderline(pItem, hdc, xLeft, yTop, pchOut, LOWORD(result)); } } if (pchOut != szMenu) { ThreadUnlockAndFreePool(ptiCurrent, &tl); } } /***************************************************************************\ * xxxSendMenuDrawItemMessage * * Sends a WM_DRAWITEM message to the owner of the menu (pMenuState->hwndMenu). * All state is determined in this routine so HILITE state must be properly * set before entering this routine.. * * Revalidation notes: * This routine must be called with a valid and non-NULL pwnd. * Revalidation is not required in this routine: no windows are used after * potentially leaving the critsect. * * History: \***************************************************************************/ VOID xxxSendMenuDrawItemMessage( HDC hdc, UINT itemAction, PMENU pmenu, PITEM pItem, BOOL fBitmap, int iOffset) { DRAWITEMSTRUCT dis; TL tlpwndNotify; int y; CheckLock(pmenu); dis.CtlType = ODT_MENU; dis.CtlID = 0; dis.itemID = pItem->wID; dis.itemAction = itemAction; dis.itemState = ((pItem->fState & MF_GRAYED) ? ODS_GRAYED : 0) | ((pItem->fState & MFS_DEFAULT) ? ODS_DEFAULT : 0) | ((pItem->fState & MFS_CHECKED) ? ODS_CHECKED : 0) | ((pItem->fState & MFS_DISABLED) ? ODS_DISABLED : 0) | (MNDrawHilite(pItem) ? ODS_SELECTED : 0) | ((pItem->fState & MFS_HOTTRACK) ? ODS_HOTLIGHT : 0) | (TestMF(pmenu, MFINACTIVE) ? ODS_INACTIVE : 0) | (!TestMF(pmenu, MFUNDERLINE) ? ODS_NOACCEL : 0); dis.hwndItem = (HWND)PtoH(pmenu); dis.hDC = hdc; y = pItem->yItem; if (fBitmap) { y = (pItem->cyItem - pItem->cyBmp) / 2; } dis.rcItem.left = iOffset + pItem->xItem; dis.rcItem.top = y; dis.rcItem.right = iOffset + pItem->xItem + (fBitmap ? pItem->cxBmp : pItem->cxItem); dis.rcItem.bottom = y + (fBitmap ? pItem->cyBmp : pItem->cyItem); dis.itemData = pItem->dwItemData; if (pmenu->spwndNotify != NULL) { ThreadLockAlways(pmenu->spwndNotify, &tlpwndNotify); xxxSendMessage(pmenu->spwndNotify, WM_DRAWITEM, 0, (LPARAM)&dis); ThreadUnlock(&tlpwndNotify); } } /***************************************************************************\ * CalcbfExtra * * History: * 08-09-96 GerardoB Made into an inline function (code from xxxMenuDraw) \***************************************************************************/ __inline UINT CalcbfExtra( VOID) { if (SYSRGB(3DHILIGHT) == SYSRGB(MENU) && SYSRGB(3DSHADOW) == SYSRGB(MENU)) { return BF_FLAT | BF_MONO; } else { return 0; } } /***************************************************************************\ * MNDrawInsertionBar * * History: * 11/21/96 GerardoB Created \***************************************************************************/ VOID MNDrawInsertionBar( HDC hdc, PITEM pItem) { BOOL fTop; POLYPATBLT PolyData [3], *ppd; /* * If no insertion bar for this item, bail */ fTop = TestMFS(pItem, MFS_TOPGAPDROP); if (!fTop && !TestMFS(pItem, (MFS_BOTTOMGAPDROP))) { return; } /* * Vertical line on the left */ ppd = PolyData; ppd->x = pItem->xItem + SYSMET(CXDRAG); ppd->cx = SYSMET(CXDRAG); ppd->cy = SYSMET(CYDRAG); if (fTop) { ppd->y = pItem->yItem; } else { ppd->y = pItem->yItem + pItem->cyItem - ppd->cy; } ppd->BrClr.hbr = SYSHBR(HIGHLIGHT); /* * Horizontal line in the middle */ ppd++; ppd->x = pItem->xItem + (2 * SYSMET(CXDRAG)); ppd->cx = pItem->cxItem - (4 * SYSMET(CXDRAG)); ppd->cy = SYSMET(CYDRAG) / 2; if (fTop) { ppd->y = pItem->yItem; } else { ppd->y = pItem->yItem + pItem->cyItem - ppd->cy; } ppd->BrClr.hbr = PolyData->BrClr.hbr; /* * Vertical line on the right */ ppd++; ppd->x = pItem->xItem + pItem->cxItem - (2 * SYSMET(CXDRAG)); ppd->cx = PolyData->cx; ppd->cy = PolyData->cy; ppd->y = PolyData->y; ppd->BrClr.hbr = PolyData->BrClr.hbr; GrePolyPatBlt(hdc, PATCOPY, PolyData, 3, PPB_BRUSH); } /***************************************************************************\ * xxxDrawMenuItem * * ! * * History: \***************************************************************************/ VOID xxxDrawMenuItem( HDC hdc, PMENU pMenu, PITEM pItem, DWORD dwFlags) { BOOL fHilite; BOOL fFlatMenuBar; BOOL fFlatMenu; HFONT hfnOld; int tcExtra; UINT uFlags; int iBkSave; hfnOld = NULL; uFlags = DST_COMPLEX; CheckLock(pMenu); fFlatMenu = MNIsFlatMenu(); /* * If the insertion bar is on (MFS_GAPDROP), don't draw the item hilited */ if (fFlatMenu) { fHilite = MNDrawHilite(pItem) || TestMFS(pItem, MFS_HOTTRACK) || TestMFS(pItem, MFS_HOTTRACKDRAWN); fFlatMenuBar = !TestMF(pMenu, MFISPOPUP); } else { fHilite = MNDrawHilite(pItem); fFlatMenuBar = FALSE; } if (TestMFS(pItem, MFS_DEFAULT)) { if (ghMenuFontDef != NULL) hfnOld = GreSelectFont(hdc, ghMenuFontDef); else { uFlags |= DSS_DEFAULT; tcExtra = GreGetTextCharacterExtra(hdc); GreSetTextCharacterExtra(hdc, tcExtra + 1 + (gcxMenuFontChar / gpsi->cxSysFontChar)); } } if (TestMFT(pItem, MFT_OWNERDRAW)) { /* * If ownerdraw, just set the default menu colors since the app is * responsible for handling the rest. */ GreSetTextColor(hdc, SYSRGB(MENUTEXT)); GreSetBkColor(hdc, fFlatMenuBar ? SYSRGB(MENUBAR) : SYSRGB(MENU)); /* * Send drawitem message since this is an ownerdraw item. */ xxxSendMenuDrawItemMessage(hdc, (UINT)((dwFlags & DMI_INVERT) ? ODA_SELECT : ODA_DRAWENTIRE), pMenu, pItem,FALSE,0); // Draw the hierarchical arrow for the cascade menu. if (TestMF(pMenu, MFISPOPUP) && (pItem->spSubMenu != NULL)) { POEMBITMAPINFO pOem; HBRUSH hbr = fHilite ? SYSHBR(HIGHLIGHTTEXT) : SYSHBR(MENUTEXT); pOem = gpsi->oembmi + (TestMFT(pItem, MFT_RIGHTORDER) ? OBI_MENUARROW_L : OBI_MENUARROW); // This item has a hierarchical popup associated with it. Draw the // bitmap dealy to signify its presence. Note we check if fPopup is set // so that this isn't drawn for toplevel menus that have popups. BltColor(hdc, hbr, HDCBITS(), TestMFT(pItem, MFT_RIGHTORDER) ? pItem->xItem + pOem->cx : pItem->xItem + pItem->cxItem - pOem->cx, pItem->yItem + max((INT)(pItem->cyItem - 2 - pOem->cy) / 2, 0), pOem->cx, pOem->cy, pOem->x, pOem->y, BC_INVERT); } } else { COLORREF crBack; COLORREF crFore; GRAYMENU gm; HBRUSH hbrBack; HBRUSH hbrFore; // // Setup colors and state // if (fHilite) { if (fFlatMenu) { crBack = SYSRGB(MENUHILIGHT); hbrBack = SYSHBR(MENUHILIGHT); crFore = SYSRGB(HIGHLIGHTTEXT); hbrFore = SYSHBR(HIGHLIGHTTEXT); } else { /* * If we are not using flat menu's, only draw the highlight if * the item is a popup menu. If it is in the menubar, don't * hilight it since it will be beveled. */ if (TestMF(pMenu, MFISPOPUP)) { crBack = SYSRGB(HIGHLIGHT); hbrBack = SYSHBR(HIGHLIGHT); crFore = SYSRGB(HIGHLIGHTTEXT); hbrFore = SYSHBR(HIGHLIGHTTEXT); } else { goto NormalMenuItem; } } } else if (fFlatMenuBar) { UserAssertMsg0(fFlatMenu, "fFlatMenuBar should only be set for flat menus"); crFore = SYSRGB(MENUTEXT); hbrFore = SYSHBR(MENUTEXT); if (pMenu->hbrBack != NULL) { crBack = SYSRGB(MENUBAR); hbrBack = pMenu->hbrBack; } else { crBack = SYSRGB(MENUBAR); hbrBack = SYSHBR(MENUBAR); } } else { NormalMenuItem: crBack = SYSRGB(MENU); hbrBack = SYSHBR(MENU); crFore = SYSRGB(MENUTEXT); hbrFore = SYSHBR(MENUTEXT); } // B#4157 - Lotus doesn't like it if we draw // its disabled menu items in GRAY, t-arthb // MAKE SURE MF_GRAYED stays 0x0001 NOT 0x0003 for this to fix /* * System bitmaps are already grayed so don't draw them disabled * if the menu is inactive */ if (!MNIsCachedBmpOnly(pItem) && (TestMFS(pItem, MF_GRAYED) || TestMF(pMenu, MFINACTIVE))) { // // Only do embossing if menu color is same as 3D color. The // emboss uses 3D hilight & 3D shadow, which doesn't look cool // on a different background. // if ((fHilite) || (crBack != SYSRGB(3DFACE)) || SYSMET(SLOWMACHINE)) { // // If gray text won't show up on background, then dither. // if (SYSRGB(GRAYTEXT) == crBack) { uFlags |= DSS_UNION; } else { crFore = SYSRGB(GRAYTEXT); hbrFore = SYSHBR(GRAYTEXT); } } else { if ((SYSRGB(3DSHADOW) == crBack) && (SYSRGB(3DHILIGHT) == crBack)) { uFlags |= DSS_UNION; } else { uFlags |= TestMF(pMenu, MFINACTIVE) ? DSS_INACTIVE : DSS_DISABLED; } } } GreSetBkColor(hdc, crBack); GreSetTextColor(hdc, crFore); if (((dwFlags & DMI_INVERT) && (pMenu->hbrBack == NULL)) || fHilite || fFlatMenuBar) { POLYPATBLT PolyData; /* * Only fill the background if we're being called on behalf of * MNInvertItem. This is so that we don't waste time filling * the unselected rect when the menu is first pulled down. * If the menu has a background brush and we were called by * MNInvertItem, that function will have already taken care of * filling the background */ PolyData.x = pItem->xItem; PolyData.y = pItem->yItem; PolyData.cx = pItem->cxItem; PolyData.cy = pItem->cyItem; PolyData.BrClr.hbr = hbrBack; GrePolyPatBlt(hdc, PATCOPY, &PolyData, 1, PPB_BRUSH); if (fHilite && fFlatMenu) { DrawOutline(hdc, pItem->xItem, pItem->yItem, pItem->cxItem, pItem->cyItem, 1, SYSHBR(HIGHLIGHT)); } } if (pMenu->hbrBack != NULL) { iBkSave = GreSetBkMode(hdc, TRANSPARENT); } GreSelectBrush(hdc, hbrFore); // // Draw the image // gm.pItem = pItem; gm.pMenu = pMenu; xxxDrawState(hdc, hbrFore, (LPARAM)(PGRAYMENU)&gm, pItem->xItem, pItem->yItem, pItem->cxItem, pItem->cyItem, uFlags); if (! fFlatMenu) { MNDrawMenu3DHotTracking(hdc, pMenu, pItem); } } /* * Draw the drop insertion bar, if any */ MNDrawInsertionBar (hdc, pItem); if (pMenu->hbrBack != NULL) GreSetBkMode(hdc, iBkSave); if (TestMFS(pItem, MFS_DEFAULT)) { if (hfnOld) GreSelectFont(hdc, hfnOld); else GreSetTextCharacterExtra(hdc, tcExtra); } } extern void SetupFakeMDIAppStuff(PMENU lpMenu, PITEM lpItem); /***************************************************************************\ * * xxxRealDrawMenuItem() * * Callback from xxxDrawState() to draw the menu item, either normally or into * an offscreen bitmp. We don't know where we're drawing, and shouldn't * have to. * \***************************************************************************/ BOOL CALLBACK xxxRealDrawMenuItem( HDC hdc, PGRAYMENU pGray, int cx, int cy) { PMENU pMenu; PITEM pItem; BOOL fPopup; int cch; int xLeft; int yTop; int tp; int rp; LPWSTR lpsz; int cyTemp; int xHilite = 0; int yHilite = 0; TL tlpwndChild; PTHREADINFO ptiCurrent = PtiCurrent(); BOOL fCheckDrawn = FALSE; int xFarLeft; // // BOGUS // Use cx and cy instead of lpItem->cxItem, lpItem->cyItem to // speed stuff up. // pMenu = pGray->pMenu; CheckLock(pMenu); pItem = pGray->pItem; fPopup = TestMF(pMenu, MFISPOPUP); if (fPopup) { xLeft = MNLEFTMARGIN; if (TestMF(pMenu, MNS_NOCHECK)) { xLeft += MNXSPACE; } else { fCheckDrawn = DrawMenuItemCheckMark(hdc, pItem, xLeft); if (!TestMF(pMenu, MNS_CHECKORBMP) || ((pItem->hbmp == NULL) || fCheckDrawn)) { xLeft += TestMFT(pItem, MFT_RIGHTORDER) ? 0 : (gpsi->oembmi[OBI_MENUCHECK].cx + MNXSPACE); } } } else { xLeft = 0; /* * If not drawing flat menus in the menubar, "depress" the menu item * when it becomes highlighted. */ if ((! MNIsFlatMenu()) && TestMFS(pItem, MFS_HILITE)) { xHilite = CXMENU3DEDGE; yHilite = CYMENU3DEDGE; } } /* * If there is not bitmap or we don't to draw it, go draw the text */ if ((pItem->hbmp == NULL) || (fCheckDrawn && TestMF(pMenu, MNS_CHECKORBMP))) { goto RealDrawMenuItemText; } /* * Draw the bitmap */ if (TestMFS(pItem, MFS_CACHEDBMP)) { if (pItem->hbmp == HBMMENU_SYSTEM) { /* * Drawing app icon (system menu) */ PWND pwndChild; PICON pIcon = NULL; UINT cyUse, cxUse; AintNothingLikeTheRealMDIThing: if (!(pItem->dwItemData)) SetupFakeMDIAppStuff(pMenu, pItem); pwndChild = HMValidateHandleNoRip((HWND)(pItem->dwItemData),TYPE_WINDOW); if (!pwndChild) { // // Oops, child window isn't valid anymore. Go find // the new one. // if (pItem->dwItemData) { pItem->dwItemData = 0; goto AintNothingLikeTheRealMDIThing; } pIcon = NULL; } else { ThreadLock(pwndChild, &tlpwndChild); pIcon = xxxGetWindowSmIcon(pwndChild, FALSE); ThreadUnlock(&tlpwndChild); } if (!pIcon) pIcon = SYSICO(WINLOGO); cyUse = cy - SYSMET(CYEDGE); cxUse = cx - (SYSMET(CXEDGE) * 2); /* * If this is a popup, make sure that no weird * width/height stretch takes place. */ if (fPopup && (cyUse < cxUse)) { cxUse = cyUse; } _DrawIconEx(hdc, xLeft + (SYSMET(CXEDGE) * 2), SYSMET(CYBORDER), pIcon, cxUse, cyUse, 0, SYSHBR(MENU), DI_NORMAL | DI_NOMIRROR); } else { /* * This is a cached bitmap */ UINT wBmp; int xBmpLeft = xLeft; int y; POEMBITMAPINFO pOem; switch ((ULONG_PTR)pItem->hbmp) { case (ULONG_PTR)HBMMENU_MBAR_RESTORE: wBmp = OBI_RESTORE_MBAR; goto DrawSysBmp; case (ULONG_PTR)HBMMENU_MBAR_MINIMIZE: wBmp = OBI_REDUCE_MBAR; xBmpLeft += SYSMET(CXEDGE); goto DrawSysBmp; case (ULONG_PTR)HBMMENU_MBAR_CLOSE: wBmp = OBI_CLOSE_MBAR; goto DrawSysBmp; case (ULONG_PTR)HBMMENU_MBAR_CLOSE_D: wBmp = OBI_CLOSE_MBAR_I; goto DrawSysBmp2; case (ULONG_PTR)HBMMENU_MBAR_MINIMIZE_D: wBmp = OBI_REDUCE_MBAR_I; xBmpLeft += SYSMET(CXEDGE); goto DrawSysBmp2; DrawSysBmp: /* * Select proper bitmap based on the item state */ if (TestMFS(pItem, MFS_HILITE)) { wBmp += DOBI_PUSHED; } DrawSysBmp2: BitBltSysBmp(hdc, xBmpLeft, SYSMET(CYEDGE), wBmp); break; default: UserAssert((pItem->hbmp >= HBMMENU_POPUPFIRST) && (pItem->hbmp <= HBMMENU_POPUPLAST)); wBmp = OBI_POPUPFIRST + HandleToUlong(pItem->hbmp) - HandleToUlong(HBMMENU_POPUPFIRST); UserAssert(wBmp < OBI_COUNT); pOem = gpsi->oembmi + wBmp; y = (pItem->cyItem - pOem->cy) / 2; if (y < 0) { y = 0; } BltColor(hdc, NULL, HDCBITS(), xLeft, y, pOem->cx, pOem->cy, pOem->x, pOem->y, BC_INVERT); break; } } /* if (pItem->hbmp == HBMMENU_SYSTEM) */ } else if (pItem->hbmp == HBMMENU_CALLBACK) { /* * Owner draw bitmap */ xxxSendMenuDrawItemMessage(hdc,ODA_DRAWENTIRE, pMenu, pItem, TRUE, xLeft); } else { /* * Drawing a regular bitmap. */ int dx, dy; HBITMAP hbmSave; // // Is this the zero'th item in a menu bar that's not all // bitmaps? Hmm, sounds like it could be a fake MDI dude. // If it is, use the windows icon instead // /* * Let's fail this for > 4.0 apps so we can get rid of * this horrible hack someday. The HBMMENU_ constants * have been made public so people can use them freely. * * Note: even if the app is marked as 4.0, he could be * recompiled and may utilizes the new feature in NT5 menu. * So just in case, we have to check both dwItemData and lpstr * so that the menu could have bitmap, dwItemData and a menu string. * */ if (LOWORD(ptiCurrent->dwExpWinVer) <= VER40) { if (pItem->dwItemData && pItem->lpstr == NULL) goto AintNothingLikeTheRealMDIThing; else if (!fPopup && (pItem == pMenu->rgItems) && (pMenu->cItems > 1) && !(pMenu->rgItems[1].hbmp) && (pItem->spSubMenu)) { RIPMSG0(RIP_WARNING, "Fake MDI detected, using window icon in place of bitmap"); goto AintNothingLikeTheRealMDIThing; } } UserAssert(hdc != ghdcMem2); dx = pItem->cxBmp; if (fPopup) { dy = pItem->cyBmp; // // Center bitmap in middle of item area // cyTemp = (pItem->cyItem - dy); if (cyTemp > 0) cyTemp = cyTemp / 2; else cyTemp = 0; } else { dy = max(pItem->cyBmp, SYSMET(CYMENUSIZE)); cyTemp = 0; if (pItem->lpstr != NULL) { xLeft += gcxMenuFontChar; } } if (hbmSave = GreSelectBitmap(ghdcMem2, pItem->hbmp)) { BITMAP bmp; // // Draw the bitmap leaving some room on the left for the // optional check mark if we are in a popup menu. (as opposed // to a top level menu bar). // // We can do cool stuff with monochrome bitmap itmes // by merging with the current colors. // // If the item is selected and the bitmap isn't monochrome, // we just invert the thing when we draw it. We can't do // anything more clever unless we want to convert to // monochrome. // GreExtGetObjectW(pItem->hbmp, sizeof(bmp), (LPSTR)&bmp); GreBitBlt(hdc, xLeft + xHilite, cyTemp + xHilite, dx, dy, ghdcMem2, 0, 0, (bmp.bmPlanes * bmp.bmBitsPixel == 1) ? SRCSTENCIL : (MNDrawHilite(pItem) ? NOTSRCCOPY : SRCCOPY), 0x00FFFFFF); GreSelectBitmap(ghdcMem2, hbmSave); } else { RIPMSG3(RIP_WARNING, "Menu 0x%08X, item 0x%08X: Tried to draw invalid bitmap 0x%08X", pMenu, pItem, pItem->hbmp) ; } } RealDrawMenuItemText: if (pItem->lpstr != NULL) { /* * We want the text in all popup menu items to be aligned * if an alignment offset is available. */ if (fPopup && (pMenu->cxTextAlign != 0)) { xLeft = pMenu->cxTextAlign; } else if (pItem->hbmp != NULL) { xLeft += pItem->cxBmp + SYSMET(CXEDGE); } // This item is a text string item. Display it. yTop = gcyMenuFontExternLeading; cyTemp = pItem->cyItem - (gcyMenuFontChar + gcyMenuFontExternLeading + SYSMET(CYBORDER)); if (cyTemp > 0) yTop += (cyTemp / 2); if (!fPopup && (pItem->hbmp == NULL)) { xLeft += gcxMenuFontChar; } lpsz = TextPointer(pItem->lpstr); if (lpsz!=NULL) { cch = pItem->cch; // Even though we no longer support any funky handling of the // help prefix character, we still need to eat it up if we run // across it so that the menu item is drawn correctly if ((*lpsz == CH_HELPPREFIX) && !fPopup) { // Skip help prefix character. lpsz++; cch--; } // tp will contain the character position of the \t indicator // in the menu string. This is where we add a tab to the string. // // rp will contain the character position of the \a indicator // in the string. All text following this is right aligned. tp = FindCharPosition(lpsz, TEXT('\t')); rp = FindCharPosition(lpsz, TEXT('\t') - 1); xFarLeft = pItem->cxItem - (gpsi->oembmi[OBI_MENUCHECK].cx + MNXSPACE); if (rp && (rp != cch)) { // Display all the text up to the \a if (TestMFT(pItem, MFT_RIGHTORDER) && fPopup) { SIZE extent; xxxPSMGetTextExtent(hdc, lpsz, rp, &extent); xLeft = xFarLeft - extent.cx; } xxxDrawMenuItemText(pItem, hdc, xLeft + xHilite, yTop + xHilite, lpsz, rp, TestMF(pMenu, MFUNDERLINE)); // Do we also have a tab beyond the \a ?? if (tp > rp + 1) { SIZE extent; if (TestMFT(pItem, MFT_RIGHTORDER) && fPopup) { xLeft = xFarLeft - pItem->dxTab ; } else { xxxPSMGetTextExtent(hdc, lpsz + rp + 1, (UINT)(tp - rp - 1), &extent); xLeft = (int)(pItem->dxTab - extent.cx); } // // lotus in Hebrew make their menus by putting the // accelerator on the left and the text on the right // xxxPSMTextOut(hdc, xLeft, yTop, (LPWSTR)(lpsz + rp + 1), tp - rp - 1, TestMF(pMenu, MFUNDERLINE) ? 0 : DT_HIDEPREFIX); } } else if (tp && rp == cch) { // Display text up to the tab position if (TestMFT(pItem, MFT_RIGHTORDER)) { SIZE extent; xxxPSMGetTextExtent(hdc, lpsz, tp, &extent); xLeft = xFarLeft - extent.cx; if (!fPopup && (pItem->hbmp == NULL)) { xLeft += gcxMenuFontChar; } } xxxDrawMenuItemText(pItem, hdc, xLeft + xHilite, yTop + xHilite, lpsz, tp, TestMF(pMenu, MFUNDERLINE)); } // Any text left to display (like after the tab) ?? if (tp < cch - 1) { if (TestMFT(pItem, MFT_RIGHTORDER) && fPopup) { SIZE extent; xxxPSMGetTextExtent(hdc, lpsz + tp + 1, (int)cch - tp - 1, &extent); xLeft = pItem->cxItem - pItem->dxTab - extent.cx; } else { xLeft = pItem->dxTab + gcxMenuFontChar; } xxxPSMTextOut(hdc, xLeft, yTop, lpsz + tp + 1, cch - tp - 1, TestMF(pMenu, MFUNDERLINE) ? 0 : DT_HIDEPREFIX); } } } // // Draw the hierarchical arrow for the cascade menu. // if (fPopup && (pItem->spSubMenu != NULL)) { POEMBITMAPINFO pOem; pOem = gpsi->oembmi + (TestMFT(pItem, MFT_RIGHTORDER) ? OBI_MENUARROW_L : OBI_MENUARROW); // This item has a hierarchical popup associated with it. Draw the // bitmap dealy to signify its presence. Note we check if fPopup is set // so that this isn't drawn for toplevel menus that have popups. BltColor(hdc, NULL, HDCBITS(), TestMFT(pItem, MFT_RIGHTORDER) ? pOem->cx : pItem->cxItem - pOem->cx, max((INT)(pItem->cyItem - 2 - pOem->cy) / 2, 0), pOem->cx, pOem->cy, pOem->x, pOem->y, BC_INVERT); } return TRUE; } /***************************************************************************\ * xxxMenuBarDraw * * History: * 11-Mar-1992 mikeke From win31 \***************************************************************************/ int xxxMenuBarDraw( PWND pwnd, HDC hdc, int cxFrame, int cyFrame) { UINT cxMenuMax; UINT cyMenu; int yTop; PMENU pMenu; BOOL fClipped = FALSE; TL tlpMenu; HBRUSH hbrT; CheckLock(pwnd); pMenu = pwnd->spmenu; if (pMenu == NULL) { return SYSMET(CYBORDER); } /* * NT5 menus are drawn inactive when the window is not active. */ if (TestwndFrameOn(pwnd) || (GetAppCompatFlags2(VER40) & GACF2_ACTIVEMENUS)) { ClearMF(pMenu, MFINACTIVE); } else { SetMF(pMenu, MFINACTIVE); } /* * Lock the menu so we can poke around. */ ThreadLockMenuNoModify(pMenu, &tlpMenu); yTop = cyFrame; yTop += GetCaptionHeight(pwnd); /* * Calculate maximum available horizontal real estate */ cxMenuMax = (pwnd->rcWindow.right - pwnd->rcWindow.left) - cxFrame * 2; /* * If the menu has switched windows, or if either count is 0, * then we need to recompute the menu width. */ if (pwnd != pMenu->spwndNotify || pMenu->cxMenu == 0 || pMenu->cyMenu == 0) { xxxMenuBarCompute(pMenu, pwnd, yTop, cxFrame, cxMenuMax); } /* * If the menu rectangle is wider than allowed, or the * bottom would overlap the size border, we need to clip. */ if (pMenu->cxMenu > cxMenuMax || (int)(yTop + pMenu->cyMenu) > (int)((pwnd->rcWindow.bottom - pwnd->rcWindow.top) - cyFrame)) { /* * Lock the display while we're playing around with visrgns. Make * a local copy of the saved-visrgn so it can be restored in case * we make a callback (i.e. WM_DRAWITEM). */ GreLockDisplay(gpDispInfo->hDev); fClipped = TRUE; GreIntersectVisRect(hdc, pwnd->rcWindow.left + cxFrame, pwnd->rcWindow.top, pwnd->rcWindow.left + cxFrame + cxMenuMax, pwnd->rcWindow.bottom - cyFrame); GreUnlockDisplay(gpDispInfo->hDev); } { // Draw menu background in MENU color // Draw border under menu in proper BORDER color POLYPATBLT PolyData[2]; BOOL fFlatMenu; /* * We can't use MFISPOPUP to determine if we are drawing a menu bar. * This is because a menu can be created as a popup, but then attached * to a window using SetMenu(), making it a menubar. */ fFlatMenu = MNIsFlatMenu(); PolyData[0].x = cxFrame; PolyData[0].y = yTop; PolyData[0].cx = pMenu->cxMenu; PolyData[0].cy = pMenu->cyMenu; PolyData[0].BrClr.hbr = (pMenu->hbrBack) ? pMenu->hbrBack : (fFlatMenu ? SYSHBR(MENUBAR) : SYSHBR(MENU)); PolyData[1].x = cxFrame; PolyData[1].y = yTop + pMenu->cyMenu; PolyData[1].cx = pMenu->cxMenu; PolyData[1].cy = SYSMET(CYBORDER); PolyData[1].BrClr.hbr = (TestWF(pwnd, WEFEDGEMASK) && !TestWF(pwnd, WFOLDUI))? SYSHBR(3DFACE) : SYSHBR(WINDOWFRAME); GrePolyPatBlt(hdc,PATCOPY,&PolyData[0],2,PPB_BRUSH); } /* * Finally, draw the menu itself. */ hbrT = GreSelectBrush(hdc, (TestWF(pwnd, WEFEDGEMASK) && !TestWF(pwnd, WFOLDUI))? SYSHBR(3DFACE) : SYSHBR(WINDOWFRAME)); xxxMenuDraw(hdc, pMenu); GreSelectBrush(hdc, hbrT); if (fClipped) { /* * Recalculate the DC visrgn after calling back. */ PDCE pdce; if ((pdce = LookupDC(hdc)) != NULL) { InvalidateDce(pdce); } } cyMenu = pMenu->cyMenu + SYSMET(CYBORDER); ThreadUnlockMenuNoModify(&tlpMenu); return cyMenu; } /***************************************************************************\ * xxxMenuDraw * * Draws the menu * * Revalidation notes: * This routine must be called with a valid and non-NULL pwnd. * * History: \***************************************************************************/ VOID xxxMenuDraw( HDC hdc, PMENU pmenu) { PITEM pItem; UINT i, cy; RECT rcItem; HFONT hFontOld; UINT bfExtra; PTHREADINFO ptiCurrent = PtiCurrent(); UINT oldAlign; int iBkSave; POINT ptOrg; CheckLock(pmenu); if (pmenu == NULL) { RIPERR0(ERROR_INVALID_HANDLE, RIP_WARNING, "xxxMenuDraw: Invalid menu handle (NULL)"); return; } GreGetViewportOrg(hdc, &ptOrg); hFontOld = GreSelectFont(hdc, ghMenuFont); oldAlign = GreGetTextAlign(hdc); if (pmenu->rgItems && TestMFT(pmenu->rgItems, MFT_RIGHTORDER)) { GreSetTextAlign(hdc, oldAlign | TA_RTLREADING); } bfExtra = CalcbfExtra(); if (pmenu->hbrBack != NULL) { iBkSave = GreSetBkMode(hdc, TRANSPARENT); } if (pmenu->dwArrowsOn != MSA_OFF) { pItem = MNGetToppItem(pmenu); GreSetViewportOrg(hdc, ptOrg.x, ptOrg.y - ((int)pItem->yItem), NULL); i = pmenu->iTop; } else { pItem = (PITEM)pmenu->rgItems; i = 0; } cy = 0; for (; i < pmenu->cItems; i++, pItem++) { if (TestMFT(pItem, MFT_MENUBARBREAK) && TestMF(pmenu, MFISPOPUP)) { // // Draw a vertical etch. This is done by calling DrawEdge(), // sunken, with BF_LEFT | BF_RIGHT. // if(TestMFT(pItem, MFT_RIGHTORDER) && i) { // // going backwards, so the correct place is just before the // _previous_ item. // PITEM pi; pi = pItem - 1; rcItem.left = pi->xItem - SYSMET(CXFIXEDFRAME); rcItem.top = 0; rcItem.right = pi->xItem - SYSMET(CXBORDER); rcItem.bottom = pmenu->cyMenu; } else { rcItem.left = pItem->xItem - SYSMET(CXFIXEDFRAME); rcItem.top = 0; rcItem.right = pItem->xItem - SYSMET(CXBORDER); rcItem.bottom = pmenu->cyMenu; } DrawEdge(hdc, &rcItem, BDR_SUNKENOUTER, BF_LEFT | BF_RIGHT | bfExtra); } /* * If this is a separator, draw it and return. * 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 */ if (TestMFT(pItem, MFT_SEPARATOR) && (!TestMFT(pItem, MFT_OWNERDRAW) || (LOWORD(ptiCurrent->dwExpWinVer) < VER40))) { /* * Draw a horizontal etch. */ int yT = pItem->yItem + (pItem->cyItem / 2) - SYSMET(CYBORDER); RECT rcItem; rcItem.left = pItem->xItem + 1; rcItem.top = yT; rcItem.right = pItem->xItem + pItem->cxItem - 1; rcItem.bottom = yT + SYSMET(CYEDGE); DrawEdge(hdc, &rcItem, BDR_SUNKENOUTER, BF_TOP | BF_BOTTOM | bfExtra); /* * Draw drop insertion bar, if any. */ MNDrawInsertionBar (hdc, pItem); } else { xxxDrawMenuItem(hdc, pmenu, pItem, 0); } if (pmenu->dwArrowsOn != MSA_OFF) { cy += pItem->cyItem; if (cy > pmenu->cyMenu) { /* * This is a scrollable menu and the item just drawn falls below * the bottom of the visible menu -- no need to draw any further */ break; } } } if (pmenu->hbrBack != NULL) { GreSetBkMode(hdc, iBkSave); } GreSetViewportOrg(hdc, ptOrg.x, ptOrg.y, NULL); GreSetTextAlign(hdc, oldAlign); GreSelectFont(hdc, hFontOld); } /***************************************************************************\ * xxxDrawMenuBar * * Forces redraw of the menu bar * * History: \***************************************************************************/ BOOL xxxDrawMenuBar( PWND pwnd) { CheckLock(pwnd); if (!TestwndChild(pwnd)) { xxxRedrawFrame(pwnd); } return TRUE; } /***************************************************************************\ * xxxMenuInvert * * Invert menu item * * Revalidation notes: * This routine must be called with a valid and non-NULL pwnd. * * fOn - TRUE if the item is selected thus it needs to be inverted * fNotify - TRUE if the parent should be notified (as appropriate), FALSE * if we are just redrawing the selected item. * * History: \***************************************************************************/ PITEM xxxMNInvertItem( PPOPUPMENU ppopupmenu, PMENU pmenu, int itemNumber, PWND pwndNotify, BOOL fOn) { PITEM pItem = NULL; HDC hdc; int y, iNewTop; RECT rcItem; BOOL fSysMenuIcon = FALSE; PMENU pmenusys; BOOL fClipped = FALSE; HFONT hOldFont; PWND pwnd; POINT ptOrg; TL tlpwnd; UINT oldAlign; CheckLock(pmenu); CheckLock(pwndNotify); /* * If we are in the middle of trying to get out of menu mode, hMenu * and/or pwndNotify will be NULL, so just bail out now. */ if ((pmenu == NULL) || (pwndNotify == NULL)) { return NULL; } /* * If ppopupmenu is NULL, we're not in menu mode (i.e, call from * HiliteMenuItem). */ if (ppopupmenu == NULL) { pwnd = pwndNotify; } else { pwnd = ppopupmenu->spwndPopupMenu; } if (pwnd != pwndNotify) { ThreadLock(pwnd, &tlpwnd); } if (itemNumber < 0) { if (ppopupmenu != NULL) { if ((itemNumber == MFMWFP_UPARROW) || (itemNumber == MFMWFP_DOWNARROW)) { MNDrawArrow(NULL, ppopupmenu, itemNumber); } } xxxSendMenuSelect(pwndNotify, pwnd, pmenu, itemNumber); goto SeeYa; } if (!TestMF(pmenu, MFISPOPUP)) { pmenusys = xxxGetSysMenuHandle(pwndNotify); if (pmenu == pmenusys) { MNPositionSysMenu(pwndNotify, pmenusys); fSysMenuIcon = TRUE; } } if ((UINT)itemNumber >= pmenu->cItems) goto SeeYa; pItem = &pmenu->rgItems[itemNumber]; if (!TestMF(pmenu, MFISPOPUP) && TestWF(pwndNotify, WFMINIMIZED)) { /* * Skip inverting top level menus if the window is iconic. */ goto SeeYa; } /* * Is this a separator? */ if (TestMFT(pItem, MFT_SEPARATOR)) { goto SendSelectMsg; } if ((BOOL)TestMFS(pItem, MFS_HILITE) == (BOOL)fOn) { /* * Item's state isn't really changing. Just return. */ goto SeeYa; } if (fOn && (ppopupmenu != NULL) && (pmenu->dwArrowsOn != MSA_OFF)) { /* * when selecting an item, ensure that the item is fully visible * NOTE -- For mouse use, partially visible should be acceptable * -- Can we get mouse info down this far ? */ if (itemNumber < pmenu->iTop) { iNewTop = itemNumber; goto NewTop; } else { PITEM pWalk = MNGetToppItem(pmenu); int dy = pItem->yItem + pItem->cyItem - pWalk->yItem - pmenu->cyMenu; iNewTop = pmenu->iTop; while ((dy > 0) && (iNewTop < (int)pmenu->cItems)) { dy -= pWalk->cyItem; pWalk++; iNewTop++; } if (iNewTop >= (int)pmenu->cItems) { iNewTop = pmenu->cItems; } NewTop: if (xxxMNSetTop(ppopupmenu, iNewTop)) { xxxUpdateWindow(pwnd); } } } rcItem.left = pItem->xItem; rcItem.top = pItem->yItem; rcItem.right = pItem->xItem + pItem->cxItem; rcItem.bottom = pItem->yItem + pItem->cyItem; y = pItem->cyItem; if (TestMF(pmenu, MFISPOPUP)) { hdc = _GetDC(pwnd); } else { hdc = _GetWindowDC(pwnd); if (TestWF(pwnd, WFSIZEBOX) && !fSysMenuIcon) { /* * If the window is small enough that some of the menu bar has been * obscured by the frame, we don't want to draw on the bottom of the * sizing frame. Note that we don't want to do this if we are * inverting the system menu icon since that will be clipped to the * window rect. (otherwise we end up with only half the sys menu * icon inverted) */ int xMenuMax = (pwnd->rcWindow.right - pwnd->rcWindow.left) - SYSMET(CXSIZEFRAME); if (rcItem.right > xMenuMax || rcItem.bottom > ((pwnd->rcWindow.bottom - pwnd->rcWindow.top) - SYSMET(CYSIZEFRAME))) { /* * Lock the display while we're playing around with visrgns. * Make a local copy of the visrgn, so that it can be * properly restored on potential callbacks (i.e. WM_DRAWITEM). */ GreLockDisplay(gpDispInfo->hDev); fClipped = TRUE; GreIntersectVisRect(hdc, pwnd->rcWindow.left + rcItem.left, pwnd->rcWindow.top + rcItem.top, pwnd->rcWindow.left + xMenuMax, pwnd->rcWindow.bottom - SYSMET(CYSIZEFRAME)); GreUnlockDisplay(gpDispInfo->hDev); } } } oldAlign = GreGetTextAlign(hdc); if (pItem && TestMFT(pItem, MFT_RIGHTORDER)) GreSetTextAlign(hdc, oldAlign | TA_RTLREADING); hOldFont = GreSelectFont(hdc, ghMenuFont); GreGetViewportOrg(hdc, &ptOrg); if (fOn) { SetMFS(pItem, MFS_HILITE); } else { ClearMFS(pItem, MFS_HILITE); } if (!fSysMenuIcon && ((pItem->hbmp != HBMMENU_SYSTEM) || (TestMF(pmenu, MFISPOPUP)))) { if (pmenu->dwArrowsOn != MSA_OFF) { GreSetViewportOrg(hdc, ptOrg.x, ptOrg.y - ((int)MNGetToppItem(pmenu)->yItem), NULL); } if ((pmenu->hbrBack != NULL) && !MNDrawHilite(pItem) && !TestMFT(pItem, MFT_OWNERDRAW)) { /* * fill the background here so xxxDrawMenuItem doesn't have to fool * around with hbrBack */ int iBkSave = GreSetBkMode(hdc, TRANSPARENT); MNEraseBackground (hdc, pmenu, pItem->xItem, pItem->yItem, pItem->cxItem, pItem->cyItem); GreSetBkMode(hdc, iBkSave); } xxxDrawMenuItem(hdc, pmenu, pItem, DMI_INVERT); } if (fClipped) { /* * Recalculate the DC visrgn after calling back. */ PDCE pdce; if ((pdce = LookupDC(hdc)) != NULL) { InvalidateDce(pdce); } } GreSelectFont(hdc, hOldFont); GreSetViewportOrg(hdc, ptOrg.x, ptOrg.y, NULL); GreSetTextAlign(hdc, oldAlign); _ReleaseDC(hdc); SendSelectMsg: /* * send select msg only if we are selecting an item. */ if (fOn) { xxxSendMenuSelect(pwndNotify, pwnd, pmenu, itemNumber); } SeeYa: if (pwnd != pwndNotify) { ThreadUnlock(&tlpwnd); } return pItem; } /***************************************************************************\ * xxxDrawMenuBarTemp * * This is so the control panel can let us do the work -- and make their * preview windows that much more accurate. The only reason I put the hwnd in * here is because, in the low level menu routines, we assume that an hwnd is * associated with the hmenu -- I didn't want to slow that code down by adding * NULL checks. * * The SYSMET(CYMENU) with regard to the given font is returned -- this * way control panel can say, "The user wants this menu font (hfont) with this * menu height (lprc)", and we can respond "this is the height we ended up * using." * * NOTE: It's OK to over-write lprc because this function receives a pointer * to the rectangle captured in NtUserDrawMenuBarTemp. * * History: * 20-Sep-95 BradG Ported from Win95 (inctlpan.c) \***************************************************************************/ int xxxDrawMenuBarTemp( PWND pwnd, HDC hdc, LPRECT lprc, PMENU pMenu, HFONT hfont) { int cyMenu; HFONT hOldFont; HFONT hFontSave; int cxCharSave; int cxOverhangSave; int cyCharSave; int cyLeadingSave; int cyAscentSave; int cySizeSave; PWND pwndNotify; TL tlpwndNotify; hFontSave = ghMenuFont; cxCharSave = gcxMenuFontChar; cxOverhangSave = gcxMenuFontOverhang; cyCharSave = gcyMenuFontChar; cyLeadingSave = gcyMenuFontExternLeading; cyAscentSave = gcyMenuFontAscent; cySizeSave = SYSMET(CYMENUSIZE); CheckLock(pwnd); CheckLock(pMenu); ThreadLock(pMenu->spwndNotify, &tlpwndNotify); pwndNotify = pMenu->spwndNotify; cyMenu = lprc->bottom - lprc->top; if (hfont) { TEXTMETRIC textMetrics; /* * Compute the new menu font info if needed */ ghMenuFont = hfont; hOldFont = GreSelectFont(HDCBITS(), ghMenuFont); gcxMenuFontChar = GetCharDimensions( HDCBITS(), &textMetrics, &gcyMenuFontChar); gcxMenuFontOverhang = textMetrics.tmOverhang; GreSelectFont(HDCBITS(), hOldFont); gcyMenuFontExternLeading = textMetrics.tmExternalLeading; gcyMenuFontAscent = textMetrics.tmAscent + SYSMET(CYBORDER); } cyMenu -= SYSMET(CYBORDER); cyMenu = max(cyMenu, (gcyMenuFontChar + gcyMenuFontExternLeading + SYSMET(CYEDGE))); SYSMET(CYMENUSIZE) = cyMenu; SYSMET(CYMENU) = cyMenu + SYSMET(CYBORDER); /* * Compute the dimensons of the menu (hope that we don't leave the * USER critical section) */ xxxMenuBarCompute(pMenu, pwnd, lprc->top, lprc->left, lprc->right); /* * Draw menu border in menu color */ lprc->bottom = lprc->top + pMenu->cyMenu; FillRect(hdc, lprc, MNIsFlatMenu() ? SYSHBR(MENUBAR) : SYSHBR(MENU)); /* * Finally, draw the menu itself. */ xxxMenuDraw(hdc, pMenu); /* * Restore the old state */ ghMenuFont = hFontSave; gcxMenuFontChar = cxCharSave; gcxMenuFontOverhang = cxOverhangSave; gcyMenuFontChar = cyCharSave; gcyMenuFontExternLeading = cyLeadingSave; gcyMenuFontAscent = cyAscentSave; SYSMET(CYMENUSIZE) = cySizeSave; cyMenu = SYSMET(CYMENU); SYSMET(CYMENU) = cySizeSave + SYSMET(CYBORDER); Lock(&pMenu->spwndNotify, pwndNotify); ThreadUnlock(&tlpwndNotify); return cyMenu; } /***************************************************************************\ * xxxDrawMenuBarUnderlines * * Description: Shows or hides all underlines on a menu bar. * * History: * 07/23/96 vadimg created \***************************************************************************/ VOID xxxDrawMenuBarUnderlines( PWND pwnd, BOOL fShow) { HDC hdc; PMENU pmenu; PITEM pitem; ULONG i, yTop, cyTemp; LPWSTR psz; WCHAR szMenu[MENU_STRLEN], *pchOut; LONG result; HBRUSH hbr; TL tlpMenu; PTHREADINFO ptiCurrent = PtiCurrentShared(); int xLeft; LPWSTR lpsz; SIZE extent; BOOL fFlatMenuBar; CheckLock(pwnd); /* * Bail if menu underlines are always on. */ if (TEST_BOOL_ACCF(ACCF_KEYBOARDPREF) || TestEffectInvertUP(KEYBOARDCUES) || (GetAppCompatFlags2(VER40) & GACF2_KCOFF)) { return; } // if there is no menu, bail out right away pwnd = GetTopLevelWindow(pwnd); if (pwnd == NULL || !TestWF(pwnd, WFMPRESENT)) { return; } /* * We don't clear WFMPRESENT when the menu is unlocked so make sure we have * one. */ pmenu = pwnd->spmenu; if (pmenu == NULL) { return; } if (MNIsFlatMenu()) { fFlatMenuBar = !TestMF(pmenu, MFISPOPUP); } else { fFlatMenuBar = FALSE; } /* * set/clear the underline state. There are cases when the * menu loop doesn't remove the keys from the queue; so after * exiting we might get here but nothing needs to be drawn */ if (fShow) { if (TestMF(pmenu, MFUNDERLINE)) { return; } hbr = SYSHBR(MENUTEXT); SetMF(pmenu, MFUNDERLINE); } else { if (!TestMF(pmenu, MFUNDERLINE)) { return; } if (pmenu->hbrBack != NULL) { hbr = pmenu->hbrBack; } else if (fFlatMenuBar) { hbr = SYSHBR(MENUBAR); } else { hbr = SYSHBR(MENU); } ClearMF(pmenu, MFUNDERLINE); } pitem = (PITEM)pmenu->rgItems; hdc = _GetDCEx(pwnd, NULL, DCX_WINDOW | DCX_USESTYLE | DCX_CACHE); // select in the correct brush and font GreSelectFont(hdc, ghMenuFont); ThreadLockMenuNoModify(pmenu, &tlpMenu); for (i = 0; i < pmenu->cItems; i++, pitem++) { if (((psz = TextPointer(pitem->lpstr)) == NULL) && !TestMFT(pitem, MFT_OWNERDRAW)) { continue; } if (TestMFT(pitem, MFT_OWNERDRAW)) { GreSetViewportOrg(hdc, 0, 0, NULL); } else { GreSetViewportOrg(hdc, pitem->xItem, pitem->yItem, NULL); } // this funky xLeft and yTop calculation stolen from RealDrawMenuItem yTop = gcyMenuFontExternLeading; cyTemp = pitem->cyItem - (gcyMenuFontChar + gcyMenuFontExternLeading + SYSMET(CYBORDER)); if (cyTemp > 0) { yTop += (cyTemp / 2); } if (fShow && TestMFS(pitem, MFS_HOTTRACK)) { GreSelectBrush(hdc, SYSHBR(HOTLIGHT)); } else { GreSelectBrush(hdc, hbr); } if (TestMFT(pitem, MFT_OWNERDRAW)) { xxxSendMenuDrawItemMessage(hdc, ODA_DRAWENTIRE, pmenu, pitem, FALSE, 0); } else { TL tl; if (pitem->cch > MENU_STRLEN) { pchOut = (WCHAR*)UserAllocPool((pitem->cch+1) * sizeof(WCHAR), TAG_RTL); if (pchOut == NULL) { break; } ThreadLockPool(ptiCurrent, pchOut, &tl); } else { pchOut = szMenu; } xLeft = gcxMenuFontChar; if (TestMFT(pitem, MFT_RIGHTORDER) && ((lpsz = TextPointer(pitem->lpstr)) != NULL)) { xxxPSMGetTextExtent(hdc, lpsz, pitem->cch, &extent); xLeft += (pitem->cxItem - (gpsi->oembmi[OBI_MENUCHECK].cx + MNXSPACE) - extent.cx); } if (CALL_LPK(ptiCurrent)) { if (!fShow) { //Becuase PSMTextOut does not use PatBlt it uses ExtTextOut. GreSetTextColor(hdc, fFlatMenuBar ? SYSRGB(MENUBAR) : SYSRGB(MENU)); } xxxPSMTextOut(hdc, xLeft, yTop, psz, pitem->cch, DT_PREFIXONLY); } else { result = GetPrefixCount(psz, pitem->cch, pchOut, pitem->cch); xxxDrawItemUnderline(pitem, hdc, xLeft, yTop, pchOut, LOWORD(result)); } if (pchOut != szMenu) { ThreadUnlockAndFreePool(ptiCurrent, &tl); } } } ThreadUnlockMenuNoModify(&tlpMenu); _ReleaseDC(hdc); } /***************************************************************************\ * xxxPaintMenuBar * * 3/8/2000 vadimg created \***************************************************************************/ UINT xxxPaintMenuBar(PWND pwnd, HDC hdc, int iLeftOffset, int iRightOffset, int iTopOffset, DWORD dwFlags) { PMENU pMenu; UINT cyMenu, cxMenuMax; HBRUSH hbrOld, hbr; TL tlpMenu; CheckLock(pwnd); pMenu = (PMENU)pwnd->spmenu; if (pMenu == NULL) { return 0; } ThreadLockMenuNoModify(pMenu, &tlpMenu); /* * Figure out whether to paint it in active or inactive colors. */ if (dwFlags & PMB_ACTIVE) { ClearMF(pMenu, MFINACTIVE); } else { SetMF(pMenu, MFINACTIVE); } /* * Calculate maximum available horizontal real estate. */ cxMenuMax = ((pwnd->rcWindow.right - iRightOffset) - (pwnd->rcWindow.left + iLeftOffset)); /* * If the menu has switched windows, or if either count is 0, * then we need to recompute the menu width. */ if (pwnd != pMenu->spwndNotify || pMenu->cxMenu == 0 || pMenu->cyMenu == 0) { xxxMenuBarCompute(pMenu, pwnd, iTopOffset, iLeftOffset, cxMenuMax); } if (pMenu->hbrBack) { hbr = pMenu->hbrBack; } else { hbr = SYSHBR(MENUBAR); } hbrOld = GreSelectBrush(hdc, hbr); GrePatBlt(hdc, iLeftOffset, iTopOffset, pMenu->cxMenu, pMenu->cyMenu, PATCOPY); /* * Finally draw the menu itself. */ xxxMenuDraw(hdc, pMenu); GreSelectBrush(hdc, hbrOld); cyMenu = pMenu->cyMenu; ThreadUnlockMenuNoModify(&tlpMenu); return cyMenu; }