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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > RichEdit > 查看源码
CoolMenu.cpp
资源名称：VC_full-featured_text_editor_Rich_textEditrich_tex　[点击查看]
上传用户：shilei2004
上传日期：2020-07-18
资源大小：83k
文件大小：34k
源码类别：

RichEdit

开发平台：

Visual C++

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