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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
RTMenu.cpp
资源名称：20060417006-9709.rar　[点击查看]
上传用户：qhonly
上传日期：2013-06-10
资源大小：487k
文件大小：41k
源码类别：

界面编程

开发平台：

Visual C++

RTMenu.cpp：源码内容
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //
  3. // MenuXP.cpp : implementation file
  4. //
  5. ///////////////////////////////////////////////////////////////////////////////
  7. #include "stdafx.h"
  8. #include "RTMenu.h"
  9. #include "RTTools.h"
  10. #include "RTDraw.h"
  12. #ifdef _DEBUG
  13. #define new DEBUG_NEW
  14. #undef THIS_FILE
  15. static char THIS_FILE[] = __FILE__;
  16. #endif
  18. #ifndef DWORD_PTR
  19.     typedef ULONG DWORD_PTR;
  20.     typedef long LONG_PTR;
  21. #endif
  23. #ifndef ODS_HOTLIGHT
  24.     #define ODS_HOTLIGHT 0x0040
  25. #endif
  26. #ifndef ODS_INACTIVE
  27.     #define ODS_INACTIVE 0x0080
  28. #endif
  30. #ifndef ODS_NOACCEL
  31.     #define ODS_NOACCEL 0x0100
  32. #endif
  34. #ifndef DT_HIDEPREFIX
  35.     #define DT_HIDEPREFIX 0x00100000
  36. #endif
  38. #ifndef SPI_GETKEYBOARDCUES
  39.     #define SPI_GETKEYBOARDCUES 0x100A
  40. #endif
  42. // From <winuser.h>
  43. #ifndef OBM_CHECK
  44.     #define OBM_CHECK 32760
  45. #endif
  47. #define IMGWIDTH 16
  48. #define IMGHEIGHT 16
  49. #define IMGPADDING 6
  50. #define TEXTPADDING 8
  51. #define TEXTPADDING_MNUBR 4
  52. #define SM_CXSHADOW 4
  54. const TCHAR _WndPropName_OldProc[] = _T("XPWndProp_OldProc");
  55. const TCHAR _WndPropName_MenuXP[] = _T("XPWndProp_MenuXP");
  57. ///////////////////////////////////////////////////////////////////////////////
  58. // Menu item management class
  59. //
  60. class CRTMenuItem
  61. {
  62. protected:
  63.     MENUITEMINFO m_miInfo;
  64.     CString      m_sCaption;
  65.     CImgDesc     m_ImgDesc;
  66.     HIMAGELIST   m_hImgList;
  67.     int          m_nIndex;
  69. public:
  70.     CRTMenuItem ();
  71.     CRTMenuItem (HMENU hMenu, UINT uItem, bool fByPosition = true);
  72.    ~CRTMenuItem ();
  74. // Properties
  75. public:
  76.     int   GetCaption   (CString& sCaption) const;
  77.     int   GetShortCut  (CString& sShortCut) const;
  78.     bool  GetSeparator () const;
  79.     bool  GetChecked   () const;
  80.     bool  GetRadio     () const;
  81.     bool  GetDisabled  () const;
  82.     bool  GetDefault   () const;
  83.     HMENU GetPopup     () const;
  84.     UINT  GetID        () const;
  86. // Methods
  87. public:
  88.     int  GetCaptionWidth  (CDC* pDC) const;
  89.     int  GetShortCutWidth (CDC* pDC) const;
  90.     int  GetHeight        (CDC* pDC) const;
  91.     bool Draw             (CDC* pDC, LPCRECT pRect, bool bSelected, bool bMenuBar = false, bool bHotLight = false, bool bInactive = false, bool bNoAccel = false) const;
  92. public:
  93.     static BYTE ms_nCheck;
  94.     static CRect ms_rcMRUMenuBarItem;
  95. };
  98. ///////////////////////////////////////////////////////////////////////////////
  99. ///////////////////////////////////////////////////////////////////////////////
  100. BYTE CRTMenuItem::ms_nCheck = 0;
  101. CRect CRTMenuItem::ms_rcMRUMenuBarItem (0, 0, 0, 0);
  103. ///////////////////////////////////////////////////////////////////////////////
  104. CRTMenuItem::CRTMenuItem ()
  105. {
  106.     memset (&m_miInfo, 0, sizeof(MENUITEMINFO));
  107. }
  109. ///////////////////////////////////////////////////////////////////////////////
  110. CRTMenuItem::CRTMenuItem (HMENU hMenu, UINT uItem, bool fByPosition)
  111. {
  112.     memset (&m_miInfo, 0, sizeof(MENUITEMINFO));
  113.     m_miInfo.cbSize = sizeof(MENUITEMINFO);
  114.     m_miInfo.fMask = MIIM_STATE|MIIM_SUBMENU|MIIM_TYPE|MIIM_DATA|MIIM_ID;
  115.     VERIFY (::GetMenuItemInfo (hMenu, uItem, fByPosition, &m_miInfo));
  117.     if ( !(m_miInfo.fType & MFT_SEPARATOR) )
  118.     {
  119.         if ( m_miInfo.hSubMenu != NULL )
  120.         {
  121.             CRTMenu::ms_sSubMenuCaptions.Lookup (m_miInfo.hSubMenu, m_sCaption);
  122.             CRTMenu::ms_SubMenuImages.Lookup (m_miInfo.hSubMenu, m_ImgDesc);
  123.         }
  124.         else
  125.         {
  126.             CRTMenu::ms_sCaptions.Lookup (m_miInfo.wID, m_sCaption);
  127.             CRTMenu::ms_Images.Lookup (m_miInfo.wID, m_ImgDesc);
  128.         }
  129.     }
  130. }
  132. ///////////////////////////////////////////////////////////////////////////////
  133. CRTMenuItem::~CRTMenuItem ()
  134. {
  135. }
  137. ///////////////////////////////////////////////////////////////////////////////
  138. int CRTMenuItem::GetCaption (CString& sCaption) const
  139. {
  140.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  141.     sCaption = m_sCaption;
  143.     int nShortCutPos = sCaption.Find ('t');
  145.     if ( nShortCutPos == -1 )
  146.     {
  147.         return sCaption.GetLength();
  148.     }
  149.     sCaption = sCaption.Left (nShortCutPos);
  151.     return nShortCutPos-1;
  152. }
  153. ///////////////////////////////////////////////////////////////////////////////
  154. int CRTMenuItem::GetShortCut (CString& sShortCut) const
  155. {
  156.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  157.     CString sCaption = m_sCaption;
  159.     int nShortCutPos = sCaption.Find ('t');
  161.     if ( nShortCutPos == -1 )
  162.     {
  163.         sShortCut = "";
  164.         return 0;
  165.     }
  166.     int nLength = sCaption.GetLength()-nShortCutPos-1;
  168.     sShortCut = sCaption.Right (nLength);
  170.     return nLength;
  171. }
  173. ///////////////////////////////////////////////////////////////////////////////
  174. bool CRTMenuItem::GetSeparator () const
  175. {
  176.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  177.     return (m_miInfo.fType & MFT_SEPARATOR) == MFT_SEPARATOR;
  178. }
  180. ///////////////////////////////////////////////////////////////////////////////
  181. bool CRTMenuItem::GetChecked () const
  182. {
  183.     ASSERT(m_miInfo.fMask & MIIM_STATE);
  184.     return (m_miInfo.fState & MFS_CHECKED) == MFS_CHECKED;
  185. }
  187. ///////////////////////////////////////////////////////////////////////////////
  188. bool CRTMenuItem::GetRadio () const
  189. {
  190.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  191.     return (m_miInfo.fType & MFT_RADIOCHECK) == MFT_RADIOCHECK;
  192. }
  194. ///////////////////////////////////////////////////////////////////////////////
  195. bool CRTMenuItem::GetDisabled () const
  196. {
  197.     ASSERT(m_miInfo.fMask & MIIM_STATE);
  198.     return (m_miInfo.fState & MFS_GRAYED) == MFS_GRAYED;
  199. }
  201. ///////////////////////////////////////////////////////////////////////////////
  202. bool CRTMenuItem::GetDefault () const
  203. {
  204.     ASSERT(m_miInfo.fMask & MIIM_STATE);
  205.     return (m_miInfo.fState & MFS_DEFAULT) == MFS_DEFAULT;
  206. }
  208. ///////////////////////////////////////////////////////////////////////////////
  209. HMENU CRTMenuItem::GetPopup () const
  210. {
  211.     ASSERT(m_miInfo.fMask & MIIM_SUBMENU);
  212.     return m_miInfo.hSubMenu;
  213. }
  215. ///////////////////////////////////////////////////////////////////////////////
  216. UINT CRTMenuItem::GetID () const
  217. {
  218.     ASSERT(m_miInfo.fMask & MIIM_ID);
  219.     return m_miInfo.wID;
  220. }
  222. ///////////////////////////////////////////////////////////////////////////////
  223. int CRTMenuItem::GetCaptionWidth (CDC* pDC) const
  224. {
  225.     if ( GetSeparator() )
  226.     {
  227.         return 0;
  228.     }
  229.     CString sCaption;
  230.     int nLength = 0;
  232.     if ( GetCaption (sCaption) > 0 )
  233.     {
  234.         int nPos = sCaption.Find ('&');
  235.         CBoldDC bold (*pDC, GetDefault());
  237.         if ( nPos >= 0 )
  238.         {
  239.             sCaption = sCaption.Left (nPos) + sCaption.Right (sCaption.GetLength()-nPos-1);
  240.         }
  241.         nLength = pDC->GetTextExtent (sCaption).cx;
  242.     }
  243.     return nLength;
  244. }
  246. ///////////////////////////////////////////////////////////////////////////////
  247. int CRTMenuItem::GetShortCutWidth (CDC* pDC) const
  248. {
  249.     if ( GetSeparator() )
  250.     {
  251.         return 0;
  252.     }
  253.     CString sShortCut;
  254.     int nLength = 0;
  256.     if ( GetShortCut (sShortCut) > 0 )
  257.     {
  258.         CBoldDC bold (*pDC, GetDefault());
  260.         nLength = pDC->GetTextExtent (sShortCut).cx;
  261.     }
  262.     return nLength;
  263. }
  265. ///////////////////////////////////////////////////////////////////////////////
  266. int CRTMenuItem::GetHeight (CDC* pDC) const
  267. {
  268.     TEXTMETRIC tm;
  270.     pDC->GetTextMetrics (&tm);
  271.                      
  272.     return GetSeparator() ? tm.tmHeight/2+2 : tm.tmHeight+4;
  273. }
  275. ///////////////////////////////////////////////////////////////////////////////
  276. bool CRTMenuItem::Draw (CDC* pDC, LPCRECT pRect, bool bSelected,bool bMenuBar, bool bHotLight, bool bInactive, bool bNoAccel) const
  277. {
  278.     COLORREF crBackImg = CLR_NONE;
  279.     bool bMenuBarItemSelected = false;
  281.     if ( bMenuBar && bSelected )
  282.     {
  283. if(CRTMenu::m_MenuBarBitmap[BMP_DOWN] != NULL && CRTMenu::m_bEnableSkin)
  284. {
  285. CRTDraw::RTDrawBitmap(pDC,pRect,CRTMenu::m_MenuBarBitmap[BMP_DOWN],CRTMenu::m_MenuBarBitmapDrawMode[BMP_DOWN]);
  286. }
  287. else
  288. {
  289. CRect rc (pRect);
  290. CPenDC pen (*pDC, ::GetSysColor (COLOR_3DDKSHADOW));
  291. CBrushDC brush (*pDC, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  293. rc.right -= TEXTPADDING_MNUBR;
  294. ms_rcMRUMenuBarItem = rc;
  295. bMenuBarItemSelected = true;
  296. pDC->Rectangle (rc);
  297. rc.left = rc.right;
  298. rc.right += TEXTPADDING_MNUBR;
  299. pDC->FillSolidRect (rc, ::GetSysColor (COLOR_3DFACE));
  301. for ( int x = 0; x < SM_CXSHADOW; x++ )
  302. {
  303. for ( int y = ( x < 2 ) ? 2-x : 0; y < rc.Height()-x-((x>0)?1:2); y++ )
  304. {
  305. int nMakeSpec = 78+(3-(y==0?0:(y==1?(x<2?0:1):(y==2?(x<2?x:2):x))))*5;
  306. COLORREF cr = pDC->GetPixel (rc.right-x-1, rc.top+y+SM_CXSHADOW);
  307. COLORREF cr2 = RGB(((nMakeSpec * int(GetRValue(cr))) / 100),
  308. ((nMakeSpec * int(GetGValue(cr))) / 100),
  309. ((nMakeSpec * int(GetBValue(cr))) / 100));
  310. pDC->SetPixel (rc.right-x-1, rc.top+y+SM_CXSHADOW, cr2);
  311. }
  312. }
  313. }
  314.     }
  315.     else if ( bSelected || (bHotLight && !bInactive) )
  316.     {
  317.         COLORREF crHighLight = ::GetSysColor (COLOR_HIGHLIGHT);
  318.         CPenDC pen (*pDC, crHighLight);
  319.         CBrushDC brush (*pDC, crBackImg = GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +73, 0) : HLS_TRANSFORM (crHighLight, +70, -57));
  321.         if ( bMenuBar )
  322.         {
  323. if(CRTMenu::m_MenuBarBitmap[BMP_FOCUS] != NULL && CRTMenu::m_bEnableSkin)
  324. {
  325. CRTDraw::RTDrawBitmap(pDC,pRect,CRTMenu::m_MenuBarBitmap[BMP_FOCUS],CRTMenu::m_MenuBarBitmapDrawMode[BMP_FOCUS]);
  326. }
  327. else
  328. {
  329. CRect rc (pRect);
  330. rc.right -= TEXTPADDING_MNUBR;
  331. pDC->Rectangle (rc);
  332. rc.left = rc.right;
  333. rc.right += TEXTPADDING_MNUBR;
  334. pDC->FillSolidRect (rc, ::GetSysColor (COLOR_3DFACE));
  335. }
  336.         }
  337.         else
  338.         {
  339. if(CRTMenu::m_MenuItemBitmap[BMP_FOCUS] != NULL && CRTMenu::m_bEnableSkin)
  340. {
  341. CRect rc (pRect);
  342. rc.right = IMGWIDTH+IMGPADDING;
  343. CRTDraw::RTDrawBitmap(pDC,&rc,CRTMenu::m_MenuItemBitmap[BMP_SLIDER],CRTMenu::m_MenuItemBitmapDrawMode[BMP_SLIDER]);
  344. rc.left = rc.right;
  345. rc.right = pRect->right;
  346. CRTDraw::RTDrawBitmap(pDC,&rc,CRTMenu::m_MenuItemBitmap[BMP_FOCUS],CRTMenu::m_MenuItemBitmapDrawMode[BMP_FOCUS]);
  347. }
  348. else
  349. {
  350.   pDC->Rectangle (pRect);
  351. }
  352.         }
  353.     }
  354.     else if ( !bMenuBar )
  355.     {
  356.         CRect rc (pRect);
  357. rc.right = IMGWIDTH+IMGPADDING;
  358. if(CRTMenu::m_MenuItemBitmap[BMP_SLIDER] != NULL && CRTMenu::m_bEnableSkin)
  359. {
  360. CRTDraw::RTDrawBitmap(pDC,&rc,CRTMenu::m_MenuItemBitmap[BMP_SLIDER],CRTMenu::m_MenuItemBitmapDrawMode[BMP_SLIDER]);
  361. }
  362. else
  363. {
  364. pDC->FillSolidRect (rc, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  365. }
  366. rc.left = rc.right;
  367. rc.right = pRect->right;
  368. if(CRTMenu::m_MenuItemBitmap[BMP_NORMAL] != NULL && CRTMenu::m_bEnableSkin)
  369. {
  370. CRTDraw::RTDrawBitmap(pDC,&rc,CRTMenu::m_MenuItemBitmap[BMP_NORMAL],CRTMenu::m_MenuItemBitmapDrawMode[BMP_NORMAL]);
  371. }
  372. else
  373. {
  374. pDC->FillSolidRect (rc, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +75, 0));
  375. }
  376.     }
  377.     else//MenuBar
  378.     {
  379. if(CRTMenu::m_MenuBarBitmap[BMP_NORMAL] != NULL && CRTMenu::m_bEnableSkin)
  380. {
  381. CRTDraw::RTDrawBitmap(pDC,pRect,CRTMenu::m_MenuBarBitmap[BMP_NORMAL],CRTMenu::m_MenuBarBitmapDrawMode[BMP_NORMAL]);
  382. }
  383. else
  384. {
  385. pDC->FillSolidRect (pRect, ::GetSysColor (COLOR_3DFACE));
  386. }
  387.     }
  388.     if ( GetSeparator() )
  389.     {
  390.         CPenDC pen (*pDC, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -18, 0));
  392.         pDC->MoveTo (pRect->left+IMGWIDTH+IMGPADDING+TEXTPADDING,  (pRect->top+pRect->bottom)/2);
  393.         pDC->LineTo (pRect->right-1, (pRect->top+pRect->bottom)/2);
  394.     }
  395.     else
  396.     {
  397.         CRect rc (pRect);
  398.         CString sCaption;
  400.         if ( GetCaption (sCaption) > 0 )
  401.         {
  402.             pDC->SetTextColor (bInactive ? ::GetSysColor (COLOR_3DSHADOW) : (GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -18, 0) : ::GetSysColor (COLOR_MENUTEXT)));
  403.             pDC->SetBkMode (TRANSPARENT);
  405.             BOOL bKeyboardCues = true;
  406.             ::SystemParametersInfo (SPI_GETKEYBOARDCUES, 0, &bKeyboardCues, 0);
  407.             DWORD dwHidePrefix = ( bNoAccel && !bKeyboardCues ) ? DT_HIDEPREFIX : 0;
  409.             if ( bMenuBar )
  410.             {
  411.                 rc.right -= TEXTPADDING_MNUBR;
  412.                 pDC->DrawText (sCaption, rc, DT_SINGLELINE|DT_VCENTER|DT_CENTER|dwHidePrefix);
  413.             }
  414.             else
  415.             {
  416.                 CBoldDC bold (*pDC, GetDefault());
  418.                 rc.left = IMGWIDTH+IMGPADDING+TEXTPADDING;
  419.                 pDC->DrawText (sCaption, rc, DT_SINGLELINE|DT_VCENTER|DT_LEFT|dwHidePrefix);
  421.                 CString sShortCut;
  423.                 if ( GetShortCut (sShortCut) > 0 )
  424.                 {
  425.                     rc.right -= TEXTPADDING+4;
  426.                     pDC->DrawText (sShortCut, rc, DT_SINGLELINE|DT_VCENTER|DT_RIGHT);
  427.                 }
  428.                 if ( GetChecked() )
  429.                 {
  430.                     COLORREF crHighLight = ::GetSysColor (COLOR_HIGHLIGHT);
  431.                     CPenDC pen (*pDC, crHighLight);
  432.                     CBrushDC brush (*pDC, crBackImg = GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +73, 0) :
  433.                                                                       (bSelected ? HLS_TRANSFORM (crHighLight, +50, -50) : HLS_TRANSFORM (crHighLight, +70, -57)));
  435.                     pDC->Rectangle (CRect (pRect->left+1, pRect->top+1, pRect->left+IMGWIDTH+4, pRect->bottom-1));
  436.                 }
  437.                 if ( m_ImgDesc.m_hImgList != NULL && m_ImgDesc.m_nIndex != -1 )
  438.                 {
  439.                     bool bOver = !GetDisabled() && bSelected;
  441.                     if ( GetDisabled() || (bSelected && !GetChecked()) )
  442.                     {
  443.                         HICON hIcon = ImageList_ExtractIcon (NULL, m_ImgDesc.m_hImgList, m_ImgDesc.m_nIndex);
  444.                         pDC->DrawState (CPoint (pRect->left + ( bOver ? 4 : 3 ), rc.top + ( bOver ? 4 : 3 )),
  445.                                         CSize (IMGWIDTH, IMGHEIGHT), hIcon, DSS_MONO,
  446.                                         CBrush (bOver ? HLS_TRANSFORM (::GetSysColor (COLOR_HIGHLIGHT), +50, -66) : HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -27, 0)));
  447.                         DestroyIcon (hIcon);
  448.                     }
  449.                     if ( !GetDisabled() )
  450.                     {
  451.                         ::ImageList_Draw (m_ImgDesc.m_hImgList, m_ImgDesc.m_nIndex, pDC->m_hDC,
  452.                                           pRect->left+( (bSelected && !GetChecked()) ? 2 : 3 ), rc.top+( (bSelected && !GetChecked()) ? 2 : 3 ), ILD_TRANSPARENT);
  453.                     }
  454.                 }
  455.                 else if ( GetChecked() )
  456.                 {
  457.                     // Draw the check mark
  458.                     rc.left  = pRect->left+IMGWIDTH/4+1;
  459.                     rc.right = rc.left + IMGWIDTH-1;
  461.                     if ( GetRadio() )
  462.                     {
  463.                         CPoint ptCenter = rc.CenterPoint();
  464.                         COLORREF crBullet = GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -27, 0) : ::GetSysColor (COLOR_MENUTEXT);
  465.                         CPenDC pen (*pDC, crBullet);
  466.                         CBrushDC brush (*pDC, crBullet);
  467.                         
  468.                         pDC->Ellipse (CRect (ptCenter.x-4, ptCenter.y-3, ptCenter.x+3, ptCenter.y+4));
  469.                         pDC->SetPixel (ptCenter.x+1, ptCenter.y+2, crBackImg);
  470.                     }
  471.                     else
  472.                     {
  473.                         pDC->SetBkColor (crBackImg);
  474.                         HBITMAP hBmp = LoadBitmap (NULL, MAKEINTRESOURCE(OBM_CHECK));
  475.                         pDC->DrawState (CPoint (rc.left,rc.top+3), CSize(rc.Size()), hBmp, DSS_NORMAL, (HBRUSH)NULL);
  476.                         DeleteObject (hBmp);
  477.                     }
  478.                 }
  479.             }
  480.         }
  481.     }
  482.     return bMenuBarItemSelected;
  483. }
  486. ///////////////////////////////////////////////////////////////////////////////
  487. ///////////////////////////////////////////////////////////////////////////////
  488. CMap <int, int, CString, CString&> CRTMenu::ms_sCaptions;
  489. CMap <HMENU, HMENU, CString, CString&> CRTMenu::ms_sSubMenuCaptions;
  490. CMap <int, int, CImgDesc, CImgDesc&> CRTMenu::ms_Images;
  491. CMap <HMENU, HMENU, CImgDesc, CImgDesc&> CRTMenu::ms_SubMenuImages;
  492. CBitmap* CRTMenu::m_MenuBarBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  493. UINT     CRTMenu::m_MenuBarBitmapDrawMode[5] = {0,0,0,0,0};
  494. CBitmap* CRTMenu::m_MenuItemBitmap[5] = {NULL,NULL,NULL,NULL,NULL};
  495. UINT     CRTMenu::m_MenuItemBitmapDrawMode[5] = {0,0,0,0,0};
  496. BOOL     CRTMenu::m_bEnableSkin = FALSE;
  498. ///////////////////////////////////////////////////////////////////////////////
  499. void CRTMenu::EnableSkin(BOOL IsEnable)
  500. {
  501. m_bEnableSkin = IsEnable;
  502. }
  504. void CRTMenu::SetXPLookNFeel (CWnd* pWnd, BOOL bXPLook)
  505. {
  506.     if ( bXPLook )
  507.     {
  508.         ::SetProp (pWnd->GetSafeHwnd(), _WndPropName_MenuXP, (HANDLE)TRUE);
  509.     }
  510.     else
  511.     {
  512.         ::RemoveProp (pWnd->GetSafeHwnd(), _WndPropName_MenuXP);
  513.     }
  514. }
  516. ///////////////////////////////////////////////////////////////////////////////
  517. bool CRTMenu::GetXPLookNFeel (const CWnd* pWnd)
  518. {
  519.     return ::GetProp (pWnd->GetSafeHwnd(), _WndPropName_MenuXP) != NULL;
  520. }
  522. ///////////////////////////////////////////////////////////////////////////////
  523. void CRTMenu::UpdateMenuBar (CWnd* pWnd)
  524. {
  525.     if ( GetXPLookNFeel (pWnd) )
  526.     {
  527.         HMENU hMenu = pWnd->GetMenu()->GetSafeHmenu();
  529.         if ( hMenu != NULL )
  530.         {
  531.             SetXPLookNFeel (pWnd, hMenu, true, true);
  532.         }
  533.     }
  534. }
  536. ///////////////////////////////////////////////////////////////////////////////
  537. void CRTMenu::SetXPLookNFeel (CWnd* pWnd, HMENU hMenu, BOOL bXPLook, BOOL bMenuBar)
  538. {
  539.     if ( !bXPLook )
  540.     {
  541.         // TODO: Remove the ownerdraw style ?
  542.         return;
  543.     }
  544. //    TRACE(_T("Referenced captions : %in"), ms_sCaptions.GetCount()+ms_sSubMenuCaptions.GetCount());
  545.     // Clean up old references...
  546.     // ... for captions
  547.     POSITION pos = ms_sSubMenuCaptions.GetStartPosition();
  549.     while ( pos != NULL )
  550.     {
  551.         HMENU hSubMenu;
  552.         CString sBuff;
  554.         ms_sSubMenuCaptions.GetNextAssoc (pos, hSubMenu, sBuff);
  556.         if ( !::IsMenu (hSubMenu) )
  557.         {
  558.             ms_sSubMenuCaptions.RemoveKey (hSubMenu);
  559.         }
  560.     }
  561.     // ... for images
  562.     pos = ms_SubMenuImages.GetStartPosition();
  564.     while ( pos != NULL )
  565.     {
  566.         HMENU hSubMenu;
  567.         CImgDesc ImgDesc;
  569.         ms_SubMenuImages.GetNextAssoc (pos, hSubMenu, ImgDesc);
  571.         if ( !::IsMenu (hSubMenu) )
  572.         {
  573.             ms_SubMenuImages.RemoveKey (hSubMenu);
  574.         }
  575.     }
  576.     ASSERT(hMenu != NULL);
  577.     int nItemCount = ::GetMenuItemCount (hMenu);
  578.     MENUITEMINFO mii = { sizeof MENUITEMINFO, MIIM_ID|MIIM_TYPE|MIIM_SUBMENU };
  579.     CClientDC cDC (AfxGetMainWnd());
  580.     TEXTMETRIC tm;
  581.     CFontDC font (cDC, DEFAULT_GUI_FONT);
  583.     cDC.GetTextMetrics (&tm);
  585.     int nHeight = max(tm.tmHeight+2,IMGHEIGHT)+4;
  586.     int nSepHeight = tm.tmHeight/2+2;
  587.     int nCaptionLength = 0;
  588.     int nShortCutLength = 0;
  589.     CPtrList* pListControlBars = NULL;
  591.     if ( pWnd != NULL && !bMenuBar )
  592.     {
  593.         if ( pWnd->IsKindOf (RUNTIME_CLASS(CMDIFrameWnd)) )
  594.         {
  595.             CMDIChildWnd* pActiveChild = ((CMDIFrameWnd*)pWnd)->MDIGetActive();
  597.             if ( pActiveChild != NULL && pActiveChild->GetSystemMenu (false)->GetSafeHmenu() == hMenu )
  598.             {
  599.                 CRTMenuItem::ms_rcMRUMenuBarItem.SetRectEmpty();
  600.                 return;
  601.             }
  602.         }
  603.         if ( pWnd->IsKindOf (RUNTIME_CLASS(CFrameWnd)) && !((CFrameWnd*)pWnd)->m_listControlBars.IsEmpty() )
  604.         {
  605.             pListControlBars = &((CFrameWnd*)pWnd)->m_listControlBars;
  606.         }
  607.         else
  608.         {
  609.             CFrameWnd* pFrame = pWnd->GetParentFrame();
  611.             if ( pFrame != NULL && pFrame->IsKindOf (RUNTIME_CLASS(CMDIChildWnd)) )
  612.             {
  613.                 pFrame = pFrame->GetParentFrame();
  614.             }
  615.             if ( pFrame != NULL )
  616.             {
  617.                 pListControlBars = &pFrame->m_listControlBars;
  618.             }
  619.         }
  620.     }
  621.     for ( int i = 0; i < nItemCount; i++ )
  622.     {
  623.         TCHAR sCaption[256] = _T("");
  624.         mii.dwTypeData = sCaption;
  625.         mii.cch = 255;
  626.         mii.fMask &= ~MIIM_DATA;
  627.         ::GetMenuItemInfo (hMenu, i, true, &mii);
  629.         if ( (mii.fType & MFT_OWNERDRAW) == 0 && (!bMenuBar || (mii.fType & MFT_BITMAP) == 0) )
  630.         {
  631.             mii.fType |= MFT_OWNERDRAW;
  633.             if ( bMenuBar )
  634.             {
  635.                 CRect rcText (0, 0, 1000, 0);
  637.                 cDC.DrawText (sCaption, (int)_tcslen (sCaption), rcText, DT_SINGLELINE|DT_LEFT|DT_CALCRECT);
  638.                 mii.dwItemData = MAKELONG(MAKEWORD(0, 0), rcText.Width());
  639.                 mii.fMask |= MIIM_DATA;
  640.             }
  641.             ::SetMenuItemInfo (hMenu, i, true, &mii);
  643.             if ( (mii.fType & MFT_SEPARATOR) == 0 )
  644.             {
  645.                 CString sBuff(sCaption);
  647.                 if ( mii.hSubMenu != NULL )
  648.                 {
  649.                     ms_sSubMenuCaptions.SetAt (mii.hSubMenu, sBuff);
  650.                 }
  651.                 else
  652.                 {
  653.                     ms_sCaptions.SetAt (mii.wID, sBuff);
  654.                 }
  655.                 if ( pListControlBars != NULL )
  656.                 {
  657.                     POSITION pos = pListControlBars->GetHeadPosition();
  659.                     while ( pos != NULL )
  660.                     {
  661.                         CControlBar* pBar = (CControlBar*)pListControlBars->GetNext (pos);
  662.                         ASSERT(pBar != NULL);
  663.                         TCHAR sClassName[256];
  665.                         ::GetClassName (pBar->m_hWnd, sClassName, lengthof (sClassName));
  667.                         if ( !_tcsicmp (sClassName, _T("ToolbarWindow32")) )
  668.                         {
  669.                             TBBUTTONINFO tbbi = { sizeof(TBBUTTONINFO), TBIF_COMMAND|TBIF_IMAGE };
  671.                             if ( pBar->SendMessage (TB_GETBUTTONINFO, mii.wID, (LPARAM)&tbbi) != -1 &&
  672.                                  (UINT)tbbi.idCommand == mii.wID && tbbi.iImage != -1 )
  673.                             {
  674.                                 CImgDesc imgDesc ((HIMAGELIST)pBar->SendMessage (TB_GETIMAGELIST, 0, 0), tbbi.iImage);
  676.                                 if ( mii.hSubMenu != NULL )
  677.                                 {
  678.                                     ms_SubMenuImages.SetAt (mii.hSubMenu, imgDesc);
  679.                                 }
  680.                                 else
  681.                                 {
  682.                                     ms_Images.SetAt (mii.wID, imgDesc);
  683.                                 }
  684.                                 break;
  685.                             }
  686.                         }
  687.                     }
  688.                 }
  689.             }
  690.         }
  691.         if ( !bMenuBar )
  692.         {
  693.             CRTMenuItem mnuItem (hMenu, i);
  694.             int       nWidth = mnuItem.GetCaptionWidth (&cDC);
  696.             if ( nWidth > nCaptionLength )
  697.             {
  698.                 nCaptionLength = nWidth;
  699.             }
  700.             nWidth = mnuItem.GetShortCutWidth (&cDC);
  702.             if ( nWidth > nShortCutLength )
  703.             {
  704.                 nShortCutLength = nWidth;
  705.             }
  706.         }
  707.     }
  708.     if ( !bMenuBar )
  709.     {
  710.         for ( int j = 0; j < nItemCount; j++ )
  711.         {
  712.             mii.fMask = MIIM_TYPE;
  713.             ::GetMenuItemInfo (hMenu, j, true, &mii);
  715.             if ( (mii.fType & MFT_SEPARATOR) == 0 )
  716.             {
  717.                 mii.dwItemData = MAKELONG(MAKEWORD(nHeight, nShortCutLength), nCaptionLength);
  718.             }
  719.             else
  720.             {
  721.                 mii.dwItemData = nSepHeight;
  722.             }
  723.             mii.fMask = MIIM_DATA;
  724.             ::SetMenuItemInfo (hMenu, j, true, &mii);
  725.         }
  726.     }
  727. }
  729. ///////////////////////////////////////////////////////////////////////////////
  730. bool CRTMenu::IsOwnerDrawn (HMENU hMenu)
  731. {
  732.     MENUITEMINFO mii = { sizeof MENUITEMINFO, MIIM_TYPE };
  734.     ::GetMenuItemInfo (hMenu, 0, true, &mii);
  736.     return (mii.fType & MFT_OWNERDRAW) != 0;
  737. }
  739. ///////////////////////////////////////////////////////////////////////////////
  740. void CRTMenu::SetMRUMenuBarItem (RECT& rc)
  741. {
  742.     CRTMenuItem::ms_rcMRUMenuBarItem = rc;
  743. }
  745. ///////////////////////////////////////////////////////////////////////////////
  746. void CRTMenu::SetMenuItemImage (UINT nID, HIMAGELIST hImgList, int nIndex)
  747. {
  748.     CImgDesc imgDesc (hImgList, nIndex);
  749.     ms_Images.SetAt (nID, imgDesc);
  750. }
  752. void CRTMenu::SetMenuBarBitmap(CBitmap* MenuBarBitmap[],UINT DrawMode[])
  753. {
  754. for(int i = 0; i < 5; i ++)
  755. {
  756. m_MenuBarBitmap[i] = MenuBarBitmap[i];
  757. m_MenuBarBitmapDrawMode[i] = DrawMode[i];
  758. }
  759. }
  761. void CRTMenu::SetMenuItemBitmap(CBitmap* MenuItemBitmap[],UINT DrawMode[])
  762. {
  763. for(int i = 0; i < 5; i ++)
  764. {
  765. m_MenuItemBitmap[i] = MenuItemBitmap[i];
  766. m_MenuItemBitmapDrawMode[i] = DrawMode[i];
  767. }
  768. }
  769. ///////////////////////////////////////////////////////////////////////////////
  770. void CRTMenu::OnMeasureItem (MEASUREITEMSTRUCT* pMeasureItemStruct)
  771. {
  772.     if ( pMeasureItemStruct->CtlType == ODT_MENU )
  773.     {
  774.         pMeasureItemStruct->itemHeight = LOBYTE(LOWORD(pMeasureItemStruct->itemData));
  776.         if ( pMeasureItemStruct->itemHeight == 0 )
  777.         {
  778.             // This is a menubar item
  779.             pMeasureItemStruct->itemWidth = HIWORD(pMeasureItemStruct->itemData) + TEXTPADDING_MNUBR;
  780.         }
  781.         else
  782.         {
  783.             pMeasureItemStruct->itemWidth = IMGWIDTH + IMGPADDING + HIWORD(pMeasureItemStruct->itemData) + TEXTPADDING + HIBYTE(LOWORD(pMeasureItemStruct->itemData)) + TEXTPADDING + 4;
  784.         }
  785.     }
  786. }
  788. ///////////////////////////////////////////////////////////////////////////////
  789. bool CRTMenu::OnDrawItem (DRAWITEMSTRUCT* pDrawItemStruct, HWND hWnd)
  790. {
  791.     if ( pDrawItemStruct->CtlType != ODT_MENU )
  792.     {
  793.         return false;
  794.     }
  795.     ASSERT (pDrawItemStruct->CtlType == ODT_MENU);
  796.     CBufferDC cDC (pDrawItemStruct->hDC, pDrawItemStruct->rcItem);
  797.     CRTMenuItem item ((HMENU)pDrawItemStruct->hwndItem, pDrawItemStruct->itemID, false);
  798.     CFontDC font (cDC, DEFAULT_GUI_FONT);
  800. if ( item.Draw (&cDC, &pDrawItemStruct->rcItem, (pDrawItemStruct->itemState&ODS_SELECTED)!=0,LOBYTE(LOWORD(pDrawItemStruct->itemData))==0, (pDrawItemStruct->itemState&ODS_HOTLIGHT)!=0, (pDrawItemStruct->itemState&ODS_INACTIVE)!=0, (pDrawItemStruct->itemState&ODS_NOACCEL)!=0) )
  801.     {
  802.         CRect rc;
  804.         ::GetMenuItemRect (hWnd, (HMENU)pDrawItemStruct->hwndItem, 0, rc);
  805.         ::ClientToScreen (hWnd, CRTMenuItem::ms_rcMRUMenuBarItem);
  806.         CRTMenuItem::ms_rcMRUMenuBarItem.top = rc.top;
  807.         CRTMenuItem::ms_rcMRUMenuBarItem.bottom = rc.bottom;
  808.         
  809.         if ( CWnd::FromHandle (hWnd)->IsKindOf (RUNTIME_CLASS(CDialog)) )
  810.         {
  811.             CRTMenuItem::ms_rcMRUMenuBarItem.OffsetRect (1, 0);
  812.         }
  813.     }
  814.     CRTMenuItem::ms_nCheck++;
  815.     
  816.     return true;
  817. }
  819. ///////////////////////////////////////////////////////////////////////////////
  820. LRESULT CRTMenu::OnMenuChar (HMENU hMenu, UINT nChar, UINT nFlags)
  821. {
  822.     if ( (nFlags & (MF_POPUP|MF_SYSMENU)) == MF_POPUP || nFlags == 0 )
  823.     {
  824.         int nItemCount = ::GetMenuItemCount (hMenu);
  826.         nChar = toupper (nChar);
  828.         for ( int i = 0; i < nItemCount; i++ )
  829.         {
  830.             CRTMenuItem mnuItem (hMenu, i);
  831.             CString sCaption;
  833.             mnuItem.GetCaption (sCaption);
  834.             sCaption.MakeUpper();
  836.             for ( int nPos = sCaption.GetLength()-2; nPos >= 0; nPos-- )
  837.             {
  838.                 if ( sCaption[nPos] == '&' && (UINT)toupper (sCaption[nPos+1]) == nChar &&
  839.                      (nPos == 0 || sCaption[nPos-1] != '&') )
  840.                 {
  841.                     return MAKELRESULT(i,2);
  842.                 }
  843.             }
  844.         }
  845.     }
  846.     return 0;
  847. }
  850. ///////////////////////////////////////////////////////////////////////////////
  851. ///////////////////////////////////////////////////////////////////////////////
  852. // CRTWndMenu class : management of the window used by system to display popup menus
  853. //
  854. class CRTWndMenu
  855. {
  856. public:
  857.     CRTWndMenu (HWND hWnd);
  858.    ~CRTWndMenu ();
  860. public:
  861.     static CRTWndMenu* FromHandle (HWND hWnd, bool bPermanent = true);
  863. protected:
  864.     void OnWindowPosChanging (WINDOWPOS* pWP);
  865.     void OnEraseBkgnd ();
  866.     void OnPrint (CDC* pDC, bool bOwnerDrawnItems);
  867.     void OnNcPaint ();
  868.     void OnShowWindow (bool bShow);
  869.     void OnNcDestroy ();
  871. private:
  872.     static LRESULT CALLBACK WindowsHook (int code, WPARAM wParam, LPARAM lParam);
  873.     static LRESULT CALLBACK SubClassMenuProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  875. protected:
  876.     HWND m_hWnd;
  877.     CRect m_rcMenu;
  878.     CPoint m_ptMenu;
  879.     CBitmap m_bmpBkGnd;
  881.     static CMap <HWND, HWND, CRTWndMenu*, CRTWndMenu*> ms_WndMenuMap;
  882.     static DWORD ms_dwRefCount;
  883.     static HHOOK ms_hHookOldMenuCbtFilter;
  885. friend class CRTMenu;
  886. };
  888. ///////////////////////////////////////////////////////////////////////////////
  889. void CRTMenu::InitializeHook ()
  890. {
  891.     CRTWndMenu::ms_dwRefCount++;
  893.     if ( CRTWndMenu::ms_hHookOldMenuCbtFilter == NULL )
  894.     {
  895.         CRTWndMenu::ms_hHookOldMenuCbtFilter = ::SetWindowsHookEx (WH_CALLWNDPROC, CRTWndMenu::WindowsHook, AfxGetApp()->m_hInstance, ::GetCurrentThreadId());
  896.     }
  897. }
  899. ///////////////////////////////////////////////////////////////////////////////
  900. void CRTMenu::UninitializeHook ()
  901. {
  902.     if ( CRTWndMenu::ms_dwRefCount == 0 )
  903.     {
  904.         return;
  905.     }
  906.     if ( --CRTWndMenu::ms_dwRefCount == 0 )
  907.     {
  908.         POSITION pos = CRTWndMenu::ms_WndMenuMap.GetStartPosition();
  910.         while ( pos != NULL )
  911.         {
  912.             HWND hKey;
  913.             CRTWndMenu* pVal;
  915.             CRTWndMenu::ms_WndMenuMap.GetNextAssoc (pos, hKey, pVal);
  916.             delete pVal;
  917.         }
  918.         CRTWndMenu::ms_WndMenuMap.RemoveAll();
  920.         if ( CRTWndMenu::ms_hHookOldMenuCbtFilter != NULL )
  921.         {
  922.             ::UnhookWindowsHookEx (CRTWndMenu::ms_hHookOldMenuCbtFilter);
  923.         }
  924.     }
  925. }
  927. ///////////////////////////////////////////////////////////////////////////////
  928. CMap <HWND, HWND, CRTWndMenu*, CRTWndMenu*> CRTWndMenu::ms_WndMenuMap;
  929. DWORD CRTWndMenu::ms_dwRefCount = 0;
  930. HHOOK CRTWndMenu::ms_hHookOldMenuCbtFilter = NULL;
  932. ///////////////////////////////////////////////////////////////////////////////
  933. CRTWndMenu::CRTWndMenu (HWND hWnd)
  934.     : m_hWnd (hWnd), m_rcMenu (0, 0, 0, 0), m_ptMenu (-0xFFFF, -0xFFFF)
  935. {
  936. }
  938. ///////////////////////////////////////////////////////////////////////////////
  939. CRTWndMenu::~CRTWndMenu ()
  940. {
  941.     WNDPROC oldWndProc = (WNDPROC)::GetProp (m_hWnd, _WndPropName_OldProc);
  943.     if ( oldWndProc != NULL )
  944.     {
  945.         ::SetWindowLong (m_hWnd, GWL_WNDPROC, (DWORD)(DWORD_PTR)oldWndProc);
  946.         ::RemoveProp (m_hWnd, _WndPropName_OldProc);
  947.     }
  948.     ms_WndMenuMap.RemoveKey (m_hWnd);
  949. }
  951. ///////////////////////////////////////////////////////////////////////////////
  952. CRTWndMenu* CRTWndMenu::FromHandle (HWND hWnd, bool bPermanent)
  953. {
  954.     CRTWndMenu* pWnd = NULL;
  956.     if ( ms_WndMenuMap.Lookup (hWnd, pWnd) )
  957.     {
  958.         return pWnd;
  959.     }
  960.     if ( bPermanent )
  961.     {
  962.         return NULL;
  963.     }
  964.     pWnd = new CRTWndMenu (hWnd);
  965.     ms_WndMenuMap.SetAt (hWnd, pWnd);
  967.     return pWnd;
  968. }
  970. ///////////////////////////////////////////////////////////////////////////////
  971. void CRTWndMenu::OnWindowPosChanging (WINDOWPOS* pWP)
  972. {
  973.     if ( GetWinVersion() < wvWinXP )
  974.     {
  975.         pWP->cx += SM_CXSHADOW;
  976.         pWP->cy += SM_CXSHADOW;
  977.     }
  978.     pWP->y--;
  979.     m_ptMenu.x = pWP->x;
  980.     m_ptMenu.y = pWP->y;
  981. }
  983. ///////////////////////////////////////////////////////////////////////////////
  984. void CRTWndMenu::OnEraseBkgnd ()
  985. {
  986.     if ( !IsWindowVisible (m_hWnd) )
  987.     {
  988.         CClientRect rc (m_hWnd);
  990.         if ( m_bmpBkGnd.m_hObject != NULL )
  991.         {
  992.             m_bmpBkGnd.DeleteObject();
  993.         }
  994.         m_bmpBkGnd.Attach (GetScreenBitmap (CRect (m_ptMenu.x, m_ptMenu.y, rc.right+m_ptMenu.x+10,
  995.                                                    rc.bottom+m_ptMenu.y+10)));
  996.     }
  997. }
  999. ///////////////////////////////////////////////////////////////////////////////
  1000. void DrawShadow (HDC hDCIn, HDC hDCOut, RECT& rc)
  1001. {
  1002.     for ( int x = 0; x < rc.right-1; x++ )
  1003.     {
  1004.         int nEnd = ( x > rc.right-SM_CXSHADOW*2 ) ? rc.right-SM_CXSHADOW-x : SM_CXSHADOW;
  1006.         for ( int y = ( x < 2 ) ? 2-x : x > rc.right-SM_CXSHADOW-3 ? x-rc.right+SM_CXSHADOW+3 : 0; y < nEnd; y++ )
  1007.         {
  1008.             int nMakeSpec = 78+(3-(x==0?0:(x==1?(y<2?0:1):(x==2?(y<2?y:2):y))))*5;
  1009.             COLORREF cr = GetPixel (hDCIn, x+SM_CXSHADOW, rc.bottom-y-1);
  1010.             COLORREF cr2 = RGB(((nMakeSpec * int(GetRValue(cr))) / 100),
  1011.                    ((nMakeSpec * int(GetGValue(cr))) / 100),
  1012.                    ((nMakeSpec * int(GetBValue(cr))) / 100));
  1013. SetPixel (hDCOut, x+SM_CXSHADOW, rc.bottom-y-1, cr2);
  1014.         }
  1015.     }
  1016.     for ( x = 0; x < SM_CXSHADOW; x++ )
  1017.     {
  1018.         for ( int y = ( x < 2 ) ? 2-x : 0; y < rc.bottom-x-SM_CXSHADOW-((x>0)?1:2); y++ )
  1019.         {
  1020.             int nMakeSpec = 78+(3-(y==0?0:(y==1?(x<2?0:1):(y==2?(x<2?x:2):x))))*5;
  1021.             COLORREF cr = GetPixel (hDCIn, rc.right-x-1, y+SM_CXSHADOW);
  1022.             COLORREF cr2 = RGB(((nMakeSpec * int(GetRValue(cr))) / 100),
  1023.                    ((nMakeSpec * int(GetGValue(cr))) / 100),
  1024.                    ((nMakeSpec * int(GetBValue(cr))) / 100));
  1025. SetPixel (hDCOut, rc.right-x-1, y+SM_CXSHADOW, cr2);
  1026.         }
  1027.     }
  1028. }
  1030. ///////////////////////////////////////////////////////////////////////////////
  1031. void CRTWndMenu::OnPrint (CDC* pDC, bool bOwnerDrawnItems)
  1032. {
  1033.     CWindowRect rc (m_hWnd);
  1034.     CBrushDC br (pDC->m_hDC);
  1035.     CPenDC pen (pDC->m_hDC, ::GetSysColor (COLOR_3DDKSHADOW));
  1037.     rc.OffsetRect (-rc.TopLeft());
  1038.     m_rcMenu = rc;
  1040.     if ( GetWinVersion() < wvWinXP )
  1041.     {
  1042.         rc.right -= SM_CXSHADOW;
  1043.         rc.bottom -= SM_CXSHADOW;
  1044.     }
  1045.     pDC->Rectangle (rc);
  1046.     pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +75, 0));
  1047.     rc.DeflateRect (1, 1);
  1048.     pDC->Rectangle (rc);
  1049.     rc.DeflateRect (1, 1);
  1050.     pDC->Rectangle (rc);
  1052.     if ( bOwnerDrawnItems && !CRTMenuItem::ms_rcMRUMenuBarItem.IsRectEmpty() &&
  1053.          CRTMenuItem::ms_rcMRUMenuBarItem.bottom == m_ptMenu.y+1 )
  1054.     {
  1055.         pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  1056.         pDC->MoveTo (CRTMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x-3, 0);
  1057.         pDC->LineTo (CRTMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x+CRTMenuItem::ms_rcMRUMenuBarItem.Width()-5, 0);
  1058.     }
  1059.     if ( GetWinVersion() < wvWinXP )
  1060.     {
  1061.         rc.right += SM_CXSHADOW+2;
  1062.         rc.bottom += SM_CXSHADOW+2;
  1064.         CDC cMemDC;
  1065.         cMemDC.CreateCompatibleDC (pDC);
  1066.         HGDIOBJ hOldBitmap = ::SelectObject (cMemDC.m_hDC, m_bmpBkGnd);
  1067.         pDC->BitBlt (0, rc.bottom-SM_CXSHADOW, SM_CXSHADOW*2, SM_CXSHADOW, &cMemDC, 0, rc.bottom-SM_CXSHADOW, SRCCOPY);
  1068.         pDC->BitBlt (rc.right-SM_CXSHADOW, rc.bottom-SM_CXSHADOW, SM_CXSHADOW, SM_CXSHADOW, &cMemDC, rc.right-SM_CXSHADOW, rc.bottom-SM_CXSHADOW, SRCCOPY);
  1069.         pDC->BitBlt (rc.right-SM_CXSHADOW, 0, SM_CXSHADOW, SM_CXSHADOW*2, &cMemDC, rc.right-SM_CXSHADOW, 0, SRCCOPY);
  1070.         DrawShadow (cMemDC.m_hDC, pDC->m_hDC, rc);
  1071.         ::SelectObject (cMemDC.m_hDC, hOldBitmap);
  1072.     }
  1073. }
  1075. ///////////////////////////////////////////////////////////////////////////////
  1076. void CRTWndMenu::OnNcPaint ()
  1077. {
  1078.     CWindowDC cDC (CWnd::FromHandle (m_hWnd));
  1079.     CDC* pDC = &cDC;
  1080.     CWindowRect rc (m_hWnd);
  1082.     m_ptMenu.x = rc.left;
  1083.     m_ptMenu.y = rc.top;
  1084.     rc.OffsetRect (-rc.TopLeft());
  1086.     if ( rc != m_rcMenu )
  1087.     {
  1088.         m_rcMenu = rc;
  1090.         CBrushDC br (pDC->m_hDC);
  1091.         CPenDC pen (pDC->m_hDC, ::GetSysColor (COLOR_3DDKSHADOW));
  1093.         if ( GetWinVersion() < wvWinXP )
  1094.         {
  1095.             rc.right -= SM_CXSHADOW;
  1096.             rc.bottom -= SM_CXSHADOW;
  1097.         }
  1099.         pDC->Rectangle (rc);
  1100.         pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +75, 0));
  1101.         rc.DeflateRect (1, 1);
  1102. pDC->Rectangle (rc);
  1103.         rc.DeflateRect (1, 1);
  1104. pDC->Rectangle (rc);
  1106.         if ( !CRTMenuItem::ms_rcMRUMenuBarItem.IsRectEmpty() &&
  1107.              CRTMenuItem::ms_rcMRUMenuBarItem.bottom == m_ptMenu.y+1 )
  1108.         {
  1109.             pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  1110.             pDC->MoveTo (CRTMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x-3, 0);
  1111.             pDC->LineTo (CRTMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x+CRTMenuItem::ms_rcMRUMenuBarItem.Width()-5, 0);
  1112.         }
  1113.         if ( GetWinVersion() < wvWinXP )
  1114.         {
  1115.             rc.right += SM_CXSHADOW+2;
  1116.             rc.bottom += SM_CXSHADOW+2;
  1118.             DrawShadow (pDC->m_hDC, pDC->m_hDC, rc);
  1119.         }
  1120.     }
  1121. }
  1123. ///////////////////////////////////////////////////////////////////////////////
  1124. void CRTWndMenu::OnShowWindow (bool bShow)
  1125. {
  1126.     if ( !bShow )
  1127.     {
  1128.         delete this;
  1129.     }
  1130. }
  1132. ///////////////////////////////////////////////////////////////////////////////
  1133. void CRTWndMenu::OnNcDestroy ()
  1134. {
  1135.     delete this;
  1136. }
  1138. ///////////////////////////////////////////////////////////////////////////////
  1139. LRESULT CALLBACK CRTWndMenu::WindowsHook (int code, WPARAM wParam, LPARAM lParam)
  1140. {
  1141.     CWPSTRUCT* pStruct = (CWPSTRUCT*)lParam;
  1143.     // Not a real loop (just for 'break' branchment)
  1144.     while ( code == HC_ACTION )
  1145.     {
  1146.         HWND hWnd = pStruct->hwnd;
  1148.         // Normal and special handling for menu 0x10012
  1149.         if ( pStruct->message != WM_CREATE && pStruct->message != 0x01E2 )
  1150.         {
  1151.             break;
  1152.         }
  1153.         CWnd* pFrame = CWnd::GetForegroundWindow();
  1155. if ( pFrame == NULL || !CRTMenu::GetXPLookNFeel (pFrame) || !CRTMenu::m_bEnableSkin )
  1156.         {
  1157.             break;
  1158.         }
  1159.         TCHAR sClassName[10];
  1160.         int Count = ::GetClassName (hWnd, sClassName, lengthof(sClassName));
  1162.         // Check for the menu-class
  1163.         if ( Count != 6 || _tcscmp (sClassName, _T("#32768")) != 0 )
  1164.         {
  1165.             break;
  1166.         }
  1167.         VERIFY(CRTWndMenu::FromHandle (pStruct->hwnd, false) != NULL);
  1169.         if ( ::GetProp (pStruct->hwnd, _WndPropName_OldProc) != NULL )
  1170.         {
  1171.             // Already subclassed
  1172.             break;
  1173.         }
  1174.         // Subclass the window
  1175.         WNDPROC oldWndProc = (WNDPROC)(LONG_PTR)::GetWindowLong (pStruct->hwnd, GWL_WNDPROC);
  1177.         if ( oldWndProc == NULL )
  1178.         {
  1179.             break;
  1180.         }
  1181.         ASSERT(oldWndProc != SubClassMenuProc);
  1183.         if ( !SetProp (pStruct->hwnd, _WndPropName_OldProc, oldWndProc) )
  1184.         {
  1185.             break;
  1186.         }
  1187.         if ( !SetWindowLong (pStruct->hwnd, GWL_WNDPROC,(DWORD)(DWORD_PTR)SubClassMenuProc) )
  1188.         {
  1189.             ::RemoveProp (pStruct->hwnd, _WndPropName_OldProc);
  1190.             break;
  1191.         }
  1192.         // Success !
  1193.         break;
  1194.     }
  1195.     return CallNextHookEx (CRTWndMenu::ms_hHookOldMenuCbtFilter, code, wParam, lParam);
  1196. }
  1198. ///////////////////////////////////////////////////////////////////////////////
  1199. LRESULT CALLBACK CRTWndMenu::SubClassMenuProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  1200. {
  1201.     WNDPROC oldWndProc = (WNDPROC)::GetProp (hWnd, _WndPropName_OldProc);
  1202.     CRTWndMenu* pWnd = NULL;
  1204.     switch ( uMsg )
  1205.     {
  1206.     case WM_NCCALCSIZE:
  1207.         {
  1208.             LRESULT lResult = CallWindowProc (oldWndProc, hWnd, uMsg, wParam, lParam);
  1210.             if ( GetWinVersion() < wvWinXP )
  1211.             {
  1212.                 NCCALCSIZE_PARAMS* lpncsp = (NCCALCSIZE_PARAMS*)lParam;
  1214.                 lpncsp->rgrc[0].right -= SM_CXSHADOW;
  1215.                 lpncsp->rgrc[0].bottom -= SM_CXSHADOW;
  1216.             }
  1217.             return lResult;
  1218.         }
  1220.     case WM_WINDOWPOSCHANGING:
  1221.         if ( (pWnd=CRTWndMenu::FromHandle (hWnd)) != NULL )
  1222.         {
  1223.             pWnd->OnWindowPosChanging ((LPWINDOWPOS)lParam);
  1224.         }
  1225.         break;
  1227.     case WM_ERASEBKGND:
  1228.         if ( (pWnd=CRTWndMenu::FromHandle (hWnd)) != NULL )
  1229.         {
  1230.             pWnd->OnEraseBkgnd();
  1231.         }
  1232.         break;
  1234.     case WM_PRINT:
  1235.         {
  1236.             BYTE nCheck = CRTMenuItem::ms_nCheck;
  1237.             LRESULT lResult = CallWindowProc (oldWndProc, hWnd, uMsg, wParam, lParam);
  1238.             bool bOwnerDrawnItems = nCheck != CRTMenuItem::ms_nCheck;
  1240.             if ( (pWnd=CRTWndMenu::FromHandle (hWnd)) != NULL )
  1241.             {
  1242.                 pWnd->OnPrint (CDC::FromHandle ((HDC)wParam), bOwnerDrawnItems);
  1243.             }
  1244.             return lResult;
  1245.         }
  1247.     case WM_NCPAINT:
  1248.         if ( (pWnd=CRTWndMenu::FromHandle (hWnd)) != NULL )
  1249.         {
  1250.             pWnd->OnNcPaint();
  1251.             return 0;
  1252.         }
  1253.         break;
  1255.     case WM_SHOWWINDOW:
  1256.         if ( (pWnd=CRTWndMenu::FromHandle (hWnd)) != NULL )
  1257.         {
  1258.             pWnd->OnShowWindow (wParam != 0);
  1259.         }
  1260.         break;
  1262.     case WM_NCDESTROY:
  1263.         if ( (pWnd=CRTWndMenu::FromHandle (hWnd)) != NULL )
  1264.         {
  1265.             pWnd->OnNcDestroy();
  1266.         }
  1267.         break;
  1268.     }
  1269.     return CallWindowProc (oldWndProc, hWnd, uMsg, wParam, lParam);
  1270. }