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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
CoolMenu.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：36k
源码类别：

金融证券系统

开发平台：

Visual C++

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