开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
CoolMenu.cpp
资源名称：sourcecode.zip　[点击查看]
上传用户：wlkj888
上传日期：2022-08-01
资源大小：806k
文件大小：37k
源码类别：

对话框与窗口

开发平台：

Visual C++

CoolMenu.cpp：源码内容
  1. /****************************************************************************
  2.  * *  
  3.  * GuiToolKit   *
  4.  *  (MFC extension) *  
  5.  * Created by Francisco Campos G. www.beyondata.com fcampos@beyondata.com *
  6.  *--------------------------------------------------------------------------*    
  7.  * *
  8.  * This program is free software;so you are free to use it any of your *
  9.  * applications (Freeware, Shareware, Commercial),but leave this header *
  10.  * intact. *
  11.  * *
  12.  * These files are provided "as is" without warranty of any kind. *
  13.  * *
  14.  *        GuiToolKit is forever FREE CODE !!!!! *
  15.  * *
  16.  *--------------------------------------------------------------------------*
  17.  * Bug Fixes and improvements : (Add your name) *
  18.  * -Francisco Campos *
  19.  * -Serge Koroleuve *
  20.  * *
  21.  ****************************************************************************/
  25. ////////////////////////////////////////////////////////////////
  26. // CoolMenu 1997 Microsoft Systems Journal. 
  27. // If this code works, it was written by Paul DiLascia.
  28. // If not, I don't know who wrote it.
  29. //
  30. // ==========================================================================  
  31. // HISTORY:   
  32. // ==========================================================================
  33. // 1.01 13 Aug 1998 - Andrew Bancroft [ABancroft@lgc.com] - Since we've already 
  34. //   added the entire toolbar to the imagelist we need to 
  35. //   increment nNextImage even if we didn't add this button to 
  36. //   m_mapIDtoImage in the LoadToolbar() method.
  37. // 1.01a 13 Aug 1998 - Peter Tewkesbury - Added AddSingleBitmap(...)
  38. //   method for adding a single bitmap to a pulldown
  39. //   menu item.
  40. // 1.02 13 Aug 1998 - Omar L Francisco - Fixed bug with lpds->CtlType
  41. //   and lpds->itemData item checking.
  42. // 1.03 12 Nov 1998 - Fixes debug assert in system menu. - Wang Jun
  43. // 1.04 17 Nov 1998 - Fixes debug assert when you maximize a view - Wang Jun
  44. //   window, then try to use the system menu for the view.
  45. // 1.05 09 Jan 1998 - Seain B. Conover [sc@tarasoft.com] - Fix for virtual 
  46. //   key names.
  47. // 1.06 24 Feb 1999 - Michael Lange [michael.home@topdogg.com] - Fix for memory 
  48. //   leak in CMyItemData structure, added a destructor that 
  49. //   calls text.Empty().
  50. // - Boris Kartamishev [kbv@omegasoftware.com] - Fix for resource
  51. //   ID bug.
  52. // - Jeremy Horgan [jeremyhorgan@hotmail.com] - During 
  53. //   accelerator key processing OnInitMenuPopup() calls 
  54. //   ConvertMenu() which allocates a new CMyItemData for each 
  55. //       menu item. This is memory is normally freed by a call to 
  56. //       OnMenuSelect(), which is not called when processing 
  57. //   accelerator keys. This results in a memory leak. This was
  58. //   fixed by modifying the ~CCoolMenuManager() destructor.
  59. // 1.07 24 Feb 1999 - Koji MATSUNAMI [kmatsu@inse.co.jp] - Fixed problem with 
  60. //   popup menus being drawn correctly as cool menus.
  61. // ==========================================================================
  62. //
  63. /////////////////////////////////////////////////////////////////////////////
  65. #include "StdAfx.h"
  66. #include "CoolMenu.h"
  67. #include "GuiDrawLayer.h"
  68. #include "GuiDocSpecial.h"
  70. #ifdef _DEBUG
  71. #define new DEBUG_NEW
  72. #undef THIS_FILE
  73. static char THIS_FILE[] = __FILE__;
  74. #endif
  75. #define safe_delete(p){if(p){delete p;p=NULL;}}
  76. // helpers
  77. //void PLFillRect(CDC& dc, const CRect& rc, COLORREF color);
  78. void PLDrawEmbossed(CDC& dc, CImageList& il, int i,
  79. CPoint p, BOOL bColor=FALSE);
  80. HBITMAP PLLoadSysColorBitmap(LPCTSTR lpResName, BOOL bMono=FALSE);
  81. inline HBITMAP PLLoadSysColorBitmap(UINT nResID, BOOL bMono=FALSE) {
  82. return PLLoadSysColorBitmap(MAKEINTRESOURCE(nResID), bMono);
  83. }
  85. // if you want to see extra TRACE diagnostics, set below to TRUE
  86. BOOL CCoolMenuManager::bTRACE = FALSE;
  88. #ifdef _DEBUG
  89. #define CMTRACEFN
  90. CTraceFn __fooble;
  91. if (bTRACE)
  92. TRACE
  93. #define CMTRACE
  94. if (bTRACE)
  95. TRACE
  96. #else
  97. #define CMTRACEFN TRACE
  98. #define CMTRACE   TRACE
  99. #endif
  101. // constants used for drawing
  102. const CXGAP = 1; // num pixels between button and text
  103. const CXTEXTMARGIN = 2; // num pixels after hilite to start text
  104. const CXBUTTONMARGIN = 2; // num pixels wider button is than bitmap
  105. const CYBUTTONMARGIN = 2; // ditto for height
  107. // DrawText flags
  108. const DT_MYSTANDARD = DT_SINGLELINE|DT_LEFT|DT_VCENTER;
  110. // identifies owner-draw data as mine
  111. const LONG MYITEMID = MAKELONG(MAKEWORD(_T('m'),_T('i')),MAKEWORD(_T('d'),_T('0')));
  113. // private struct: one of these for each owner-draw menu item
  114. struct CMyItemData {
  115. long magicNum; // magic number identifying me
  116. CString text; // item text
  117. UINT fType; // original item type flags
  118. int iButton; // index of button image in image list
  119. CMyItemData() { magicNum = MYITEMID; }
  120. ~CMyItemData() { text.Empty(); }
  121. BOOL IsMyItemData() { return magicNum == MYITEMID; }
  122. };
  124. IMPLEMENT_DYNAMIC(CCoolMenuManager, CSubclassWnd)
  126. CCoolMenuManager::CCoolMenuManager()
  127. {
  128. m_szBitmap = m_szButton = CSize(0,0); // will compute later
  129. m_bShowButtons = TRUE; // show buttons by default
  130. m_bAutoAccel = TRUE; // auto accelerators by default
  131. m_hAccel = NULL; // no accelerators loaded yet
  132. m_pAccel = NULL; // no accelerators loaded yet
  133. m_bUseDrawState = FALSE; // use DrawEmbossed by default
  134. m_bDrawDisabledButtonsInColor = FALSE; // use color for disabled buttons
  135. m_StyleDisplay=GUISTYLE_XP;
  136. FixMFCDotBitmap();
  137. }
  139. CCoolMenuManager::~CCoolMenuManager()
  140. {
  141. // Jeremy Horgan [jeremyhorgan@hotmail.com]
  143. while (!m_menuList.IsEmpty()) 
  144. {
  145. ConvertMenu(CMenu::FromHandle((HMENU)m_menuList.RemoveHead()),0,     
  146. FALSE, FALSE);
  147. }
  149. Destroy();
  150. }
  152. //////////////////
  153. // Destroy everything. Called from destructor and Refresh.
  154. //
  155. void CCoolMenuManager::Destroy()
  156. {
  157. m_ilButtons.DeleteImageList();
  158. m_mapIDtoImage.RemoveAll();
  159. m_szBitmap = m_szButton = CSize(0,0);
  160. m_arToolbarID.RemoveAll();
  161. m_fontMenu.DeleteObject();
  162. DestroyAccel();
  163. }
  165. /////////////////
  166. // Destroy accelerators
  167. //
  168. void CCoolMenuManager::DestroyAccel()
  169. {
  170. m_mapIDtoAccel.RemoveAll(); // delete ACCEL entries in map
  171. safe_delete(m_pAccel); // delete current accelerators
  172. }
  174. //////////////////
  175. // Call this to install the menu manager. Install(NULL) to un-install.
  176. //
  177. void CCoolMenuManager::Install(CFrameWnd* pFrame)
  178. {
  179. ASSERT_VALID(pFrame);
  180. m_pFrame = pFrame;
  181. HookWindow(pFrame);   // install message hook
  182. }
  184. //////////////////
  185. // Load array of toolbar IDs.
  186. //
  187. BOOL CCoolMenuManager::LoadToolbars(const UINT* arID, int n)
  188. {
  189. ASSERT(arID);
  190. BOOL bRet = TRUE;
  191. for (int i=0; i<n; i++)
  192. bRet |= LoadToolbar(arID[i]);
  193. return bRet;
  194. }
  196. // structure of RT_TOOLBAR resource
  197. struct TOOLBARDATA {
  198. WORD wVersion; // version # should be 1
  199. WORD wWidth; // width of one bitmap
  200. WORD wHeight; // height of one bitmap
  201. WORD wItemCount; // number of items
  202. WORD items[1]; // array of command IDs, actual size is wItemCount
  203. };
  205. //////////////////
  206. // Load one toolbar. Assumes bg color is gray.
  207. // 
  208. //  * add toolbar bitmap to image list
  209. //  * add each button ID to button map
  210. //
  211. BOOL CCoolMenuManager::LoadToolbar(UINT nIDToolbar)
  212. {
  214. // load bitmap
  215. HBITMAP hbmToolbar = PLLoadSysColorBitmap(nIDToolbar);
  216. if (!hbmToolbar) {
  217. TRACE(_T("*** Can't load bitmap for toolbar %d!n"), nIDToolbar);
  218. return FALSE;
  219. }
  220. CBitmap bmToolbar;
  221. bmToolbar.Attach(hbmToolbar); // destructor will detach & destroy
  223. // load toolbar
  224. LPTSTR lpResName = MAKEINTRESOURCE(nIDToolbar);
  225. HINSTANCE hInst;
  226. HRSRC hRsrc;
  227. TOOLBARDATA* ptbd;
  228. if ((hInst= AfxFindResourceHandle(lpResName, RT_TOOLBAR)) == NULL ||
  229.  (hRsrc= FindResource(hInst, lpResName, RT_TOOLBAR))   == NULL ||
  230.  (ptbd = (TOOLBARDATA*)LoadResource(hInst, hRsrc))     == NULL) {
  232. TRACE(_T("*** Can't load toolbar %d!n"), nIDToolbar);
  233. return FALSE;
  234. }
  235. ASSERT(ptbd->wVersion==1);
  238. // OK, I have the bitmap and toolbar. 
  240. CSize sz(ptbd->wWidth, ptbd->wHeight);
  241. if (m_szBitmap.cx==0) {
  242. // First toolbar: initialized bitmap/button sizes and create image list.
  243. m_szBitmap = sz;
  244. m_szButton = sz + CSize(CXBUTTONMARGIN<<1, CYBUTTONMARGIN<<1);
  245. VERIFY(m_ilButtons.Create(sz.cx, sz.cy, ILC_COLORDDB|ILC_MASK, 0, 10));
  247. } else if (m_szBitmap != sz) {
  248. // button sizes different -- oops
  249. TRACE(_T("*** Toolbar %d button size differs!n"), nIDToolbar);
  250. return FALSE;
  251. }
  253. // I have a good toolbar: now add bitmap to the image list, and each
  254. // command ID to m_mapIDtoImage array. Note that LoadSysColorBitmap will
  255. // change gray -> COLOR_3DFACE, so use that for image list background.
  256. //
  257. int iNextImage = m_ilButtons.GetImageCount();
  258. m_ilButtons.Add(&bmToolbar,GuiDrawLayer::GetRGBColorFace());
  259. for (int i = 0; i < ptbd->wItemCount; i++) 
  260. {
  262. UINT nID = ptbd->items[i];
  263. if (nID > 0) 
  264. {
  265. if (GetButtonIndex(nID) >= 0) 
  266. {
  267. TRACE(_T("*** Duplicate button ID %d ignoredn"), nID);
  268. } 
  269. else 
  270. {
  271. m_mapIDtoImage.SetAt(nID, (void*)iNextImage);
  272. //TRACE(_T("CCoolMenuManager::LoadToolbar(). Added Menu Id %d, Button Number %dn"), nID, iNextImage-1);
  273. }
  274. // AB. 13-08-98. Since we've already added the entire toolbar to the imagelist
  275. // we need to increment nNextImage even if we didn't add this button to
  276. // m_mapIDtoImage.
  277. iNextImage++;
  278. }
  279. }
  280. m_arToolbarID.Add(nIDToolbar); // remember toolbar ID for Refresh 
  281. bmToolbar.Detach();
  282. return TRUE; // success!
  284. }
  286. //////////////////
  287. // Virtual CSubclassWnd window proc. All messages come here before frame
  288. // window. Isn't it cool? Just like in the old days!
  289. //
  290. LRESULT CCoolMenuManager::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
  291. {
  292. switch(msg) {
  293. case WM_SYSCOLORCHANGE:
  294. case WM_SETTINGCHANGE:
  295. Refresh();
  296. break;
  298. case WM_MEASUREITEM:
  299. if (OnMeasureItem((MEASUREITEMSTRUCT*)lp))
  300. return TRUE; // handled
  301. break;
  303. case WM_DRAWITEM:
  304. if (OnDrawItem((DRAWITEMSTRUCT*)lp))
  305. return TRUE; // handled
  306. break;
  308. case WM_INITMENUPOPUP:
  309. // Very important: must let frame window handle it first!
  310. // Because if someone calls CCmdUI::SetText, MFC will change item to
  311. // MFT_STRING, so I must change back to MFT_OWNERDRAW.
  312. //
  313. CSubclassWnd::WindowProc(msg, wp, lp);
  314. OnInitMenuPopup(CMenu::FromHandle((HMENU)wp),
  315. (UINT)LOWORD(lp), (BOOL)HIWORD(lp));
  316. return 0;
  318. case WM_MENUSELECT:
  319. OnMenuSelect((UINT)LOWORD(wp), (UINT)HIWORD(wp), (HMENU)lp);
  320. break;
  322. case WM_MENUCHAR:
  323. LRESULT lr = OnMenuChar((TCHAR)LOWORD(wp), (UINT)HIWORD(wp),
  324. CMenu::FromHandle((HMENU)lp));
  325. if (lr!=0)
  326. return lr;
  327. break;
  328. }
  329. return CSubclassWnd::WindowProc(msg, wp, lp);
  330. }
  332. //////////////////
  333. // Refresh all colors, fonts, etc. For WM_SETTINGCHANGE, WM_SYSCOLORCHANGE.
  334. //
  335. void CCoolMenuManager::Refresh()
  336. {
  337. // first copy list (array) of toolbar IDs now loaded.
  338. CUIntArray arToolbarID;
  339. arToolbarID.Copy(m_arToolbarID);
  341. // destroy everything
  342. Destroy();
  344. // re-load toolbars.
  345. int nToolbars = arToolbarID.GetSize();
  346. for (int i = 0; i < nToolbars; i++)
  347. LoadToolbar(arToolbarID[i]);
  348. }
  350. //////////////////
  351. // Get menu font, creating if needed
  352. //
  353. CFont* CCoolMenuManager::GetMenuFont()
  354. {
  355. if (!(HFONT)m_fontMenu) {
  356. NONCLIENTMETRICS info;
  357. info.cbSize = sizeof(info);
  358. SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  359. VERIFY(m_fontMenu.CreateFontIndirect(&info.lfMenuFont));
  360. }
  361. return &m_fontMenu;
  362. }
  364. //////////////////
  365. // Handle WM_MEASUREITEM on behalf of frame: compute menu item size.
  366. //
  367. BOOL CCoolMenuManager::OnMeasureItem(LPMEASUREITEMSTRUCT lpms)
  368. {
  369. ASSERT(lpms);
  370. CMyItemData* pmd = (CMyItemData*)lpms->itemData;
  371. ASSERT(pmd);
  372. if (lpms->CtlType != ODT_MENU || !pmd->IsMyItemData())
  373. return FALSE; // not handled by me
  375. if (pmd->fType & MFT_SEPARATOR) {
  376. // separator: use half system height and zero width
  377. lpms->itemHeight = GetSystemMetrics(SM_CYMENU)>>1;
  378. lpms->itemWidth  = 0;
  380. } else {
  382. // compute size of text: use DrawText with DT_CALCRECT
  384. CWindowDC dc(NULL); // screen DC--I won't actually draw on it
  385. CRect rcText(0,0,0,0);
  386. CFont* pOldFont = dc.SelectObject(GetMenuFont());
  387. dc.DrawText(pmd->text, rcText, DT_MYSTANDARD|DT_CALCRECT);
  388. dc.SelectObject(pOldFont);
  390. // height of item is just height of a standard menu item
  391. lpms->itemHeight= max(GetSystemMetrics(SM_CYMENU), rcText.Height());
  393. // width is width of text plus a bunch of stuff
  394. int cx = rcText.Width()+20; // text width 
  395. cx += CXTEXTMARGIN<<1; // L/R margin for readability
  396. cx += CXGAP; // space between button and menu text
  397. cx += m_szButton.cx<<1; // button width (L=button; R=empty margin)
  399. // whatever value I return in lpms->itemWidth, Windows will add the
  400. // width of a menu checkmark, so I must subtract to defeat Windows. Argh.
  401. //
  402. cx -= GetSystemMetrics(SM_CXMENUCHECK)-1;
  403. lpms->itemWidth = cx+14; // done deal
  404. lpms->itemHeight+=2;
  405. CMTRACE(_T("OnMeasureItem for '%s':tw=%d h=%dn"), (LPCTSTR)pmd->text,
  406. lpms->itemWidth, lpms->itemHeight);
  407. }
  408. return TRUE; // handled
  409. }
  412. void CCoolMenuManager::DrawSeparator(CRect& rc, CDC& dc)
  413. {
  414. CBrush brush;
  415. CRect m_rc=rc;
  416. brush.CreateSolidBrush(GuiDrawLayer::GetRGBColorXP());
  417. m_rc.right=m_rc.left+m_szButton.cx+11;
  418. dc.FillRect(m_rc,&brush);
  419. brush.DeleteObject( );
  420. if (m_StyleDisplay==GUISTYLE_2003)
  421. {
  422. CGradient M(CSize(m_rc.Width(),m_rc.Height()));
  423. M.PrepareHorizontal(&dc,m_StyleDisplay);
  424. M.Draw(&dc,-1,m_rc.top,0,0,m_rc.Width(),m_rc.Height(),SRCCOPY);
  425. }
  426. brush.CreateSolidBrush(GuiDrawLayer::GetRGBSkinMenu());
  427. rc.left+=m_szButton.cx+4;
  428. dc.FillRect(rc,&brush);
  429. rc.top += rc.Height()>>1;
  430. rc.left+= 5;
  431. //rc.right-=5;
  432. dc.DrawEdge(rc, EDGE_ETCHED, BF_TOP);
  434. }
  436. /////////////////
  437. // Handle WM_DRAWITEM on behalf of frame. Note: in all that goes
  438. // below, can't assume rcItem.left=0 because of multi-column menus!
  439. //
  440. BOOL CCoolMenuManager::OnDrawItem(LPDRAWITEMSTRUCT lpds)
  441. {
  443. CRect rc2;
  444. CPoint p;
  445. CRect rcCheck;
  446. CMenuItemInfo info;
  447. CRect rcText;
  448. CSize sz; 
  449. CSize siImg;
  450. CRect rcima;
  451. IMAGEINFO pImageInfo;
  452. ASSERT(lpds);
  453. // Omar L Francisco
  454. if (lpds->CtlType != ODT_MENU)
  455. return FALSE;
  456. // Omar L Francisco
  457. CMyItemData* pmd = (CMyItemData*)lpds->itemData;
  458. ASSERT(pmd);
  460. if (!pmd->IsMyItemData())
  461. return FALSE;
  463. ASSERT(lpds->itemAction != ODA_FOCUS);
  464. ASSERT(lpds->hDC);
  465. CDC dc;
  466. dc.Attach(lpds->hDC);
  468. const CRect& rcItem = lpds->rcItem;
  470. if (pmd->fType & MFT_SEPARATOR) {
  471. // draw separator
  472. CRect rc = rcItem;
  473. DrawSeparator(rc,dc);
  475. } else
  476. { // not a separator
  478. BOOL bDisabled = lpds->itemState & ODS_GRAYED;
  479. BOOL bSelected = lpds->itemState & ODS_SELECTED;
  480. BOOL bChecked  = lpds->itemState & ODS_CHECKED;
  481. BOOL bHaveButn=FALSE;
  483. int cxButn = m_szButton.cx; // width of button
  484. COLORREF colorBG = bSelected ? GuiDrawLayer::GetRGBFondoXP(): GetSysColor(WHITE_PEN) ;
  485. CRect rcBG = rcItem;
  487. if (bSelected || lpds->itemAction==ODA_SELECT)
  488. {
  490. if (bSelected && !bDisabled)
  491. PLSelectRect(dc, rcBG);
  492. else
  493. PLNormalRect(dc, rcBG);
  495. }
  496. else
  497. PLNormalRect(dc, rcBG);
  499. CMTRACE(_T("OnDrawItem for '%s':tw=%d h=%dn"), (LPCTSTR)pmd->text,
  500. rcItem.Width(), rcItem.Height());
  502. // Paint button, or blank if none
  503. CRect rcButn(rcItem.TopLeft(), m_szButton); // button rect
  504. rcButn += CPoint(0, // center vertically
  505. (rcItem.Height() - rcButn.Height())>>1 );
  507. int iButton = pmd->iButton;
  508. if (true) {
  510. // this item has a button!
  511. bHaveButn = TRUE;
  513. // compute point to start drawing
  514. sz = rcButn.Size() - m_szBitmap;
  515. sz.cx >>= 1;
  516. sz.cy >>= 1;
  517. p=CPoint(rcButn.TopLeft() + sz);
  518. p.x+=2;
  519. // draw disabled or normal
  520. if (!bDisabled) {
  521. // normal: fill BG depending on state
  522. if (bChecked )
  523. {
  524. rcCheck=rcButn;
  525. rcCheck.left+=1;
  526. rcCheck.top+=1;
  527. rcCheck.InflateRect(1,1);
  528. PLSelectRect(dc, rcCheck);
  529. }
  530. // draw pushed-in or popped-out edge
  531. if (bSelected || bChecked) {
  532. rc2 = rcButn;
  533. if (bChecked)
  534. {
  535. rc2.DeflateRect(5,5);
  536. GuiDrawLayer::DrawCheck(&dc,rc2);
  537. }
  538. //dc.DrawEdge(rc2, bChecked ? GuiDrawLayer::GetRGBCaptionXP() : GuiDrawLayer::GetRGBCaptionXP(),
  539. // BF_RECT);
  540. }
  541. // draw the button!
  542. if (bSelected)
  543. {
  545. m_ilButtons.GetImageInfo(iButton,&pImageInfo);
  546. rcima =pImageInfo.rcImage;
  547. siImg=CSize(rcima.Width(),rcima.Height());
  548. if (GuiDrawLayer::m_Style != GUISTYLE_2003)
  549. {
  550. p.x+=1;
  551. p.y+=3;
  552. dc.DrawState(p,siImg,m_ilButtons.ExtractIcon(iButton),DSS_MONO,CBrush (GuiDrawLayer::GetRGBColorShadow()));
  553. p.x-=2; p.y-=3;
  554. }
  555. m_ilButtons.Draw(&dc, iButton, p, ILD_TRANSPARENT);
  556. if (GuiDrawLayer::m_Style != GUISTYLE_2003)
  557. {
  558. p.x+=1;
  559. p.y+=3;
  560. }
  561. }
  562. else
  563. m_ilButtons.Draw(&dc, iButton, p, ILD_TRANSPARENT);
  565. } else if (m_bUseDrawState) {
  566. // use DrawState to draw disabled button: must convert to icon
  567. HICON hIcon=m_ilButtons.ExtractIcon(iButton);
  568. ASSERT(hIcon);
  569. dc.DrawState(p, CSize(0,0), hIcon, DSS_DISABLED, (HBRUSH)NULL);
  570. DestroyIcon(hIcon);
  572. } else
  573. // use DrawEmbossed to draw disabeld button, w/color flag
  574. PLDrawEmbossed(dc, m_ilButtons, iButton, p,
  575. m_bDrawDisabledButtonsInColor);
  577. } else {
  578. // no button: look for custom checked/unchecked bitmaps
  579. info.fMask = MIIM_CHECKMARKS;
  580. GetMenuItemInfo((HMENU)lpds->hwndItem,
  581. lpds->itemID, MF_BYCOMMAND, (MENUITEMINFO *)&info);
  582. if (bChecked || info.hbmpUnchecked) {
  583. bHaveButn = Draw3DCheckmark(dc, rcButn, bSelected,
  584. bChecked ? info.hbmpChecked : info.hbmpUnchecked);
  585. }
  586. }
  588. // Done with button, now paint text. First do background if needed.
  590. // compute text rectangle and colors
  591. rcText = rcItem;  // start w/whole item
  592. rcText.left += cxButn + CXGAP + CXTEXTMARGIN+11; // left margin
  593. rcText.right -= cxButn;  // right margin
  594. dc.SetBkMode(TRANSPARENT);  // paint transparent text
  595. COLORREF colorText = GetSysColor(bDisabled ?  COLOR_GRAYTEXT :
  596. bSelected ? COLOR_MENUTEXT : COLOR_MENUTEXT);
  598. // Now paint menu item text. No need to select font,
  599. // because windows sets it up before sending WM_DRAWITEM
  600. //
  601. if (bDisabled && (!bSelected || colorText == colorBG)) {
  602. // disabled: draw hilite text shifted southeast 1 pixel for embossed
  603. // look. Don't do it if item is selected, tho--unless text color same
  604. // as menu highlight color. Got it?
  605. //
  606. DrawMenuText(dc, rcText + CPoint(1,1), pmd->text,
  607. GetSysColor(COLOR_3DHILIGHT));
  608. }
  609. DrawMenuText(dc, rcText, pmd->text, colorText); // finally!
  610. }
  611. dc.Detach();
  613. return TRUE; // handled
  614. }
  616. /////////////////
  617. // Helper function to draw justified menu text. If the text contains a TAB,
  618. // draw everything after the tab right-aligned
  619. //
  620. void CCoolMenuManager::DrawMenuText(CDC& dc, CRect rc, CString text,
  621. COLORREF color)
  622. {
  623. CString left = text;
  624. CString right;
  625. int iTabPos = left.Find(_T('t'));
  626. if (iTabPos >= 0) {
  627. right = left.Right(left.GetLength() - iTabPos - 1);
  628. left  = left.Left(iTabPos);
  629. }
  630. dc.SetTextColor(color);
  631. dc.DrawText(left, &rc, DT_MYSTANDARD);
  632. if (iTabPos > 0)
  633. dc.DrawText(right, &rc, DT_MYSTANDARD|DT_RIGHT);
  634. }
  636. #ifndef OBM_CHECK
  637. #define OBM_CHECK 32760 // from winuser.h
  638. #endif
  640. //////////////////
  641. // Draw 3D checkmark
  642. //
  643. // dc device context to draw in
  644. // rc rectangle to center bitmap in
  645. // bSelected TRUE if button is also selected
  646. // hbmCheck Checkmark bitmap to use, or NULL for default
  647. //
  648. BOOL CCoolMenuManager::Draw3DCheckmark(CDC& dc, const CRect& rc,
  649. BOOL bSelected, HBITMAP hbmCheck)
  650. {
  651. // get checkmark bitmap if none, use Windows standard
  652. if (!hbmCheck) {
  653. CBitmap bm;
  654. VERIFY(bm.LoadOEMBitmap(OBM_CHECK));
  655. hbmCheck = (HBITMAP)bm.Detach();
  656. ASSERT(hbmCheck);
  657. }
  659. // center bitmap in caller's rectangle
  660. BITMAP bm;
  661. ::GetObject(hbmCheck, sizeof(bm), &bm);
  662. int cx = bm.bmWidth;
  663. int cy = bm.bmHeight;
  664. CRect rcDest = rc;
  665. CPoint p(0,0);
  666. CSize delta(CPoint((rc.Width() - cx)/2, (rc.Height() - cy)/2));
  667. if (rc.Width() > cx)
  668. rcDest = CRect(rc.TopLeft() + delta, CSize(cx, cy));
  669. else
  670. p -= delta;
  672. // select checkmark into memory DC
  673. CDC memdc;
  674. memdc.CreateCompatibleDC(&dc);
  675. HBITMAP hOldBM = (HBITMAP)::SelectObject(memdc, hbmCheck);
  677. // set BG color based on selected state
  678. COLORREF colorOld =
  679. dc.SetBkColor(GetSysColor(bSelected ? COLOR_MENU : COLOR_3DLIGHT));
  680. dc.BitBlt(rcDest.left, rcDest.top, rcDest.Width(), rcDest.Height(),
  681. &memdc, p.x, p.y, SRCCOPY);
  682. dc.SetBkColor(colorOld);
  684. ::SelectObject(memdc, hOldBM); // restore
  686. // draw pushed-in hilight.
  687. if (rc.Width() > cx) // if room:
  688. rcDest.InflateRect(1,1); // inflate checkmark by one pixel all around
  689. dc.DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT);
  691. return TRUE;
  692. }
  694. //////////////////
  695. // Handle WM_INITMENUPOPUP on behalf of frame.
  696. //
  697. void CCoolMenuManager::OnInitMenuPopup(CMenu* pMenu,
  698. UINT nIndex, BOOL bSysMenu)
  699. {
  700. if (m_bAutoAccel)
  701. {
  702. // check for new accels. If ASSERT bombs,
  703. // you forgot to call Install.
  704. ASSERT_VALID(m_pFrame);
  706. HACCEL hAccel = m_pFrame->GetDefaultAccelerator();
  708. if (hAccel != m_hAccel)
  709. LoadAccel(hAccel);
  711. // 12 Nov 1998 - Wang Jun - Fixes debug assert in system menu.
  712. // Check if click system menu.
  713. if (!bSysMenu) {
  714. ConvertMenu(pMenu, nIndex, bSysMenu, m_bShowButtons);
  715. }
  716. }
  717. ConvertMenu(pMenu, nIndex, bSysMenu, m_bShowButtons);
  718. }
  720. //////////////////
  721. // Set the accelerator table used to generate automatic key
  722. // names in menus. Delete previous table if any.
  723. //
  724. void CCoolMenuManager::LoadAccel(HACCEL hAccel)
  725. {
  726. DestroyAccel();
  727. int nAccel;
  728. if (hAccel && (nAccel = CopyAcceleratorTable(hAccel, NULL, 0)) > 0) {
  729. m_pAccel = new ACCEL [nAccel];
  730. ASSERT(m_pAccel);
  731. CopyAcceleratorTable(hAccel, m_pAccel, nAccel);
  733. // Now I have the accelerators. Look over list, linking each command
  734. // ID with its ACCEL structure--i.e., m_mapIDtoAccel[nID] = ACCEL for
  735. // that ID. If more than one ACCEL for a given command (command has more
  736. // than one shortcut), fix up so ACCEL.cmd is offset of prev ACCEL
  737. // 
  738. for (int i=0; i<nAccel; i++) {
  739. ACCEL& ac = m_pAccel[i];
  740. ACCEL* pAccel = GetAccel(ac.cmd);
  741. m_mapIDtoAccel.SetAt(ac.cmd, &ac);
  742. ac.cmd = pAccel ? &ac - pAccel : 0; // ac.cmd = offset of prev, or 0
  743. }
  744. }
  745. }
  747. //////////////////
  748. // This rather gnarly function is used both to convert the menu from strings to
  749. // owner-draw and vice versa. In either case, it also appends automagic
  750. // accelerator key names to the menu items, if m_bAutoAccel is TRUE.
  751. //
  752. void CCoolMenuManager::ConvertMenu(CMenu* pMenu,
  753. UINT nIndex, BOOL bSysMenu, BOOL bShowButtons)
  754. {
  755. ASSERT_VALID(pMenu);
  757. CString sItemName;
  759. UINT nItem = pMenu->GetMenuItemCount();
  760. for (UINT i = 0; i < nItem; i++) {
  761. // loop over each item in menu
  763. // get menu item info
  764. TCHAR itemname[256] = {0};
  765. CMenuItemInfo info;
  766. info.fMask = MIIM_SUBMENU | MIIM_DATA | MIIM_ID
  767. | MIIM_TYPE;
  768. info.dwTypeData = itemname;
  769. info.cch = sizeof(itemname);
  770. ::GetMenuItemInfo(*pMenu, i, TRUE, (MENUITEMINFO *)&info);
  771. CMyItemData* pmd = (CMyItemData*)info.dwItemData;
  774. if (pmd && !pmd->IsMyItemData()) {
  775. CMTRACE(_T("CCoolMenuManager: ignoring foreign owner-draw itemn"));
  776. continue; 
  777. // owner-draw menu item isn't mine--leave it alone
  778. }
  780. // Koji MATSUNAMI 1999.2.23
  781. //
  782. if (bSysMenu && info.wID >= 0xF000) {
  783. CMTRACE(_T("CCoolMenuManager: ignoring sys menu itemn"));
  784. continue; // don't do for system menu commands
  785. }
  787. // now that I have the info, I will modify it
  788. info.fMask = 0; // assume nothing to change
  790. if (bShowButtons) {
  792. // I'm showing buttons: convert to owner-draw
  794. if (!(info.fType & MFT_OWNERDRAW)) {
  795. // If not already owner-draw, make it so. NOTE: If app calls
  796. // pCmdUI->SetText to change the text of a menu item, MFC will
  797. // turn the item to MFT_STRING. So I must set it back to
  798. // MFT_OWNERDRAW again. In this case, the menu item data (pmd)
  799. // will still be there.
  800. // 
  801. info.fType |= MFT_OWNERDRAW;
  802. info.fMask |= MIIM_TYPE;
  803. if (!pmd) { // if no item data:
  804. pmd = new CMyItemData; //   create one
  805. ASSERT(pmd); //   (I hope)
  806. pmd->fType = info.fType; //   handy when drawing
  807. pmd->iButton = GetButtonIndex(info.wID);
  808. info.dwItemData = (DWORD)pmd; //   set in menu item data
  809. info.fMask |= MIIM_DATA; //   set item data
  810. }
  811. pmd->text = info.dwTypeData; // copy menu item string
  812. }
  814. // now add the menu to list of "converted" menus
  815. HMENU hmenu = pMenu->GetSafeHmenu();
  816. ASSERT(hmenu);
  817. if (!m_menuList.Find(hmenu))
  818. m_menuList.AddHead(hmenu);
  820. // append accelerators to menu item name
  821. if (m_pAccel && m_bAutoAccel)
  822. AppendAccelName(pmd->text, info.wID);
  824. } else {
  826. // no buttons -- I'm converting to strings
  828. if (info.fType & MFT_OWNERDRAW) { // if ownerdraw:
  829. info.fType &= ~MFT_OWNERDRAW; //   turn it off
  830. info.fMask |= MIIM_TYPE; //   change item type
  831. ASSERT(pmd); //   sanity check
  832. sItemName = pmd->text; //   save name before deleting pmd
  833. } else // otherwise:
  834. sItemName = info.dwTypeData; //   use name from MENUITEMINFO_LOCAL
  836. if (pmd) {
  837. // NOTE: pmd (item data) could still be left hanging around even
  838. // if MFT_OWNERDRAW is not set, in case mentioned above where app
  839. // calls pCmdUI->SetText to set text of item and MFC sets the type
  840. // to MFT_STRING.
  841. //
  842. info.dwItemData = NULL; // item data is NULL
  843. info.fMask |= MIIM_DATA; // change it
  844. safe_delete(pmd); // and item data too
  845. }
  847. // possibly add accelerator name
  848. if (m_pAccel  && m_bAutoAccel && AppendAccelName(sItemName, info.wID))
  849. info.fMask |= MIIM_TYPE; //  change item type (string)
  851. if (info.fMask & MIIM_TYPE) {
  852. // if setting name, copy name from CString to buffer and set cch
  853. _tcsncpy(itemname, sItemName, sizeof(itemname));
  854. info.dwTypeData = itemname;
  855. info.cch = sItemName.GetLength();
  856. }
  857. }
  859. // if after all the above, there is anything to change, change it
  860. if (info.fMask) {
  861. CMTRACE(_T("Converting '%s' to %sn"), itemname,
  862. (info.fType & MFT_OWNERDRAW) ? _T("OWNERDRAW") : _T("STRING"));
  863. SetMenuItemInfo(*pMenu, i, TRUE, (MENUITEMINFO *)&info);
  864. }
  865. }
  866. }
  868. //////////////////
  869. // User typed a char into menu. Look for item with & preceeding the char typed.
  870. //
  871. LRESULT CCoolMenuManager::OnMenuChar(UINT nChar, UINT nFlags, CMenu* pMenu)
  872. {
  873. ASSERT_VALID(pMenu);
  875. UINT iCurrentItem = (UINT)-1; // guaranteed higher than any command ID
  876. CUIntArray arItemsMatched; // items that match the character typed
  878. UINT nItem = pMenu->GetMenuItemCount();
  879. for (UINT i=0; i< nItem; i++) {
  880. // get menu info
  881. CMenuItemInfo info;
  882. info.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE;
  883. ::GetMenuItemInfo(*pMenu, i, TRUE, (MENUITEMINFO *)&info);
  885. CMyItemData* pmd = (CMyItemData*)info.dwItemData;
  886. if ((info.fType & MFT_OWNERDRAW) && pmd && pmd->IsMyItemData()) {
  887. CString& text = pmd->text;
  888. int iAmpersand = text.Find(_T('&'));
  889. if (iAmpersand >=0 && toupper(nChar)==toupper(text[iAmpersand+1]))
  890. arItemsMatched.Add(i);
  891. }
  892. if (info.fState & MFS_HILITE)
  893. iCurrentItem = i; // note index of current item
  894. }
  896. // arItemsMatched now contains indexes of items that match the char typed.
  897. //
  898. //   * if none: beep
  899. //   * if one:  execute it
  900. //   * if more than one: hilite next
  901. //
  902. UINT nFound = arItemsMatched.GetSize();
  903. if (nFound == 0)
  904. return 0;
  906. else if (nFound==1)
  907. return MAKELONG(arItemsMatched[0], MNC_EXECUTE);
  909. // more than one found--return 1st one past current selected item;
  910. UINT iSelect = 0;
  911. for (i=0; i < nFound; i++) {
  912. if (arItemsMatched[i] > iCurrentItem) {
  913. iSelect = i;
  914. break;
  915. }
  916. }
  917. return MAKELONG(arItemsMatched[iSelect], MNC_SELECT);
  918. }
  920. //////////////////
  921. // Handle WM_MENUSELECT: check for menu closed
  922. //
  923. void CCoolMenuManager::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu)
  924. {
  925. if (hSysMenu==NULL && nFlags==0xFFFF) {
  926. // Windows has closed the menu: restore all menus to original state
  927. while (!m_menuList.IsEmpty()) {
  928. ConvertMenu(CMenu::FromHandle((HMENU)m_menuList.RemoveHead()),
  929. 0, FALSE, FALSE);
  930. }
  931. }
  932. }
  934. // fix for virtual key names - Seain Conover (1999/01/09) 
  936. CString CCoolMenuManager::GetVirtualKeyName( const CString strVirtKey ) const
  937. {
  938. CString strResult;
  940. if ( strVirtKey == _T("Num 7")) { strResult = _T("Home"); }
  941. else if ( strVirtKey == _T("Num 1")) { strResult = _T("End");  }
  942. else if ( strVirtKey == _T("Num 9")) { strResult = _T("PgUp"); }
  943. else if ( strVirtKey == _T("Num 3")) { strResult = _T("PgDn"); }
  944. else if ( strVirtKey == _T("Num 0")) { strResult = _T("Ins");  }
  945. else if ( strVirtKey == _T("Num Del")) { strResult = _T("Del");  }
  946. else
  947. {
  948. strResult = strVirtKey;
  949. }
  951. return strResult;
  952. }
  954. //////////////////
  955. // Append the name of accelerator for given command ID to menu string.
  956. // sItemName is menu item name, which will have the accelerator appended.
  957. // For example, might call with sItemName = "File &Open" and return with
  958. // sItemName = "File &OpentCtrl-O". Returns BOOL = whether string changed.
  959. //
  960. BOOL CCoolMenuManager::AppendAccelName(CString& sItemName, UINT nID)
  961. {
  962. int iTabPos = sItemName.Find(_T('t'));
  963. if (iTabPos > 0)
  964. sItemName = sItemName.Left(iTabPos);
  966. BOOL bFound = FALSE;
  967. for (ACCEL* pa = GetAccel(nID); pa; pa -= pa->cmd) {
  968. sItemName += bFound ? _T(", ") : _T("t");
  969. if (pa->fVirt & FALT) sItemName += _T("Alt+");
  970. if (pa->fVirt & FCONTROL) sItemName += _T("Ctrl+");
  971. if (pa->fVirt & FSHIFT) sItemName += _T("Shift+");
  972. if (pa->fVirt & FVIRTKEY) {
  973. TCHAR keyname[64];
  974. UINT vkey = MapVirtualKey(pa->key, 0)<<16;
  975. GetKeyNameText(vkey, keyname, sizeof(keyname));
  976. // Seain Conover (1999/01/09) 
  977. sItemName += GetVirtualKeyName( keyname );
  978. } else
  979. sItemName += (char)pa->key;
  981. bFound = TRUE;
  982. if (pa->cmd == 0)
  983. break;
  984. }
  985. return bFound;
  986. }
  988. //////////////////
  989. // This function fixes MFC's diseased dot bitmap used for
  990. // "radio-style" menu items (CCmdUI->SetRadio), which is completely
  991. // wrong if the menu font is large. 
  992. //
  993. void CCoolMenuManager::FixMFCDotBitmap()
  994. {
  995. HBITMAP hbmDot = GetMFCDotBitmap();
  996. if (hbmDot) {
  997. // Draw a centered dot of appropriate size
  998. BITMAP bm;
  999. ::GetObject(hbmDot, sizeof(bm), &bm);
  1000. CRect rcDot(0,0, bm.bmWidth, bm.bmHeight);
  1001. rcDot.DeflateRect((bm.bmWidth>>1)-2, (bm.bmHeight>>1)-2);
  1003. CWindowDC dcScreen(NULL);
  1004. CDC memdc;
  1005. memdc.CreateCompatibleDC(&dcScreen);
  1006. int nSave = memdc.SaveDC();
  1007. memdc.SelectStockObject(BLACK_PEN);
  1008. memdc.SelectStockObject(BLACK_BRUSH);
  1009. memdc.SelectObject((HGDIOBJ)hbmDot);
  1010. memdc.PatBlt(0, 0, bm.bmWidth, bm.bmHeight, WHITENESS);
  1011. memdc.Ellipse(&rcDot);
  1012. memdc.RestoreDC(nSave);
  1013. }
  1014. }
  1016. //////////////////
  1017. // This function gets MFC's dot bitmap.
  1018. //
  1019. HBITMAP CCoolMenuManager::GetMFCDotBitmap()
  1020. {
  1021. // The bitmap is stored in afxData.hbmMenuDot, but afxData is MFC-private,
  1022. // so the only way to get it is create a menu, set the radio check,
  1023. // and then see what bitmap MFC set in the menu item.
  1024. CMenu menu;
  1025. VERIFY(menu.CreateMenu());
  1026. VERIFY(menu.AppendMenu(MFT_STRING, 0, (LPCTSTR)NULL));
  1027. CCmdUI cui;
  1028. cui.m_pMenu = &menu;
  1029. cui.m_nIndex = 0;
  1030. cui.m_nIndexMax = 1;
  1031. cui.SetRadio(TRUE);
  1032. CMenuItemInfo info;
  1033. info.fMask = MIIM_CHECKMARKS;
  1034. GetMenuItemInfo(menu, 0, MF_BYPOSITION,(MENUITEMINFO *) &info);
  1035. HBITMAP hbmDot = info.hbmpChecked;
  1036. menu.DestroyMenu();
  1037. return hbmDot;
  1038. }
  1040. // Peter Tewkesbury
  1041. BOOL CCoolMenuManager::AddSingleBitmap(UINT nBitmapID, UINT n, UINT *nID)
  1042. {
  1043. // load bitmap
  1044. HBITMAP hbmBitmap = (HBITMAP)::LoadImage(AfxGetInstanceHandle(),
  1045. MAKEINTRESOURCE(nBitmapID), IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
  1046. ASSERT(hbmBitmap);
  1048. if (!hbmBitmap) {
  1049. TRACE(_T("*** Can't load bitmap %d!n"), nBitmapID);
  1050. return FALSE;
  1051. }
  1053. // Assign Bitmap to CBitmap
  1054. CBitmap bmBitmap;
  1055. bmBitmap.Attach(hbmBitmap); // destructor will detach & destroy
  1057. // OK, I have the bitmap - Check that Bitmaps are correct size.
  1058. if (m_szBitmap.cx==0) 
  1059. {
  1060. // First toolbar: initialized bitmap/button sizes and create image list.
  1061. CSize sz(16,15);
  1062. m_szBitmap = sz;
  1063. m_szButton = sz + CSize(CXBUTTONMARGIN<<1, CYBUTTONMARGIN<<1);
  1064. VERIFY(m_ilButtons.Create(sz.cx, sz.cy, ILC_MASK, 0, 10));
  1066. } 
  1068. // Add Bitmap to ImageList
  1069. int iNextImage = m_ilButtons.GetImageCount();
  1070. m_ilButtons.Add(&bmBitmap, GetSysColor(COLOR_3DFACE)); 
  1072. // Add ID to Map.
  1073. for(UINT i=0;i<n;i++)
  1074. {
  1075. if (nID[i] > 0) 
  1076. {
  1077. if (GetButtonIndex(nID[i]) >= 0) 
  1078. {
  1079. TRACE(_T("*** Duplicate button ID %d ignoredn"), nID[i]);
  1080. } 
  1081. else m_mapIDtoImage.SetAt(nID[i], (void*)iNextImage++); 
  1082. }
  1083. }
  1085. // All Done.
  1086. return TRUE;
  1087. }
  1089. ////////////////////////////////////////////////////////////////
  1090. // Helper functions
  1092. //////////////////
  1093. // Load a bitmap, converting the standard colors.
  1094. // Calls AfxLoadSysColorBitmap to do the work.
  1095. //
  1096. // RGB(0x00, 0x00, 0x00) (black)      --> COLOR_BTNTEXT
  1097. // RGB(0x80, 0x80, 0x80) (dark gray)  --> COLOR_3DSHADOW
  1098. // RGB(0xC0, 0xC0, 0xC0) (gray)       --> COLOR_3DFACE
  1099. // RGB(0xFF, 0xFF, 0xFF) (white)      --> COLOR_3DHILIGHT
  1100. // 
  1101. HBITMAP PLLoadSysColorBitmap(LPCTSTR lpResName, BOOL bMono)
  1102. {
  1103. HINSTANCE hInst = AfxFindResourceHandle(lpResName, RT_BITMAP);
  1104. HRSRC hRsrc = ::FindResource(hInst, lpResName, RT_BITMAP);
  1105. if (hRsrc == NULL)
  1106. return NULL;
  1107. return AfxLoadSysColorBitmap(hInst, hRsrc, bMono);
  1108. }
  1110. //////////////////
  1111. // Shorthand to fill a rectangle with a solid color.
  1112. //
  1114. void CCoolMenuManager::PLSelectRect(CDC& dc, const CRect& rc)
  1115. {
  1116. CBrush brush;
  1117. if(m_StyleDisplay==GUISTYLE_2003)
  1118. brush.CreateSolidBrush(GuiDrawLayer::m_Theme ? RGB(252,230,186):GuiDrawLayer::GetRGBFondoXP());
  1119. else
  1120. brush.CreateSolidBrush(GuiDrawLayer::GetRGBFondoXP());
  1121. dc.FillRect(rc,&brush);
  1122. if(m_StyleDisplay==GUISTYLE_2003)
  1123. {
  1124. COLORREF clrNear=dc.GetNearestColor(GuiDrawLayer::GetRGBCaptionXP());
  1125. if(clrNear==13221564)
  1126. {
  1127. dc.Draw3dRect(rc,GuiDrawLayer::GetRGBColorShadow(GUISTYLE_2003),GuiDrawLayer::GetRGBColorShadow(GUISTYLE_2003)); 
  1128. return;
  1129. }
  1131. }
  1132. dc.Draw3dRect(rc,GuiDrawLayer::GetRGBCaptionXP(),GuiDrawLayer::GetRGBCaptionXP()); 
  1134. }
  1136. void CCoolMenuManager::PLNormalRect(CDC& dc, const CRect& rc)
  1137. {
  1138. CRect m_rc=rc;
  1139. CBrush brush;
  1140. brush.CreateSolidBrush(GuiDrawLayer::GetRGBColorXP());
  1141. m_rc.right=m_rc.left+m_szButton.cx+4;
  1142. dc.FillRect(m_rc,&brush);
  1143. brush.DeleteObject( );
  1144. if (m_StyleDisplay==GUISTYLE_2003)
  1145. {
  1146. CGradient M(CSize(m_rc.Width(),m_rc.Height()));
  1147. M.PrepareHorizontal(&dc,m_StyleDisplay);
  1148. M.Draw(&dc,0,m_rc.top,0,0,m_rc.Width(),m_rc.Height(),SRCCOPY);
  1149. }
  1150. m_rc=rc;
  1151. m_rc.left+=m_szButton.cx+4;
  1152. brush.CreateSolidBrush(GuiDrawLayer::GetRGBSkinMenu());
  1153. dc.FillRect(m_rc,&brush);
  1155. }
  1159. // This is the magic ROP code used to generate the embossed look for
  1160. // a disabled button. It's listed in Appendix F of the Win32 Programmer's
  1161. // Reference as PSDPxax (!) which is a cryptic reverse-polish notation for
  1162. //
  1163. // ((Destination XOR Pattern) AND Source) XOR Pattern
  1164. //
  1165. // which I leave to you to figure out. In the case where I apply it,
  1166. // Source is a monochrome bitmap which I want to draw in such a way that
  1167. // the black pixels get transformed to the brush color and the white pixels
  1168. // draw transparently--i.e. leave the Destination alone.
  1169. //
  1170. // black ==> Pattern (brush)
  1171. // white ==> Destintation (ie, transparent)
  1172. //
  1173. // 0xb8074a is the ROP code that does this. For more info, see Charles
  1174. // Petzold, _Programming Windows_, 2nd Edition, p 622-624.
  1175. //
  1176. #define TRANSPARENTROP 0xb8074a
  1178. //////////////////
  1179. // Draw an image with the embossed (disabled) look.
  1180. //
  1181. // dc device context to draw in
  1182. // il image list containing image
  1183. // i index of image to draw
  1184. // p point in dc to draw image at
  1185. //    bColor do color embossing. Default is B/W.
  1186. //
  1187. void PLDrawEmbossed(CDC& dc, CImageList& il, int i,
  1188. CPoint p, BOOL bColor)
  1189. {
  1190. IMAGEINFO info;
  1191. VERIFY(il.GetImageInfo(0, &info));
  1192. CRect rc = info.rcImage;
  1193. int cx = rc.Width();
  1194. int cy = rc.Height();
  1196. // create memory dc
  1197. CDC memdc;
  1198. memdc.CreateCompatibleDC(&dc);
  1200. // create mono or color bitmap
  1201. CBitmap bm;
  1202. if (bColor)
  1203. bm.CreateCompatibleBitmap(&dc, cx, cy);
  1204. else
  1205. bm.CreateBitmap(cx, cy, 1, 1, NULL);
  1207. // draw image into memory DC--fill BG white first
  1208. CBitmap* pOldBitmap = memdc.SelectObject(&bm);
  1209. memdc.PatBlt(0, 0, cx, cy, WHITENESS);
  1210. il.Draw(&memdc, i, CPoint(0,0), ILD_TRANSPARENT);
  1212. // This seems to be required. Why, I don't know. ???
  1213. COLORREF colorOldBG = dc.SetBkColor(RGB(255,255,255)); // white
  1215. // Draw using hilite offset by (1,1), then shadow
  1216. CBrush brShadow(GetSysColor(COLOR_3DSHADOW));
  1217. CBrush brHilite(GetSysColor(COLOR_3DHIGHLIGHT));
  1218. CBrush* pOldBrush = dc.SelectObject(&brHilite);
  1219. dc.BitBlt(p.x+1, p.y+1, cx, cy, &memdc, 0, 0, TRANSPARENTROP);
  1220. dc.SelectObject(&brShadow);
  1221. dc.BitBlt(p.x, p.y, cx, cy, &memdc, 0, 0, TRANSPARENTROP);
  1222. dc.SelectObject(pOldBrush);
  1223. dc.SetBkColor(colorOldBG);  // restore
  1224. memdc.SelectObject(pOldBitmap);  // ...
  1225. }