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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
UICoolMenu.cpp
资源名称：isee_code01231.zip　[点击查看]
上传用户：yatsl7111
上传日期：2007-01-08
资源大小：1433k
文件大小：48k
源码类别：

图形图象

开发平台：

Visual C++

UICoolMenu.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. //    1.08  7 Jul 2000 - Philip Oldaker [philip@masmex.com] - Added support for
  38. // IContextMenu2 as used by the windows shell for owner draw menus
  39. // ==========================================================================
  40. //
  41. /////////////////////////////////////////////////////////////////////////////
  43. #include "StdAfx.h"
  44. #include "UICoolMenu.h"
  46. #include <afxpriv.h>
  48. #ifdef _DEBUG
  49. #define new DEBUG_NEW
  50. #undef THIS_FILE
  51. static char THIS_FILE[] = __FILE__;
  52. #endif
  54. #define safe_delete(p){if(p){delete p;p=NULL;}}
  56. #define USES_ICON  -2
  58. CCoolMenuManager g_CoolMenuManager;
  60. // helpers
  61. void PLFillRect(CDC& dc, const CRect& rc, COLORREF color);
  62. void PLDrawEmbossed(CDC& dc, CImageList& il, int i,
  63.   CPoint p, BOOL bColor=FALSE);
  64. HBITMAP PLLoadSysColorBitmap(LPCTSTR lpResName, BOOL bMono=FALSE);
  65. inline HBITMAP PLLoadSysColorBitmap(UINT nResID, BOOL bMono=FALSE) {
  66.   return PLLoadSysColorBitmap(MAKEINTRESOURCE(nResID), bMono);
  67. }
  69. // if you want to see extra TRACE diagnostics, set below to TRUE
  70. BOOL CCoolMenuManager::bTRACE = FALSE;
  72. #ifdef _DEBUG
  73. #define CMTRACEFN     
  74.   CTraceFn __fooble;  
  75.   if (bTRACE)       
  76.     TRACE
  77. #define CMTRACE     
  78.   if (bTRACE)       
  79.     TRACE
  80. #else
  81. #define CMTRACEFN TRACE
  82. #define CMTRACE   TRACE
  83. #endif
  85. // constants used for drawing
  86. const CXGAP = 1;        // num pixels between button and text
  87. const CXTEXTMARGIN = 2;   // num pixels after hilite to start text
  88. const CXBUTTONMARGIN = 2; // num pixels wider button is than bitmap
  89. const CYBUTTONMARGIN = 2; // ditto for height
  91. // DrawText flags
  92. const DT_MYSTANDARD = DT_SINGLELINE|DT_LEFT|DT_VCENTER;
  94. // identifies owner-draw data as mine
  95. const LONG MYITEMID = MAKELONG(MAKEWORD(_T('m'),_T('i')),MAKEWORD(_T('d'),_T('0')));
  97. // private struct: one of these for each owner-draw menu item
  98. struct CMyItemData {
  99.     long    magicNum;   // magic number identifying me
  100.     CString text;       // item text
  101.     UINT    fType;      // original item type flags
  102.     int     iButton;    // index of button image in image list (or USES_ICON)
  103.     HICON   hIcon;
  104.     void *  pContext; // item data
  105. LPCONTEXTMENU lpcm; // if set this will handle menu messages (windows shell)
  106.     CMyItemData()       { lpcm=NULL; magicNum = MYITEMID; iButton = -1; hIcon = 0; pContext = NULL; }
  107.     ~CMyItemData()        { text.Empty(); if (hIcon) ::DestroyIcon(hIcon); if (lpcm) lpcm->Release(); }
  108.     BOOL IsMyItemData()   { return this != NULL  &&  magicNum == MYITEMID; }
  109. };
  111. static CMyItemData *GetMyItemData(HMENU hMenu, UINT uItem, 
  112.                                   BOOL bByPosition = FALSE)
  113. {
  114.     MENUITEMINFO mii;
  115. ZeroMemory(&mii,sizeof(mii));
  116.     mii.cbSize = sizeof(mii);
  117.     mii.fMask  = MIIM_DATA;
  118.     ::GetMenuItemInfo(hMenu, uItem, bByPosition, &mii);
  119.     return (CMyItemData *)mii.dwItemData;
  120. }
  122. static void SetMyItemData(CMyItemData *pmd, HMENU hMenu, UINT uItem, 
  123.                           BOOL bByPosition = FALSE)
  124. {
  125.     MENUITEMINFO mii;
  126.     mii.cbSize     = sizeof(mii);
  127.     mii.fMask      = MIIM_DATA;
  128.     mii.dwItemData = (DWORD)pmd;
  129.     ::SetMenuItemInfo(hMenu, uItem, bByPosition, &mii);
  130. }
  133. IMPLEMENT_DYNAMIC(CCoolMenuManager, CSubclassWnd)
  135. CCoolMenuManager::CCoolMenuManager()
  136. {
  137. m_lpcm = NULL;
  138. m_szBitmap = CSize(0,0); // will compute later
  139. m_szButton = CSize(0,0); 
  140. m_bShowButtons = TRUE;            // show buttons by default
  141. m_bAutoAccel = TRUE;              // auto accelerators by default
  142. m_pAccel = NULL;                // no accelerators loaded yet
  143. m_bUseDrawState = FALSE;          // use DrawEmbossed by default
  144. m_bDrawDisabledButtonsInColor = FALSE;  // use color for disabled buttons
  145. FixMFCDotBitmap();
  146. }
  148. CCoolMenuManager::~CCoolMenuManager()
  149. {
  150.   // Jeremy Horgan [jeremyhorgan@hotmail.com]
  152.   while (!m_menuList.IsEmpty()) 
  153.   {
  154.       UnconvertMenu(CMenu::FromHandle((HMENU)m_menuList.RemoveHead()));
  155.   }
  156.   
  157.   Destroy();
  158. }
  160. //////////////////
  161. // Destroy everything. Called from destructor and Refresh.
  162. //
  163. void CCoolMenuManager::Destroy()
  164. {
  165.   m_ilButtons.DeleteImageList();
  166.   m_ilTemp.DeleteImageList();
  167.   m_mapIDtoImage.RemoveAll();
  168.   m_mapHMENUtoID.RemoveAll();
  169.   m_szBitmap = m_szButton = CSize(0,0);
  170.   m_arToolbarID.RemoveAll();
  171.   m_fontMenu.DeleteObject();
  172.   DestroyAccel();
  173. }
  175. /////////////////
  176. // Destroy accelerators
  177. //
  178. void CCoolMenuManager::DestroyAccel()
  179. {
  180.   m_mapIDtoAccel.RemoveAll();   // delete ACCEL entries in map
  181.   safe_delete(m_pAccel);      // delete current accelerators
  182. }
  184. //////////////////
  185. // Call this to install the menu manager. Install(NULL) to un-install.
  186. //
  187. void CCoolMenuManager::Install(CWnd* pFrame)
  188. {
  189. m_pFrame = pFrame;
  190. HookWindow(pFrame);   // install message hook
  191. }
  193. void CCoolMenuManager::Uninstall()
  194. {
  195. m_pFrame = NULL;
  196. HookWindow((HWND)NULL); 
  197. }
  199. // Addition: Phliip Oldaker
  200. // call this to enable help text on the status bar
  201. void CCoolMenuManager::SetShellContextMenu(LPCONTEXTMENU lpcm,UINT nIDFirst,UINT nIDLast)
  202. {
  203. m_lpcm = lpcm;
  204. m_idShellMenuFirst = nIDFirst;
  205. m_idShellMenuLast = nIDLast;
  206. }
  208. //////////////////
  209. // Load array of toolbar IDs.
  210. //
  211. BOOL CCoolMenuManager::LoadToolbars(const UINT* arID, int n)
  212. {
  213.   ASSERT(arID);
  214.   BOOL bRet = TRUE;
  215.   for (int i=0; i<n; i++)
  216.     bRet |= LoadToolbar(arID[i]);
  217.   return bRet;
  218. }
  220. // structure of RT_TOOLBAR resource
  221. struct TOOLBARDATA {
  222.   WORD wVersion;    // version # should be 1
  223.   WORD wWidth;    // width of one bitmap
  224.   WORD wHeight;   // height of one bitmap
  225.   WORD wItemCount;  // number of items
  226.   WORD items[1];    // array of command IDs, actual size is wItemCount
  227. };
  229. // Addition: Philip Oldaker
  230. CSize CCoolMenuManager::SetButtonSize(CSize &sz)
  231. {
  232. // Set defaults
  233. if (sz.cx == 0)
  234. sz.cx = 16;
  235. if (sz.cy == 0)
  236. sz.cy = 15;
  237. CSize szOld(m_szBitmap);
  238. m_szBitmap = sz;
  239. m_szButton = sz + CSize(CXBUTTONMARGIN<<1, CYBUTTONMARGIN<<1);
  240. return szOld;
  241. }
  243. //////////////////
  244. // Load one toolbar. Assumes bg color is gray.
  245. // 
  246. //  * add toolbar bitmap to image list
  247. //   * add each button ID to button map
  248. //
  249. BOOL CCoolMenuManager::LoadToolbar(UINT nIDToolbar)
  250. {
  251.   // load bitmap
  252.   HBITMAP hbmToolbar = PLLoadSysColorBitmap(nIDToolbar);
  253.   if (!hbmToolbar) {
  254.     TRACE(_T("*** Can't load bitmap for toolbar %d!n"), nIDToolbar);
  255.     return FALSE;
  256.   }
  258.   // load toolbar
  259.   LPTSTR lpResName = MAKEINTRESOURCE(nIDToolbar);
  260.   HINSTANCE hInst;
  261.   HRSRC hRsrc;
  262.   TOOLBARDATA* ptbd;
  263.   if ((hInst= AfxFindResourceHandle(lpResName, RT_TOOLBAR)) == NULL ||
  264.      (hRsrc= FindResource(hInst, lpResName, RT_TOOLBAR))   == NULL ||
  265.      (ptbd = (TOOLBARDATA*)LoadResource(hInst, hRsrc))     == NULL) {
  267.     TRACE(_T("*** Can't load toolbar %d!n"), nIDToolbar);
  268.     return FALSE;
  269.   }
  270.   ASSERT(ptbd->wVersion==1);
  271.     
  272.   // OK, I have the bitmap and toolbar. 
  274.   CSize sz(ptbd->wWidth, ptbd->wHeight);
  275.   if (m_szBitmap.cx==0) {
  276.     // First toolbar: initialized bitmap/button sizes and create image list.
  277.     m_szBitmap = sz;
  278.     m_szButton = sz + CSize(CXBUTTONMARGIN<<1, CYBUTTONMARGIN<<1);
  279.     VERIFY(m_ilButtons.Create(sz.cx, sz.cy, ILC_COLOR32|ILC_MASK, 0, 10));
  280.     VERIFY(m_ilTemp.   Create(sz.cx, sz.cy, ILC_COLOR32|ILC_MASK, 0, 10));
  282.   } else if (m_szBitmap != sz) {
  283.     // button sizes different -- oops
  284.     TRACE(_T("*** Toolbar %d button size differs!n"), nIDToolbar);
  285.     return FALSE;
  286.   }
  288.   m_ilButtons.SetBkColor(::GetSysColor(COLOR_3DFACE));
  290.   // I have a good toolbar: now add bitmap to the image list, and each
  291.   // command ID to m_mapIDtoImage array. Note that LoadSysColorBitmap will
  292.   // change gray -> COLOR_3DFACE, so use that for image list background.
  293.   //
  294.   int iNextImage = m_ilButtons.GetImageCount();
  295.   m_ilButtons.Add(CBitmap::FromHandle(hbmToolbar), GetSysColor(COLOR_3DFACE));
  296.   for (int i = 0; i < ptbd->wItemCount; i++) {
  297.     UINT nID = ptbd->items[i];
  298.     if (nID > 0) {
  299.       if (GetButtonIndex(nID) >= 0) {
  300.         TRACE(_T("*** Duplicate button ID %d ignoredn"), nID);
  301.       } else {
  302.         m_mapIDtoImage.SetAt(nID, (void*)iNextImage);
  303.         TRACE(_T("CCoolMenuManager::LoadToolbar(). Added Menu Id %d, Button Number %dn"), nID, iNextImage-1);
  304.       }
  305.       // AB. 13-08-98. Since we've already added the entire toolbar to the imagelist
  306.       // we need to increment nNextImage even if we didn't add this button to
  307.       // m_mapIDtoImage.
  308.       iNextImage++;
  309.     }
  310.   }
  311.   m_arToolbarID.Add(nIDToolbar);  // remember toolbar ID for Refresh
  312.   ::DeleteObject(hbmToolbar);
  313.   return TRUE; // success!
  314. }
  316. //////////////////
  317. // Virtual CCoolMenuSubclassWnd window proc. All messages come here before frame
  318. // window. Isn't it cool? Just like in the old days!
  319. //
  320. LRESULT CCoolMenuManager::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
  321. {
  322.   switch(msg) {
  323.       case WM_SYSCOLORCHANGE:
  324.       case WM_SETTINGCHANGE:
  325.         Refresh();
  326.         break;
  328.       case WM_MEASUREITEM:
  329.         if (OnMeasureItem((MEASUREITEMSTRUCT*)lp))
  330.           return TRUE; // handled
  331.         break;
  333.       case WM_DRAWITEM:
  334.         if (OnDrawItem((DRAWITEMSTRUCT*)lp))
  335.           return TRUE; // handled
  336.         break;
  338.       case WM_INITMENUPOPUP:
  339.         // Very important: must let frame window handle it first!
  340.         // Because if someone calls CCmdUI::SetText, MFC will change item to
  341.         // MFT_STRING, so I must change back to MFT_OWNERDRAW.
  342.         //
  343.         CSubclassWnd::WindowProc(msg, wp, lp);
  344.         OnInitMenuPopup(CMenu::FromHandle((HMENU)wp),
  345.           /*(UINT)LOWORD(lp)*/0, (BOOL)HIWORD(lp));
  346.         return 0;
  348.       case WM_MENUSELECT:
  349.         OnMenuSelect((UINT)LOWORD(wp), (UINT)HIWORD(wp), (HMENU)lp);
  350.         break;
  352.       case WM_MENUCHAR:
  353.         LRESULT lr = OnMenuChar((TCHAR)LOWORD(wp), (UINT)HIWORD(wp),
  354.           CMenu::FromHandle((HMENU)lp));
  355.         if (lr!=0)
  356.           return lr;
  357.         break;
  358.   }
  359.   return CSubclassWnd::WindowProc(msg, wp, lp);
  360. }
  362. //////////////////
  363. // Refresh all colors, fonts, etc. For WM_SETTINGCHANGE, WM_SYSCOLORCHANGE.
  364. //
  365. void CCoolMenuManager::Refresh()
  366. {
  367.   // first copy list (array) of toolbar IDs now loaded.
  368.   CUIntArray arToolbarID;
  369.   arToolbarID.Copy(m_arToolbarID);
  371.   // destroy everything
  372.   Destroy();
  374.   // re-load toolbars.
  375.   int nToolbars = arToolbarID.GetSize();
  376.   for (int i = 0; i < nToolbars; i++)
  377.     LoadToolbar(arToolbarID[i]);
  378. }
  380. //////////////////
  381. // Get menu font, creating if needed
  382. //
  383. CFont* CCoolMenuManager::GetMenuFont()
  384. {
  385.   if (!(HFONT)m_fontMenu) {
  386.     NONCLIENTMETRICS info;
  387.     info.cbSize = sizeof(info);
  388.     SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  389.     VERIFY(m_fontMenu.CreateFontIndirect(&info.lfMenuFont));
  390.   }
  391.   return &m_fontMenu;
  392. }
  394. //////////////////
  395. // Handle WM_MEASUREITEM on behalf of frame: compute menu item size.
  396. //
  397. BOOL CCoolMenuManager::OnMeasureItem(LPMEASUREITEMSTRUCT lpms)
  398. {
  399. ASSERT(lpms);
  400. CMyItemData* pmd = (CMyItemData*)lpms->itemData;
  401. ASSERT(pmd);
  402. if (lpms->CtlType != ODT_MENU || !pmd->IsMyItemData())
  403. return FALSE; // not handled by me
  404. // Addition: Philip Oldaker
  405. // Pass it on to the shell if lpcm has been set
  406. if (pmd->lpcm)
  407. {
  408. IContextMenu2 *lpcm2=NULL;
  409. HRESULT hr = pmd->lpcm->QueryInterface(IID_IContextMenu2,(LPVOID*)&lpcm2);
  410. if (SUCCEEDED(hr))
  411. {
  412. // switch context item data
  413. lpms->itemData = (DWORD)pmd->pContext;
  414. lpcm2->HandleMenuMsg(WM_MEASUREITEM,0,(LPARAM)lpms);
  415. // clean up
  416. lpms->itemData = (DWORD)pmd;
  417. lpcm2->Release();
  418. }
  419. return TRUE;
  420. }
  421. /////////////////////
  422. if (pmd->fType & MFT_SEPARATOR) {
  423. // separator: use half system height and zero width
  424. lpms->itemHeight = GetSystemMetrics(SM_CYMENU)>>1;
  425. lpms->itemWidth  = 0;
  427. } else {
  429.     // compute size of text: use DrawText with DT_CALCRECT
  431.     CWindowDC dc(NULL); // screen DC--I won't actually draw on it
  432.     CRect rcText(0,0,0,0);
  433.     CFont* pOldFont = dc.SelectObject(GetMenuFont());
  434.     dc.DrawText(pmd->text, rcText, DT_MYSTANDARD|DT_CALCRECT);
  435.     dc.SelectObject(pOldFont);
  437.     // height of item is just height of a standard menu item
  438.     lpms->itemHeight= max(GetSystemMetrics(SM_CYMENU), rcText.Height());
  440.     // width is width of text plus a bunch of stuff
  441.     int cx = rcText.Width();  // text width 
  442.     cx += CXTEXTMARGIN<<1;    // L/R margin for readability
  443.     cx += CXGAP;          // space between button and menu text
  444.     cx += m_szButton.cx<<1;   // button width (L=button; R=empty margin)
  446.     // whatever value I return in lpms->itemWidth, Windows will add the
  447.     // width of a menu checkmark, so I must subtract to defeat Windows. Argh.
  448.     //
  449.     cx -= GetSystemMetrics(SM_CXMENUCHECK)-1;
  450.     lpms->itemWidth = cx;   // done deal
  452.     CMTRACE(_T("OnMeasureItem for '%s':tw=%d h=%dn"), (LPCTSTR)pmd->text,
  453.       lpms->itemWidth, lpms->itemHeight);
  454.   }
  455.   return TRUE; // handled
  456. }
  458. /////////////////
  459. // Handle WM_DRAWITEM on behalf of frame. Note: in all that goes
  460. // below, can't assume rcItem.left=0 because of multi-column menus!
  461. //
  462. BOOL CCoolMenuManager::OnDrawItem(LPDRAWITEMSTRUCT lpds)
  463. {
  464. ASSERT(lpds);
  466. // Omar L Francisco
  467. if (lpds->CtlType != ODT_MENU)
  468. return FALSE;
  469.   
  470. // Omar L Francisco
  471. CMyItemData* pmd = (CMyItemData*)lpds->itemData;
  472. if (!pmd->IsMyItemData())
  473. return FALSE;
  474. // Addition: Philip Oldaker
  475. // Pass it on to the shell if this has been set
  476. if (pmd->lpcm)
  477. {
  478. IContextMenu2 *lpcm2=NULL;
  479. HRESULT hr = pmd->lpcm->QueryInterface(IID_IContextMenu2,(LPVOID*)&lpcm2);
  480. if (SUCCEEDED(hr))
  481. {
  482. lpds->itemData = (DWORD)pmd->pContext;
  483. lpcm2->HandleMenuMsg(WM_DRAWITEM,0,(LPARAM)lpds);
  484. lpds->itemData = (DWORD)pmd;
  485. lpcm2->Release();
  486. }
  487. return TRUE;
  488. }
  489. ////////////////////////////////
  490.   ASSERT(lpds->itemAction != ODA_FOCUS);
  491.   ASSERT(lpds->hDC);
  492.   CDC dc;
  493.   dc.Attach(lpds->hDC);
  495.   const CRect& rcItem = lpds->rcItem;
  496.   if (pmd->fType & MFT_SEPARATOR) {
  497.     // draw separator
  498.     CRect rc = rcItem;                // copy rect
  499.     rc.top += rc.Height()>>1;           // vertical center
  500.     dc.DrawEdge(&rc, EDGE_ETCHED, BF_TOP);    // draw separator line
  502.   } else {                          // not a separator
  504.     CMTRACE(_T("OnDrawItem for '%s':tw=%d h=%dn"), (LPCTSTR)pmd->text,
  505.       rcItem.Width(), rcItem.Height());
  507.     BOOL bDisabled = lpds->itemState & ODS_GRAYED;
  508.     BOOL bSelected = lpds->itemState & ODS_SELECTED;
  509.     BOOL bChecked  = lpds->itemState & ODS_CHECKED;
  510.     BOOL bHaveButn=FALSE;
  512.     // Paint button, or blank if none
  513.     CRect rcButn(rcItem.TopLeft(), m_szButton); // button rect
  514.     rcButn += CPoint(0,                 // center vertically
  515.       (rcItem.Height() - rcButn.Height())>>1 );
  517.     int iButton = pmd->iButton;
  518.     if (iButton >= 0  ||  iButton == USES_ICON) 
  519.     {
  520.       // this item has a button!
  521.       bHaveButn = TRUE;
  523.       // compute point to start drawing
  524.       CSize sz = rcButn.Size() - m_szBitmap;
  525.       sz.cx >>= 1;
  526.       sz.cy >>= 1;
  527.       CPoint p(rcButn.TopLeft() + sz);
  529.       // draw disabled or normal
  530.       if (!bDisabled) {
  531.         // normal: fill BG depending on state
  532.         PLFillRect(dc, rcButn, GetSysColor(
  533.           (bChecked && !bSelected) ? COLOR_3DLIGHT : COLOR_MENU));
  535.         // draw pushed-in or popped-out edge
  536.         if (bSelected || bChecked) {
  537.           CRect rc2 = rcButn;
  538.           dc.DrawEdge(rc2, bChecked ? BDR_SUNKENOUTER : BDR_RAISEDINNER,
  539.             BF_RECT);
  540.         }
  542.         // draw the button!
  543.         if (iButton != USES_ICON)
  544.         {
  545.             m_ilButtons.Draw(&dc, iButton, p, ILD_TRANSPARENT);
  546.         }
  547.         else
  548.         {
  549.             dc.DrawState(p, CSize(0,0), pmd->hIcon, DSS_NORMAL, 
  550.                 (HBRUSH)NULL);
  551.         }
  553.       } else if (m_bUseDrawState) {
  554.         // use DrawState to draw disabled button: must convert to icon
  555.         if (iButton != USES_ICON)
  556.         {
  557.             HICON hIcon=m_ilButtons.ExtractIcon(iButton);
  558.             ASSERT(hIcon);
  559.             dc.DrawState(p, CSize(0,0), hIcon, DSS_DISABLED, (HBRUSH)NULL);
  560.             DestroyIcon(hIcon);
  561.         }
  562.         else
  563.         {
  564.             dc.DrawState(p, CSize(0,0), pmd->hIcon, DSS_DISABLED, 
  565.                 (HBRUSH)NULL);
  566.         }
  567.       } else
  568.         // use DrawEmbossed to draw disabeld button, w/color flag
  569.         if (iButton != USES_ICON)
  570.         {
  571.             PLDrawEmbossed(dc, m_ilButtons, iButton, p,
  572.               m_bDrawDisabledButtonsInColor);
  573.         }
  574.         else
  575.         {
  576.             int i = m_ilTemp.Add(pmd->hIcon);
  577.             PLDrawEmbossed(dc, m_ilTemp, i, p, 
  578.                 m_bDrawDisabledButtonsInColor);
  579.             m_ilTemp.Remove(i);
  580.         }
  581.     } else {
  582.       // no button: look for custom checked/unchecked bitmaps
  583.       CMenuItemInfo info;
  584.       info.fMask = MIIM_CHECKMARKS;
  585.       GetMenuItemInfo((HMENU)lpds->hwndItem,
  586.         lpds->itemID, MF_BYCOMMAND, &info);
  587.       if (bChecked || info.hbmpUnchecked) {
  588.         bHaveButn = Draw3DCheckmark(dc, rcButn, bSelected,
  589.           bChecked ? info.hbmpChecked : info.hbmpUnchecked);
  590.       }
  591.     }
  593.     // Done with button, now paint text. First do background if needed.
  594.     int cxButn = m_szButton.cx;       // width of button
  595.     COLORREF colorBG = GetSysColor(bSelected ? COLOR_HIGHLIGHT : COLOR_MENU);
  596.     if (bSelected || lpds->itemAction==ODA_SELECT) {
  597.       // selected or selection state changed: paint text background
  598.       CRect rcBG = rcItem;              // whole rectangle
  599.       if (bHaveButn)                  // if there's a button:
  600.         rcBG.left += cxButn + CXGAP;      //  don't paint over it!
  601.       PLFillRect(dc, rcBG, colorBG);  // paint it!
  602.     }
  604.     // compute text rectangle and colors
  605.     CRect rcText = rcItem;         // start w/whole item
  606.     rcText.left += cxButn + CXGAP + CXTEXTMARGIN; // left margin
  607.     rcText.right -= cxButn;        // right margin
  608.     dc.SetBkMode(TRANSPARENT);       // paint transparent text
  609.     COLORREF colorText = GetSysColor(bDisabled ?  COLOR_GRAYTEXT :
  610.       bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT);
  612.     // Now paint menu item text.  No need to select font,
  613.     // because windows sets it up before sending WM_DRAWITEM
  614.     //
  615.     if (bDisabled && (!bSelected || colorText == colorBG)) {
  616.       // disabled: draw hilite text shifted southeast 1 pixel for embossed
  617.       // look. Don't do it if item is selected, tho--unless text color same
  618.       // as menu highlight color. Got it?
  619.       //
  620.       DrawMenuText(dc, rcText + CPoint(1,1), pmd->text,
  621.         GetSysColor(COLOR_3DHILIGHT));
  622.     }
  623.     DrawMenuText(dc, rcText, pmd->text, colorText); // finally!
  624.   }
  625.   dc.Detach();
  627.   return TRUE; // handled
  628. }
  630. /////////////////
  631. // Helper function to draw justified menu text. If the text contains a TAB,
  632. // draw everything after the tab right-aligned
  633. //
  634. void CCoolMenuManager::DrawMenuText(CDC& dc, CRect rc, CString text,
  635.   COLORREF color)
  636. {
  637.   CString left = text;
  638.   CString right;
  639.   int iTabPos = left.Find(_T('t'));
  640.   if (iTabPos >= 0) {
  641.     right = left.Right(left.GetLength() - iTabPos - 1);
  642.     left  = left.Left(iTabPos);
  643.   }
  644.   dc.SetTextColor(color);
  645.   dc.DrawText(left, &rc, DT_MYSTANDARD);
  646.   if (iTabPos > 0)
  647.     dc.DrawText(right, &rc, DT_MYSTANDARD|DT_RIGHT);
  648. }
  650. #ifndef OBM_CHECK
  651. #define OBM_CHECK 32760 // from winuser.h
  652. #endif
  654. //////////////////
  655. // Draw 3D checkmark
  656. //
  657. //    dc        device context to draw in
  658. //    rc        rectangle to center bitmap in
  659. //    bSelected TRUE if button is also selected
  660. //    hbmCheck    Checkmark bitmap to use, or NULL for default
  661. //
  662. BOOL CCoolMenuManager::Draw3DCheckmark(CDC& dc, const CRect& rc,
  663.   BOOL bSelected, HBITMAP hbmCheck)
  664. {
  665.   // get checkmark bitmap if none, use Windows standard
  666.   if (!hbmCheck) {
  667.     CBitmap bm;
  668.     VERIFY(bm.LoadOEMBitmap(OBM_CHECK));
  669.     hbmCheck = (HBITMAP)bm.Detach();
  670.     ASSERT(hbmCheck);
  671.   }
  672.   
  673.   // center bitmap in caller's rectangle
  674.   BITMAP bm;
  675.   ::GetObject(hbmCheck, sizeof(bm), &bm);
  676.   int cx = bm.bmWidth;
  677.   int cy = bm.bmHeight;
  678.   CRect rcDest = rc;
  679.   CPoint p(0,0);
  680.   CSize delta(CPoint((rc.Width() - cx)/2, (rc.Height() - cy)/2));
  681.   if (rc.Width() > cx)
  682.     rcDest = CRect(rc.TopLeft() + delta, CSize(cx, cy));
  683.   else
  684.     p -= delta;
  686.   // select checkmark into memory DC
  687.   CDC memdc;
  688.   memdc.CreateCompatibleDC(&dc);
  689.   HBITMAP hOldBM = (HBITMAP)::SelectObject(memdc, hbmCheck);
  691.   // set BG color based on selected state
  692.   COLORREF colorOld =
  693.     dc.SetBkColor(GetSysColor(bSelected ? COLOR_MENU : COLOR_3DLIGHT));
  694.   dc.BitBlt(rcDest.left, rcDest.top, rcDest.Width(), rcDest.Height(),
  695.     &memdc, p.x, p.y, SRCCOPY);
  696.   dc.SetBkColor(colorOld);
  698.   ::SelectObject(memdc, hOldBM); // restore
  700.   // draw pushed-in hilight.
  701.   if (rc.Width() > cx)        // if room:
  702.     rcDest.InflateRect(1,1);  // inflate checkmark by one pixel all around
  703.   dc.DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT);
  705.   return TRUE;
  706. }
  708. //////////////////
  709. // Handle WM_INITMENUPOPUP on behalf of frame.
  710. //
  711. void CCoolMenuManager::OnInitMenuPopup(CMenu* pMenu,
  712.   UINT nIndex, BOOL bSysMenu)
  713. {
  714. // Addition: Philip Oldaker
  715. /////////////////////////
  716. // Let the shell handle it
  717. if (bSysMenu)
  718. return;
  719. for(UINT i=0;i < pMenu->GetMenuItemCount();i++)
  720. {
  721. CMyItemData* pmd = GetMyItemData(*pMenu,i,TRUE);
  722. if (pmd->IsMyItemData() && pmd->lpcm)
  723. {
  724. IContextMenu2 *lpcm2=NULL;
  725. HRESULT hr = pmd->lpcm->QueryInterface(IID_IContextMenu2,(LPVOID*)&lpcm2);
  726. if (SUCCEEDED(hr))
  727. {
  728. SetMyItemData((CMyItemData*)pmd->pContext,*pMenu,i,TRUE); 
  729. lpcm2->HandleMenuMsg(WM_INITMENUPOPUP,(WPARAM)pMenu->GetSafeHmenu(),0);
  730. SetMyItemData(pmd,*pMenu,i,TRUE); 
  731. lpcm2->Release();
  732. }
  733. return;
  734. }
  735. }
  736. //////////////////////
  737.   if (m_bAutoAccel)
  738.   {
  739.     // check for new accels. If ASSERT bombs,
  740.     // you forgot to call Install.
  741. //    ASSERT_VALID(m_pFrame);
  742.     
  743. //    HACCEL hAccel = m_pFrame->GetDefaultAccelerator();
  744.     HACCEL hAccel = NULL;
  745.     
  746.     if (hAccel != m_hAccel)
  747.       LoadAccel(hAccel);
  749.     // 12 Nov 1998  - Wang Jun - Fixes debug assert in system menu.
  750.     // Check if click system menu.
  751.     if (!bSysMenu) {
  752.       ConvertMenu(pMenu, nIndex, bSysMenu, m_bShowButtons);
  753.     }
  754.   }
  755.   ConvertMenu(pMenu, nIndex, bSysMenu, m_bShowButtons);
  756. }
  758. //////////////////
  759. // Set the accelerator table used to generate automatic key
  760. // names in menus. Delete previous table if any.
  761. //
  762. void CCoolMenuManager::LoadAccel(HACCEL hAccel)
  763. {
  764.   DestroyAccel();
  765.   int nAccel;
  766.   if (hAccel && (nAccel = CopyAcceleratorTable(hAccel, NULL, 0)) > 0) {
  767.     m_pAccel = new ACCEL [nAccel];
  768.     ASSERT(m_pAccel);
  769.     CopyAcceleratorTable(hAccel, m_pAccel, nAccel);
  771.     // Now I have the accelerators. Look over list, linking each command
  772.     // ID with its ACCEL structure--i.e., m_mapIDtoAccel[nID] = ACCEL for
  773.     // that ID. If more than one ACCEL for a given command (command has more
  774.     // than one shortcut), fix up so ACCEL.cmd is offset of prev ACCEL
  775.     // 
  776.     for (int i=0; i<nAccel; i++) {
  777.       ACCEL& ac = m_pAccel[i];
  778.       ACCEL* pAccel = GetAccel(ac.cmd);
  779.       m_mapIDtoAccel.SetAt(ac.cmd, &ac);
  780.       ac.cmd = pAccel ? &ac - pAccel : 0; // ac.cmd = offset of prev, or 0
  781.     }
  782.   }
  783. }
  785. void CCoolMenuManager::ConvertMenu(CMenu *pMenu)
  786. {
  787.     ConvertMenu(pMenu, 0, FALSE, TRUE);
  788. }
  790. void CCoolMenuManager::UnconvertMenu(CMenu *pMenu)
  791. {
  792.     ConvertMenu(pMenu, 0, FALSE, FALSE);
  793. }
  795. void CCoolMenuManager::ConvertMenuItem(CMenu *pMenu, int iIndex, 
  796.     bool bRecurse /*= true*/, bool bUnconvert /*= false*/)
  797. {
  798.     ASSERT_VALID(pMenu);
  799.     CString   sItemName;
  801.     // get menu item info
  802.     TCHAR itemname[_MAX_PATH];
  803.     CMenuItemInfo info;
  804.     info.fMask = MIIM_SUBMENU | MIIM_DATA | MIIM_ID | MIIM_TYPE;
  805.     info.dwTypeData = itemname;
  806.     info.cch = sizeof(itemname);
  807.     ::GetMenuItemInfo(*pMenu, iIndex, TRUE, &info);
  808.     
  809.     // O.S. - ignore separators
  810.     if (info.fType & MFT_SEPARATOR)
  811.         return;
  813.     CMyItemData* pmd = (CMyItemData*)info.dwItemData;
  814.     // O.S. - recurse sub-menus
  815.     if (bRecurse && info.hSubMenu)
  816.     {
  817.         ConvertMenu(pMenu->GetSubMenu(iIndex), 0, FALSE, !bUnconvert);
  818.     }
  819.     
  820.     if ((info.fType & MFT_OWNERDRAW)  && pmd  &&  !pmd->IsMyItemData()) {
  821.         CMTRACE(_T("CCoolMenuManager: ignoring foreign owner-draw itemn"));
  822.         return;
  823.         // owner-draw menu item isn't mine--leave it alone
  824.     }
  825.     
  826. /*    // Koji MATSUNAMI 1999.2.23
  827.     //
  828.     if (bSysMenu && info.wID >= 0xF000) {
  829.         CMTRACE(_T("CCoolMenuManager: ignoring sys menu itemn"));
  830.         continue; // don't do for system menu commands
  831.     }
  832. */    
  833.     // now that I have the info, I will modify it
  834.     info.fMask = 0; // assume nothing to change
  835.     
  836.     if (!bUnconvert) 
  837.     {
  838.         // I'm showing buttons: convert to owner-draw
  839.         
  840.         if (!(info.fType & MFT_OWNERDRAW))
  841. {
  842.             // If not already owner-draw, make it so. NOTE: If app calls
  843.             // pCmdUI->SetText to change the text of a menu item, MFC will
  844.             // turn the item to MFT_STRING. So I must set it back to
  845.             // MFT_OWNERDRAW again. In this case, the menu item data (pmd)
  846.             // will still be there.
  847.             // 
  848.             info.fType |= MFT_OWNERDRAW;
  849.             info.fMask |= MIIM_TYPE;
  850.             if (!pmd || (pmd && !pmd->IsMyItemData()))
  851. {                   // if no item data:
  852. if (pmd && !pmd->IsMyItemData())
  853. {
  854. CMyItemData* pnmd = new CMyItemData;    //   create one
  855. pnmd->pContext = pmd;
  856. pmd = pnmd;
  857. }
  858. else
  859. pmd = new CMyItemData;    //   create one
  860.                 ASSERT(pmd);              //   (I hope)
  861.                 pmd->fType = info.fType;  //   handy when drawing
  862.                 if (info.hSubMenu)
  863.                 {
  864.                     int nID;
  865.                     if (m_mapHMENUtoID.Lookup((void *)info.wID, (WORD&)nID))
  866.                     {
  867.                         pmd->iButton = GetButtonIndex(nID);
  868.                     }
  869.                     else
  870.                     {
  871.                         pmd->iButton = -1;
  872.                     }
  873.                 }
  874.                 else
  875.                     pmd->iButton = GetButtonIndex(info.wID);
  876.                 
  877.                 info.dwItemData = (DWORD)pmd;   //   set in menu item data
  878.                 info.fMask |= MIIM_DATA;      //   set item data
  879.             }
  880.             pmd->text = info.dwTypeData;      // copy menu item string
  882.             // append accelerators to menu item name
  883.             if (m_pAccel && m_bAutoAccel)
  884.                 AppendAccelName(pmd->text, info.wID);
  885.         }
  886.    } 
  887.    else 
  888.    {
  889.         // no buttons -- I'm converting to strings
  890.         
  891.         if (info.fType & MFT_OWNERDRAW)  // if ownerdraw:
  892.         { 
  893.             info.fType &= ~MFT_OWNERDRAW;   //   turn it off
  894.             info.fMask |= MIIM_TYPE;        //   change item type
  895.             ASSERT(pmd);                    //   sanity check
  896.             sItemName = pmd->text;          //   save name before deleting pmd
  897.         } 
  898.         else                    // otherwise: 
  899.         {
  900.             sItemName = info.dwTypeData;    //   use name from MENUITEMINFO
  901.             pmd       = NULL;
  902.         }
  903.         
  904.         if (pmd) {
  905.             // NOTE: pmd (item data) could still be left hanging around even
  906.             // if MFT_OWNERDRAW is not set, in case mentioned above where app
  907.             // calls pCmdUI->SetText to set text of item and MFC sets the type
  908.             // to MFT_STRING.
  909.             //
  910.             info.dwItemData = (DWORD)pmd->pContext; // item data<-user's context
  911.             info.fMask |= MIIM_DATA;                // change it
  912.             safe_delete(pmd);                       // and item data too
  913.         }
  914.         
  915.         // possibly add accelerator name
  916.         if (m_pAccel  && m_bAutoAccel && AppendAccelName(sItemName, info.wID))
  917.             info.fMask |= MIIM_TYPE;      //  change item type (string)
  918.         
  919.         if (info.fMask & MIIM_TYPE) {
  920.             // if setting name, copy name from CString to buffer and set cch
  921.             _tcsncpy(itemname, sItemName, sizeof(itemname));
  922.             info.dwTypeData = itemname;
  923.             info.cch = sItemName.GetLength();
  924.         }
  925.     }
  926.     
  927.     // if after all the above, there is anything to change, change it
  928.     if (info.fMask) {
  929.         CMTRACE(_T("Converting '%s' to %sn"), itemname,
  930.             (info.fType & MFT_OWNERDRAW) ? _T("OWNERDRAW") : _T("STRING"));
  931.         SetMenuItemInfo(*pMenu, iIndex, TRUE, &info);
  932.     }
  933. }
  935. ///////////////////////
  936. // Addition: Philip Oldaker
  937. DWORD CCoolMenuManager::SwitchContextItemData(CMenu *pMenu, int iCmd, DWORD dwItemData /*0*/, BOOL bByPosition /*TRUE*/)
  938. {
  939. CMyItemData* pmd = GetMyItemData(*pMenu,iCmd,bByPosition);
  940. DWORD dwData=0;
  941. if (pmd == NULL)
  942. return dwData;
  943. CMenuItemInfo info;
  944.     info.fMask |= MIIM_DATA;                // change it
  945. if (pmd->IsMyItemData())
  946. {
  947. dwData= (DWORD)pmd;
  948.         info.dwItemData = (DWORD)pmd->pContext;
  949.         SetMenuItemInfo(*pMenu, iCmd, bByPosition, &info);
  950. }
  951. else if (dwItemData)
  952. {
  953. CMyItemData *pMyItemData = (CMyItemData*)dwItemData;
  954. if (pMyItemData->IsMyItemData())
  955. {
  956.         info.dwItemData = dwItemData;
  957.     SetMenuItemInfo(*pMenu, iCmd, bByPosition, &info);
  958. }
  959. }
  960. return dwData;
  961. }
  962. // This may not be the best way of doing it but it seems to work
  963. // Just save the IContextMenu2 pointer on behalf of the windows shell
  964. // and create new item data
  965. void CCoolMenuManager::AddShellContextMenu(CMenu *pMenu, LPCONTEXTMENU lpm, int iIndex)
  966. {
  967. CMyItemData* pmd = GetMyItemData(*pMenu,iIndex,TRUE);
  968. if (pmd == NULL || !pmd->IsMyItemData())
  969. {
  970. DWORD dw = (DWORD)pmd;
  971. pmd = new CMyItemData;
  972. pmd->pContext = (void*)dw;
  973. }
  974. pmd->lpcm = lpm;
  975. pmd->lpcm->AddRef();
  976.     SetMyItemData(pmd,*pMenu,iIndex,TRUE);
  977. }
  979. ///////////////////////////////
  981. //////////////////
  982. // This rather gnarly function is used both to convert the menu from strings to
  983. // owner-draw and vice versa. In either case, it also appends automagic
  984. // accelerator key names to the menu items, if m_bAutoAccel is TRUE.
  985. //
  986. void CCoolMenuManager::ConvertMenu(CMenu* pMenu, UINT nIndex, 
  987.                                    BOOL bSysMenu, BOOL bShowButtons)
  988. {
  989.     ASSERT_VALID(pMenu);
  990.     
  991.     UINT i, nItem;
  993.     // add/remove the menu to/from list of "converted" menus
  994.     HMENU hmenu = pMenu->GetSafeHmenu();
  995.     ASSERT(hmenu);
  996.     POSITION p = m_menuList.Find(hmenu);
  997.     if (!p)
  998.     {
  999.         if (bShowButtons)
  1000.             m_menuList.AddHead(hmenu);
  1001.     }
  1002.     else
  1003.     {
  1004.         if (!bShowButtons)
  1005.             m_menuList.RemoveAt(p);
  1006.     }
  1007.     
  1008.     nItem = pMenu->GetMenuItemCount();    
  1010.     for (i = 0; i < nItem; i++) 
  1011.     {  
  1012.         // loop over each item in menu
  1013.         ConvertMenuItem(pMenu, i, true, !bShowButtons);
  1014.     }
  1015. }
  1017. void *CCoolMenuManager::SetItemData(HMENU hMenu, void *pData, UINT uItem, BOOL bByPosition /*= FALSE*/)
  1018. {
  1019.     CMyItemData *pmd = GetMyItemData(hMenu, uItem, bByPosition);
  1020.     ASSERT(pmd->IsMyItemData());
  1021.     void *pOld = pmd->pContext;
  1022.     pmd->pContext = pData;
  1023.     SetMyItemData(pmd, hMenu, uItem, bByPosition);
  1024.     return pOld;
  1025. }
  1027. void *CCoolMenuManager::GetItemData(HMENU hMenu, UINT uItem, BOOL bByPosition /*= FALSE*/)
  1028. {
  1029.     MENUITEMINFO mii;
  1030.     mii.cbSize     = sizeof(mii);
  1031.     mii.fMask      = MIIM_DATA | MIIM_TYPE;
  1032.     mii.dwTypeData = NULL;
  1033.     mii.cch        = 0;
  1034.     if (!::GetMenuItemInfo(hMenu, uItem, bByPosition, &mii))
  1035.         return NULL;
  1036. if (mii.dwItemData == -1) _asm int 3;    
  1037.     CMyItemData *pmd = (CMyItemData *)mii.dwItemData;
  1038.     if ((mii.fType & MFT_OWNERDRAW)  &&  pmd  &&  pmd->IsMyItemData())
  1039.         return pmd->pContext;
  1041.     return pmd;
  1042. }
  1044. HICON CCoolMenuManager::SetItemIcon(HMENU hMenu, HICON hIcon, UINT uItem, BOOL bByPosition /*= FALSE*/)
  1045. {
  1046.     CMyItemData *pmd = GetMyItemData(hMenu, uItem, bByPosition);
  1047.     ASSERT(pmd->IsMyItemData());
  1048.     HICON hOldIcon = pmd->hIcon;
  1049.     pmd->hIcon = hIcon;
  1050.     if (hIcon)
  1051.         pmd->iButton = USES_ICON;
  1052.     else
  1053.         pmd->iButton = -1;
  1054.     SetMyItemData(pmd, hMenu, uItem, bByPosition);
  1055.     return hOldIcon;
  1056. }
  1058. HICON CCoolMenuManager::GetItemIcon(HMENU hMenu, UINT uItem, BOOL bByPosition /*= FALSE*/)
  1059. {
  1060.     CMyItemData *pmd = GetMyItemData(hMenu, uItem, bByPosition);
  1061.     ASSERT(pmd->IsMyItemData());
  1062.     return pmd->hIcon;
  1063. }
  1065. void CCoolMenuManager::SetSubMenuIcon(HMENU hSubMenu, int nID)
  1066. {
  1067.     m_mapHMENUtoID[(void *)hSubMenu] = nID;
  1068. }
  1070. void CCoolMenuManager::UnmanageSubMenu(HMENU hSubMenu)
  1071. {
  1072.     m_mapHMENUtoID.RemoveKey((void *)hSubMenu);
  1073. }
  1076. //////////////////
  1077. // User typed a char into menu. Look for item with & preceeding the char typed.
  1078. //
  1079. LRESULT CCoolMenuManager::OnMenuChar(UINT nChar, UINT nFlags, CMenu* pMenu)
  1080. {
  1081. ASSERT_VALID(pMenu);
  1082. CMyItemData* pmd = GetMyItemData(*pMenu,0,TRUE);
  1083. // Addition: Philip Oldaker
  1084. // Pass it on to the shell if this has been set
  1085. if (pmd->IsMyItemData() && pmd->lpcm)
  1086. {
  1087. LRESULT lResult=0;
  1088. LPCONTEXTMENU3 lpcm3=NULL;
  1089. HRESULT hr = pmd->lpcm->QueryInterface(IID_IContextMenu3,(LPVOID*)&lpcm3);
  1090. if (SUCCEEDED(hr))
  1091. {
  1092. // convert menu back to original item data
  1093. UINT nCount = pMenu->GetMenuItemCount();
  1094. DWORD *pArrItemData = new DWORD[nCount];
  1095. for(UINT i1=0;i1 < nCount;i1++)
  1096. pArrItemData[i1] = SwitchContextItemData(pMenu,i1);
  1097. lpcm3->HandleMenuMsg2(WM_MENUCHAR,MAKELPARAM(nChar,nFlags),(LPARAM)pMenu->GetSafeHmenu(),&lResult);
  1098. lpcm3->Release();
  1099. // Convert menu back to back our item data
  1100. for(UINT i2=0;i2 < nCount;i2++)
  1101. SwitchContextItemData(pMenu,i2,pArrItemData[i2]);
  1102. delete []pArrItemData;
  1103. }
  1104. return lResult;
  1105. }
  1106. ////////////////////////////////
  1108.   UINT iCurrentItem = (UINT)-1; // guaranteed higher than any command ID
  1109.   CUIntArray arItemsMatched;    // items that match the character typed
  1111.   UINT nItem = pMenu->GetMenuItemCount();
  1112.   for (UINT i=0; i< nItem; i++) {
  1113.     // get menu info
  1114.     CMenuItemInfo info;
  1115.     info.fMask = MIIM_DATA | MIIM_TYPE | MIIM_STATE;
  1116.     ::GetMenuItemInfo(*pMenu, i, TRUE, &info);
  1118.     CMyItemData* pmd = (CMyItemData*)info.dwItemData;
  1119.     if ((info.fType & MFT_OWNERDRAW) && pmd && pmd->IsMyItemData()) {
  1120.       CString& text = pmd->text;
  1121.       int iAmpersand = text.Find(_T('&'));
  1122.       if (iAmpersand >=0 && toupper(nChar)==toupper(text[iAmpersand+1]))
  1123.         arItemsMatched.Add(i);
  1124.     }
  1125.     if (info.fState & MFS_HILITE)
  1126.       iCurrentItem = i; // note index of current item
  1127.   }
  1129.   // arItemsMatched now contains indexes of items that match the char typed.
  1130.   //
  1131.   //   * if none: beep
  1132.   //   * if one:  execute it
  1133.   //   * if more than one: hilite next
  1134.   //
  1135.   UINT nFound = arItemsMatched.GetSize();
  1136.   if (nFound == 0)
  1137.     return 0;
  1139.   else if (nFound==1)
  1140.     return MAKELONG(arItemsMatched[0], MNC_EXECUTE);
  1142.   // more than one found--return 1st one past current selected item;
  1143.   UINT iSelect = 0;
  1144.   for (i=0; i < nFound; i++) {
  1145.     if (arItemsMatched[i] > iCurrentItem) {
  1146.       iSelect = i;
  1147.       break;
  1148.     }
  1149.   }
  1150.   return MAKELONG(arItemsMatched[iSelect], MNC_SELECT);
  1151. }
  1153. //////////////////
  1154. // Handle WM_MENUSELECT: check for menu closed
  1155. //
  1156. void CCoolMenuManager::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu)
  1157. {
  1158. if (m_lpcm)
  1159. {
  1160. char szHelpText[MAX_PATH];
  1161. ZeroMemory(szHelpText,sizeof(szHelpText));
  1162. if ((nFlags & MF_SYSMENU) != MF_SYSMENU && (nFlags & MF_POPUP) != MF_POPUP)
  1163. {
  1164. if (nItemID >= m_idShellMenuFirst && nItemID <= m_idShellMenuLast)
  1165. {
  1166. m_lpcm->GetCommandString(nItemID-m_idShellMenuFirst,GCS_HELPTEXT,NULL,szHelpText,sizeof(szHelpText));
  1167. }
  1168. }
  1169. CWnd *pWnd=m_pFrame;
  1170. if (pWnd == NULL)
  1171. pWnd = AfxGetMainWnd();
  1172. if (pWnd)
  1173. pWnd->SendMessage(WM_SETMESSAGESTRING,0,(LPARAM)szHelpText);
  1174. }
  1175. if (hSysMenu==NULL && nFlags==0xFFFF) 
  1176. {
  1177. if (m_lpcm)
  1178. {
  1179. TRACE0("Setting lpcm to nulln");
  1180. m_lpcm = NULL;
  1181. }
  1182. /*
  1183. //  de-comment this code for self destructing menus.s
  1184. // Windows has closed the menu: restore all menus to original state
  1185. while (!m_menuList.IsEmpty()) 
  1186. {
  1187.   ConvertMenu(CMenu::FromHandle((HMENU)m_menuList.RemoveHead()),
  1188. 0, FALSE, FALSE);
  1189. }
  1190. */
  1191. }
  1192. }
  1194. // fix for virtual key names - Seain Conover (1999/01/09) 
  1196. CString CCoolMenuManager::GetVirtualKeyName( const CString strVirtKey ) const
  1197. {
  1198.   CString strResult;
  1199.   
  1200.   if    ( strVirtKey == _T("Num 7"))    { strResult = _T("Home"); }
  1201.   else if ( strVirtKey == _T("Num 1"))    { strResult = _T("End");  }
  1202.   else if ( strVirtKey == _T("Num 9"))    { strResult = _T("PgUp"); }
  1203.   else if ( strVirtKey == _T("Num 3"))    { strResult = _T("PgDn"); }
  1204.   else if ( strVirtKey == _T("Num 0"))    { strResult = _T("Ins");  }
  1205.   else if ( strVirtKey == _T("Num Del"))    { strResult = _T("Del");  }
  1206.   else
  1207.   {
  1208.     strResult = strVirtKey;
  1209.   }
  1210.   
  1211.   return strResult;
  1212. }
  1214. //////////////////
  1215. // Append the name of accelerator for given command ID to menu string.
  1216. // sItemName is menu item name, which will have the accelerator appended.
  1217. // For example, might call with sItemName = "File &Open" and return with
  1218. // sItemName = "File &OpentCtrl-O". Returns BOOL = whether string changed.
  1219. //
  1220. BOOL CCoolMenuManager::AppendAccelName(CString& sItemName, UINT nID)
  1221. {
  1222.   int iTabPos = sItemName.Find(_T('t'));
  1223.   if (iTabPos > 0)
  1224.     sItemName = sItemName.Left(iTabPos);
  1226.   BOOL bFound = FALSE;
  1227.   for (ACCEL* pa = GetAccel(nID); pa; pa -= pa->cmd) {
  1228.     sItemName += bFound ? _T(", ") : _T("t");
  1229.     if (pa->fVirt & FALT)     sItemName += _T("Alt+");
  1230.     if (pa->fVirt & FCONTROL)   sItemName += _T("Ctrl+");
  1231.     if (pa->fVirt & FSHIFT)     sItemName += _T("Shift+");
  1232.     if (pa->fVirt & FVIRTKEY) {
  1233.       TCHAR keyname[64];
  1234.       UINT vkey = MapVirtualKey(pa->key, 0)<<16;
  1235.       GetKeyNameText(vkey, keyname, sizeof(keyname));
  1236.       // Seain Conover (1999/01/09) 
  1237.       sItemName += GetVirtualKeyName( keyname );
  1238.     } else
  1239.       sItemName += (char)pa->key;
  1241.     bFound = TRUE;
  1242.     if (pa->cmd == 0)
  1243.       break;
  1244.   }
  1245.   return bFound;
  1246. }
  1248. //////////////////
  1249. // This function fixes MFC's diseased dot bitmap used for
  1250. // "radio-style" menu items (CCmdUI->SetRadio), which is completely
  1251. // wrong if the menu font is large. 
  1252. //
  1253. void CCoolMenuManager::FixMFCDotBitmap()
  1254. {
  1255.   HBITMAP hbmDot = GetMFCDotBitmap();
  1256.   if (hbmDot) {
  1257.     // Draw a centered dot of appropriate size
  1258.     BITMAP bm;
  1259.     ::GetObject(hbmDot, sizeof(bm), &bm);
  1260.     CRect rcDot(0,0, bm.bmWidth, bm.bmHeight);
  1261.     rcDot.DeflateRect((bm.bmWidth>>1)-2, (bm.bmHeight>>1)-2);
  1263.     CWindowDC dcScreen(NULL);
  1264.     CDC memdc;
  1265.     memdc.CreateCompatibleDC(&dcScreen);
  1266.     int nSave = memdc.SaveDC();
  1267.     memdc.SelectStockObject(BLACK_PEN);
  1268.     memdc.SelectStockObject(BLACK_BRUSH);
  1269.     memdc.SelectObject((HGDIOBJ)hbmDot);
  1270.     memdc.PatBlt(0, 0, bm.bmWidth, bm.bmHeight, WHITENESS);
  1271.     memdc.Ellipse(&rcDot);
  1272.     memdc.RestoreDC(nSave);
  1273.   }
  1274. }
  1276. //////////////////
  1277. // This function gets MFC's dot bitmap.
  1278. //
  1279. HBITMAP CCoolMenuManager::GetMFCDotBitmap()
  1280. {
  1281.   // The bitmap is stored in afxData.hbmMenuDot, but afxData is MFC-private,
  1282.   // so the only way to get it is create a menu, set the radio check,
  1283.   // and then see what bitmap MFC set in the menu item.
  1284.   CMenu menu;
  1285.   VERIFY(menu.CreateMenu());
  1286.   VERIFY(menu.AppendMenu(MFT_STRING, 0, (LPCTSTR)NULL));
  1287.   CCmdUI cui;
  1288.   cui.m_pMenu = &menu;
  1289.   cui.m_nIndex = 0;
  1290.   cui.m_nIndexMax = 1;
  1291.   cui.SetRadio(TRUE);
  1292.   CMenuItemInfo info;
  1293.   info.fMask = MIIM_CHECKMARKS;
  1294.   GetMenuItemInfo(menu, 0, MF_BYPOSITION, &info);
  1295.   HBITMAP hbmDot = info.hbmpChecked;
  1296.   menu.DestroyMenu();
  1297.   return hbmDot;
  1298. }
  1300. // Peter Tewkesbury
  1301. BOOL CCoolMenuManager::AddSingleBitmap(UINT nBitmapID, UINT n, UINT *nID)
  1302. {
  1303.   // load bitmap
  1304.   HBITMAP hbmBitmap = (HBITMAP)::LoadImage(AfxGetInstanceHandle(),
  1305.     MAKEINTRESOURCE(nBitmapID), IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
  1306.   ASSERT(hbmBitmap);
  1308.   if (!hbmBitmap) {
  1309.     TRACE(_T("*** Can't load bitmap %d!n"), nBitmapID);
  1310.     return FALSE;
  1311.   }
  1313.   // Assign Bitmap to CBitmap
  1314.   CBitmap bmBitmap;
  1315.   bmBitmap.Attach(hbmBitmap); // destructor will detach & destroy
  1316.   
  1317.   // OK, I have the bitmap - Check that Bitmaps are correct size.
  1318.   if (m_szBitmap.cx==0) 
  1319.   {
  1320.     // First toolbar: initialized bitmap/button sizes and create image list.
  1321.     CSize sz(16,15);
  1322.     m_szBitmap = sz;
  1323.     m_szButton = sz + CSize(CXBUTTONMARGIN<<1, CYBUTTONMARGIN<<1);
  1324.     VERIFY(m_ilButtons.Create(sz.cx, sz.cy, ILC_MASK, 0, 10));
  1325.     
  1326.   } 
  1327.   
  1328.   // Add Bitmap to ImageList
  1329.   int iNextImage = m_ilButtons.GetImageCount();
  1330.   m_ilButtons.Add(&bmBitmap, GetSysColor(COLOR_3DFACE)); 
  1331.   
  1332.   // Add ID to Map.
  1333.   for(UINT i=0;i<n;i++)
  1334.   {
  1335.     if (nID[i] > 0) 
  1336.     {
  1337.       if (GetButtonIndex(nID[i]) >= 0) 
  1338.       {
  1339.         TRACE(_T("*** Duplicate button ID %d ignoredn"), nID[i]);
  1340.       } 
  1341.       else m_mapIDtoImage.SetAt(nID[i], (void*)iNextImage++); 
  1342.     }
  1343.   }
  1344.   
  1345.   // All Done.
  1346.   return TRUE;
  1347. }
  1349. ////////////////////////////////////////////////////////////////
  1350. // Helper functions
  1352. //////////////////
  1353. // Load a bitmap, converting the standard colors.
  1354. // Calls AfxLoadSysColorBitmap to do the work.
  1355. //
  1356. // RGB(0x00, 0x00, 0x00) (black)      --> COLOR_BTNTEXT
  1357. // RGB(0x80, 0x80, 0x80) (dark gray)  --> COLOR_3DSHADOW
  1358. // RGB(0xC0, 0xC0, 0xC0) (gray)       --> COLOR_3DFACE
  1359. // RGB(0xFF, 0xFF, 0xFF) (white)      --> COLOR_3DHILIGHT
  1360. // 
  1361. HBITMAP PLLoadSysColorBitmap(LPCTSTR lpResName, BOOL bMono)
  1362. {
  1363.   HINSTANCE hInst = AfxFindResourceHandle(lpResName, RT_BITMAP);
  1364.   HRSRC hRsrc = ::FindResource(hInst, lpResName, RT_BITMAP);
  1365.   if (hRsrc == NULL)
  1366.     return NULL;
  1367.   return AfxLoadSysColorBitmap(hInst, hRsrc, bMono);
  1368. }
  1370. //////////////////
  1371. // Shorthand to fill a rectangle with a solid color.
  1372. //
  1373. void PLFillRect(CDC& dc, const CRect& rc, COLORREF color)
  1374. {
  1375.   CBrush brush(color);
  1376.   CBrush* pOldBrush = dc.SelectObject(&brush);
  1377.   dc.PatBlt(rc.left, rc.top, rc.Width(), rc.Height(), PATCOPY);
  1378.   dc.SelectObject(pOldBrush);
  1379. }
  1381. // This is the magic ROP code used to generate the embossed look for
  1382. // a disabled button. It's listed in Appendix F of the Win32 Programmer's
  1383. // Reference as PSDPxax (!) which is a cryptic reverse-polish notation for
  1384. //
  1385. // ((Destination XOR Pattern) AND Source) XOR Pattern
  1386. //
  1387. // which I leave to you to figure out. In the case where I apply it,
  1388. // Source is a monochrome bitmap which I want to draw in such a way that
  1389. // the black pixels get transformed to the brush color and the white pixels
  1390. // draw transparently--i.e. leave the Destination alone.
  1391. //
  1392. // black ==> Pattern (brush)
  1393. // white ==> Destintation (ie, transparent)
  1394. //
  1395. // 0xb8074a is the ROP code that does this. For more info, see Charles
  1396. // Petzold, _Programming Windows_, 2nd Edition, p 622-624.
  1397. //
  1398. #define TRANSPARENTROP 0xb8074a
  1400. //////////////////
  1401. // Draw an image with the embossed (disabled) look.
  1402. //
  1403. //    dc      device context to draw in
  1404. //    il      image list containing image
  1405. //    i     index of image to draw
  1406. //    p     point in dc to draw image at
  1407. //    bColor  do color embossing. Default is B/W.
  1408. //
  1409. void PLDrawEmbossedOld(CDC& dc, CImageList& il, int i, CPoint p, BOOL bColor)
  1410. {
  1411.   IMAGEINFO info;
  1412.   VERIFY(il.GetImageInfo(0, &info));
  1413.   CRect rc = info.rcImage;
  1414.   int cx = rc.Width();
  1415.   int cy = rc.Height();
  1417.   // create memory dc
  1418.   CDC memdc;
  1419.   memdc.CreateCompatibleDC(&dc);
  1421.   // create mono or color bitmap
  1422.   CBitmap bm;
  1423.   if (bColor)
  1424.     bm.CreateCompatibleBitmap(&dc, cx, cy);
  1425.   else
  1426.     bm.CreateBitmap(cx, cy, 1, 1, NULL);
  1428.   // draw image into memory DC--fill BG white first
  1429.   CBitmap* pOldBitmap = memdc.SelectObject(&bm);
  1430.   memdc.PatBlt(0, 0, cx, cy, WHITENESS);
  1431.   il.Draw(&memdc, i, CPoint(0,0), ILD_TRANSPARENT);
  1433.   // This seems to be required. Why, I don't know. ???
  1434.   COLORREF colorOldBG = dc.SetBkColor(RGB(255,255,255)); // white
  1436.   // Draw using hilite offset by (1,1), then shadow
  1437.   CBrush brShadow(GetSysColor(COLOR_3DSHADOW));
  1438.   CBrush brHilite(GetSysColor(COLOR_3DHIGHLIGHT));
  1439.   CBrush* pOldBrush = dc.SelectObject(&brHilite);
  1440.   dc.BitBlt(p.x+1, p.y+1, cx, cy, &memdc, 0, 0, TRANSPARENTROP);
  1441.   dc.SelectObject(&brShadow);
  1442.   dc.BitBlt(p.x, p.y, cx, cy, &memdc, 0, 0, TRANSPARENTROP);
  1443.   dc.SelectObject(pOldBrush);
  1444.   dc.SetBkColor(colorOldBG);         // restore
  1445.   memdc.SelectObject(pOldBitmap);    // ...
  1446. }
  1448. #define NEWROP  0x00E20746L
  1450. void PLDrawEmbossed(CDC& dc, CImageList& il, int i, CPoint p, BOOL bColor)
  1451. {
  1452.     IMAGEINFO info;
  1453.     VERIFY(il.GetImageInfo(0, &info));
  1454.     CRect rc = info.rcImage;
  1455.     int cx = rc.Width();
  1456.     int cy = rc.Height();
  1457.     CBitmap patbmp, bmp;
  1458. CDC memdc, patdc;
  1459. patdc.CreateCompatibleDC(0);
  1460. memdc.CreateCompatibleDC(0);
  1461. patbmp.CreateCompatibleBitmap(&patdc, cx, cy);
  1462. bmp.CreateCompatibleBitmap(&dc, cx, cy);
  1463. CBitmap * pddcOldBmp = patdc.SelectObject(&patbmp);
  1464.     CBitmap * pdcOldBmp  = memdc.SelectObject(&bmp);
  1466.     il.Draw(&memdc, i, CPoint(0, 0), ILD_NORMAL); //ILD_TRANSPARENT);
  1468. // build a mask
  1469. patdc.PatBlt(0, 0, cx, cy, WHITENESS);
  1470. memdc.SetBkColor(GetSysColor(COLOR_BTNFACE));
  1471. patdc.BitBlt(0, 0, cx, cy, &memdc, 0, 0, SRCCOPY);
  1472. memdc.SetBkColor(GetSysColor(COLOR_BTNHILIGHT));
  1473. patdc.BitBlt(0, 0, cx, cy, &memdc, 0, 0, SRCPAINT);
  1475. memdc.SetBkColor(RGB(0, 0, 0));
  1476. memdc.SetTextColor(RGB(255, 255, 255));
  1477. CBrush brShadow, brHilight;
  1478. brHilight.CreateSolidBrush(GetSysColor(COLOR_BTNHILIGHT));
  1479. brShadow.CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
  1480. CBrush * pOldBrush = memdc.SelectObject(&brHilight);
  1481. memdc.BitBlt(1, 1, cx, cy, &patdc, 0, 0, NEWROP);
  1482. memdc.BitBlt(0, 0, cx, cy, &patdc, 0, 0, NEWROP);
  1483. memdc.SelectObject(&brShadow);
  1484. memdc.BitBlt(0, 0, cx, cy, &patdc, 0, 0, NEWROP);
  1485. dc.BitBlt(p.x, p.y, cx, cy, &memdc, 0, 0, SRCCOPY);
  1487.     // reset DCs
  1488. patdc.SelectObject(pddcOldBmp);
  1489. patdc.DeleteDC();
  1490. memdc.SelectObject(pOldBrush);
  1491. memdc.SelectObject(pdcOldBmp);
  1492. memdc.DeleteDC();
  1494. brShadow.DeleteObject();
  1495. brHilight.DeleteObject();
  1496. patbmp.DeleteObject();
  1497. }