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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > CAD > 查看源码
MenuXP.cpp
资源名称：CAD2006.rar　[点击查看]
上传用户：ckg1000
上传日期：2013-01-26
资源大小：630k
文件大小：39k
源码类别：

CAD

开发平台：

Visual C++

MenuXP.cpp：源码内容
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //
  3. // MenuXP.cpp : implementation file
  4. //
  5. ///////////////////////////////////////////////////////////////////////////////
  7. #include "stdafx.h"
  8. #include "MenuXP.h"
  9. #include "Tools.h"
  10. #include "Draw.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 CMenuItem
  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.     CMenuItem ();
  71.     CMenuItem (HMENU hMenu, UINT uItem, bool fByPosition = true);
  72.    ~CMenuItem ();
  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;
  93. public:
  94.     static BYTE ms_nCheck;
  95.     static CRect ms_rcMRUMenuBarItem;
  96. };
  99. ///////////////////////////////////////////////////////////////////////////////
  100. ///////////////////////////////////////////////////////////////////////////////
  101. BYTE CMenuItem::ms_nCheck = 0;
  102. CRect CMenuItem::ms_rcMRUMenuBarItem (0, 0, 0, 0);
  104. ///////////////////////////////////////////////////////////////////////////////
  105. CMenuItem::CMenuItem ()
  106. {
  107.     memset (&m_miInfo, 0, sizeof(MENUITEMINFO));
  108. }
  110. ///////////////////////////////////////////////////////////////////////////////
  111. CMenuItem::CMenuItem (HMENU hMenu, UINT uItem, bool fByPosition)
  112. {
  113.     memset (&m_miInfo, 0, sizeof(MENUITEMINFO));
  114.     m_miInfo.cbSize = sizeof(MENUITEMINFO);
  115.     m_miInfo.fMask = MIIM_STATE|MIIM_SUBMENU|MIIM_TYPE|MIIM_DATA|MIIM_ID;
  116.     VERIFY (::GetMenuItemInfo (hMenu, uItem, fByPosition, &m_miInfo));
  118.     if ( !(m_miInfo.fType & MFT_SEPARATOR) )
  119.     {
  120.         if ( m_miInfo.hSubMenu != NULL )
  121.         {
  122.             CMenuXP::ms_sSubMenuCaptions.Lookup (m_miInfo.hSubMenu, m_sCaption);
  123.             CMenuXP::ms_SubMenuImages.Lookup (m_miInfo.hSubMenu, m_ImgDesc);
  124.         }
  125.         else
  126.         {
  127.             CMenuXP::ms_sCaptions.Lookup (m_miInfo.wID, m_sCaption);
  128.             CMenuXP::ms_Images.Lookup (m_miInfo.wID, m_ImgDesc);
  129.         }
  130.     }
  131. }
  133. ///////////////////////////////////////////////////////////////////////////////
  134. CMenuItem::~CMenuItem ()
  135. {
  136. }
  138. ///////////////////////////////////////////////////////////////////////////////
  139. int CMenuItem::GetCaption (CString& sCaption) const
  140. {
  141.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  142.     sCaption = m_sCaption;
  144.     int nShortCutPos = sCaption.Find ('t');
  146.     if ( nShortCutPos == -1 )
  147.     {
  148.         return sCaption.GetLength();
  149.     }
  150.     sCaption = sCaption.Left (nShortCutPos);
  152.     return nShortCutPos-1;
  153. }
  155. ///////////////////////////////////////////////////////////////////////////////
  156. int CMenuItem::GetShortCut (CString& sShortCut) const
  157. {
  158.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  159.     CString sCaption = m_sCaption;
  161.     int nShortCutPos = sCaption.Find ('t');
  163.     if ( nShortCutPos == -1 )
  164.     {
  165.         sShortCut = "";
  166.         return 0;
  167.     }
  168.     int nLength = sCaption.GetLength()-nShortCutPos-1;
  170.     sShortCut = sCaption.Right (nLength);
  172.     return nLength;
  173. }
  175. ///////////////////////////////////////////////////////////////////////////////
  176. bool CMenuItem::GetSeparator () const
  177. {
  178.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  179.     return (m_miInfo.fType & MFT_SEPARATOR) == MFT_SEPARATOR;
  180. }
  182. ///////////////////////////////////////////////////////////////////////////////
  183. bool CMenuItem::GetChecked () const
  184. {
  185.     ASSERT(m_miInfo.fMask & MIIM_STATE);
  186.     return (m_miInfo.fState & MFS_CHECKED) == MFS_CHECKED;
  187. }
  189. ///////////////////////////////////////////////////////////////////////////////
  190. bool CMenuItem::GetRadio () const
  191. {
  192.     ASSERT(m_miInfo.fMask & MIIM_TYPE);
  193.     return (m_miInfo.fType & MFT_RADIOCHECK) == MFT_RADIOCHECK;
  194. }
  196. ///////////////////////////////////////////////////////////////////////////////
  197. bool CMenuItem::GetDisabled () const
  198. {
  199.     ASSERT(m_miInfo.fMask & MIIM_STATE);
  200.     return (m_miInfo.fState & MFS_GRAYED) == MFS_GRAYED;
  201. }
  203. ///////////////////////////////////////////////////////////////////////////////
  204. bool CMenuItem::GetDefault () const
  205. {
  206.     ASSERT(m_miInfo.fMask & MIIM_STATE);
  207.     return (m_miInfo.fState & MFS_DEFAULT) == MFS_DEFAULT;
  208. }
  210. ///////////////////////////////////////////////////////////////////////////////
  211. HMENU CMenuItem::GetPopup () const
  212. {
  213.     ASSERT(m_miInfo.fMask & MIIM_SUBMENU);
  214.     return m_miInfo.hSubMenu;
  215. }
  217. ///////////////////////////////////////////////////////////////////////////////
  218. UINT CMenuItem::GetID () const
  219. {
  220.     ASSERT(m_miInfo.fMask & MIIM_ID);
  221.     return m_miInfo.wID;
  222. }
  224. ///////////////////////////////////////////////////////////////////////////////
  225. int CMenuItem::GetCaptionWidth (CDC* pDC) const
  226. {
  227.     if ( GetSeparator() )
  228.     {
  229.         return 0;
  230.     }
  231.     CString sCaption;
  232.     int nLength = 0;
  234.     if ( GetCaption (sCaption) > 0 )
  235.     {
  236.         int nPos = sCaption.Find ('&');
  237.         CBoldDC bold (*pDC, GetDefault());
  239.         if ( nPos >= 0 )
  240.         {
  241.             sCaption = sCaption.Left (nPos) + sCaption.Right (sCaption.GetLength()-nPos-1);
  242.         }
  243.         nLength = pDC->GetTextExtent (sCaption).cx;
  244.     }
  245.     return nLength;
  246. }
  248. ///////////////////////////////////////////////////////////////////////////////
  249. int CMenuItem::GetShortCutWidth (CDC* pDC) const
  250. {
  251.     if ( GetSeparator() )
  252.     {
  253.         return 0;
  254.     }
  255.     CString sShortCut;
  256.     int nLength = 0;
  258.     if ( GetShortCut (sShortCut) > 0 )
  259.     {
  260.         CBoldDC bold (*pDC, GetDefault());
  262.         nLength = pDC->GetTextExtent (sShortCut).cx;
  263.     }
  264.     return nLength;
  265. }
  267. ///////////////////////////////////////////////////////////////////////////////
  268. int CMenuItem::GetHeight (CDC* pDC) const
  269. {
  270.     TEXTMETRIC tm;
  272.     pDC->GetTextMetrics (&tm);
  273.                      
  274.     return GetSeparator() ? tm.tmHeight/2+2 : tm.tmHeight+4;
  275. }
  277. ///////////////////////////////////////////////////////////////////////////////
  278. bool CMenuItem::Draw (CDC* pDC, LPCRECT pRect, bool bSelected, bool bMenuBar, bool bHotLight, bool bInactive, bool bNoAccel) const
  279. {
  280.     COLORREF crBackImg = CLR_NONE;
  281.     bool bMenuBarItemSelected = false;
  283.     if ( bMenuBar && bSelected )
  284.     {
  285.         CRect rc (pRect);
  286.         CPenDC pen (*pDC, ::GetSysColor (COLOR_3DDKSHADOW));
  287.         CBrushDC brush (*pDC, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  289.         rc.right -= TEXTPADDING_MNUBR;
  290.         ms_rcMRUMenuBarItem = rc;
  291.         bMenuBarItemSelected = true;
  292.         pDC->Rectangle (rc);
  293.         rc.left = rc.right;
  294.         rc.right += TEXTPADDING_MNUBR;
  295.         pDC->FillSolidRect (rc, ::GetSysColor (COLOR_3DFACE));
  297.         for ( int x = 0; x < SM_CXSHADOW; x++ )
  298.         {
  299.             for ( int y = ( x < 2 ) ? 2-x : 0; y < rc.Height()-x-((x>0)?1:2); y++ )
  300.             {
  301.                 int nMakeSpec = 78+(3-(y==0?0:(y==1?(x<2?0:1):(y==2?(x<2?x:2):x))))*5;
  302.                 COLORREF cr = pDC->GetPixel (rc.right-x-1, rc.top+y+SM_CXSHADOW);
  303.                 COLORREF cr2 = RGB(((nMakeSpec * int(GetRValue(cr))) / 100),
  304.                        ((nMakeSpec * int(GetGValue(cr))) / 100),
  305.                        ((nMakeSpec * int(GetBValue(cr))) / 100));
  306.     pDC->SetPixel (rc.right-x-1, rc.top+y+SM_CXSHADOW, cr2);
  307.             }
  308.         }
  309.     }
  310.     else if ( bSelected || (bHotLight && !bInactive) )
  311.     {
  312.         COLORREF crHighLight = ::GetSysColor (COLOR_HIGHLIGHT);
  313.         CPenDC pen (*pDC, crHighLight);
  314.         CBrushDC brush (*pDC, crBackImg = GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +73, 0) : HLS_TRANSFORM (crHighLight, +70, -57));
  316.         if ( bMenuBar )
  317.         {
  318.             CRect rc (pRect);
  320.             rc.right -= TEXTPADDING_MNUBR;
  321.             pDC->Rectangle (rc);
  322.             rc.left = rc.right;
  323.             rc.right += TEXTPADDING_MNUBR;
  324.             pDC->FillSolidRect (rc, ::GetSysColor (COLOR_3DFACE));
  325.         }
  326.         else
  327.         {
  328.             pDC->Rectangle (pRect);
  329.         }
  330.     }
  331.     else if ( !bMenuBar )
  332.     {
  333.         CRect rc (pRect);
  335.         rc.right = IMGWIDTH+IMGPADDING;
  336.         pDC->FillSolidRect (rc, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  337.         rc.left = rc.right;
  338.         rc.right = pRect->right;
  339.         pDC->FillSolidRect (rc, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +75, 0));
  340.     }
  341.     else
  342.     {
  343.         pDC->FillSolidRect (pRect, ::GetSysColor (COLOR_3DFACE));
  344.     }
  345.     if ( GetSeparator() )
  346.     {
  347.         CPenDC pen (*pDC, HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -18, 0));
  349.         pDC->MoveTo (pRect->left+IMGWIDTH+IMGPADDING+TEXTPADDING,  (pRect->top+pRect->bottom)/2);
  350.         pDC->LineTo (pRect->right-1, (pRect->top+pRect->bottom)/2);
  351.     }
  352.     else
  353.     {
  354.         CRect rc (pRect);
  355.         CString sCaption;
  357.         if ( GetCaption (sCaption) > 0 )
  358.         {
  359.             pDC->SetTextColor (bInactive ? ::GetSysColor (COLOR_3DSHADOW) : (GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -18, 0) : ::GetSysColor (COLOR_MENUTEXT)));
  360.             pDC->SetBkMode (TRANSPARENT);
  362.             BOOL bKeyboardCues = true;
  363.             ::SystemParametersInfo (SPI_GETKEYBOARDCUES, 0, &bKeyboardCues, 0);
  364.             DWORD dwHidePrefix = ( bNoAccel && !bKeyboardCues ) ? DT_HIDEPREFIX : 0;
  366.             if ( bMenuBar )
  367.             {
  368.                 rc.right -= TEXTPADDING_MNUBR;
  369.                 pDC->DrawText (sCaption, rc, DT_SINGLELINE|DT_VCENTER|DT_CENTER|dwHidePrefix);
  370.             }
  371.             else
  372.             {
  373.                 CBoldDC bold (*pDC, GetDefault());
  375.                 rc.left = IMGWIDTH+IMGPADDING+TEXTPADDING;
  376.                 pDC->DrawText (sCaption, rc, DT_SINGLELINE|DT_VCENTER|DT_LEFT|dwHidePrefix);
  378.                 CString sShortCut;
  380.                 if ( GetShortCut (sShortCut) > 0 )
  381.                 {
  382.                     rc.right -= TEXTPADDING+4;
  383.                     pDC->DrawText (sShortCut, rc, DT_SINGLELINE|DT_VCENTER|DT_RIGHT);
  384.                 }
  385.                 if ( GetChecked() )
  386.                 {
  387.                     COLORREF crHighLight = ::GetSysColor (COLOR_HIGHLIGHT);
  388.                     CPenDC pen (*pDC, crHighLight);
  389.                     CBrushDC brush (*pDC, crBackImg = GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +73, 0) :
  390.                                                                       (bSelected ? HLS_TRANSFORM (crHighLight, +50, -50) : HLS_TRANSFORM (crHighLight, +70, -57)));
  392.                     pDC->Rectangle (CRect (pRect->left+1, pRect->top+1, pRect->left+IMGWIDTH+4, pRect->bottom-1));
  393.                 }
  394.                 if ( m_ImgDesc.m_hImgList != NULL && m_ImgDesc.m_nIndex != -1 )
  395.                 {
  396.                     bool bOver = !GetDisabled() && bSelected;
  398.                     if ( GetDisabled() || (bSelected && !GetChecked()) )
  399.                     {
  400.                         HICON hIcon = ImageList_ExtractIcon (NULL, m_ImgDesc.m_hImgList, m_ImgDesc.m_nIndex);
  401.                         pDC->DrawState (CPoint (pRect->left + ( bOver ? 4 : 3 ), rc.top + ( bOver ? 4 : 3 )),
  402.                                         CSize (IMGWIDTH, IMGHEIGHT), hIcon, DSS_MONO,
  403.                                         CBrush (bOver ? HLS_TRANSFORM (::GetSysColor (COLOR_HIGHLIGHT), +50, -66) : HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -27, 0)));
  404.                         DestroyIcon (hIcon);
  405.                     }
  406.                     if ( !GetDisabled() )
  407.                     {
  408.                         ::ImageList_Draw (m_ImgDesc.m_hImgList, m_ImgDesc.m_nIndex, pDC->m_hDC,
  409.                                           pRect->left+( (bSelected && !GetChecked()) ? 2 : 3 ), rc.top+( (bSelected && !GetChecked()) ? 2 : 3 ), ILD_TRANSPARENT);
  410.                     }
  411.                 }
  412.                 else if ( GetChecked() )
  413.                 {
  414.                     // Draw the check mark
  415.                     rc.left  = pRect->left+IMGWIDTH/4+1;
  416.                     rc.right = rc.left + IMGWIDTH-1;
  418.                     if ( GetRadio() )
  419.                     {
  420.                         CPoint ptCenter = rc.CenterPoint();
  421.                         COLORREF crBullet = GetDisabled() ? HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), -27, 0) : ::GetSysColor (COLOR_MENUTEXT);
  422.                         CPenDC pen (*pDC, crBullet);
  423.                         CBrushDC brush (*pDC, crBullet);
  424.                         
  425.                         pDC->Ellipse (CRect (ptCenter.x-4, ptCenter.y-3, ptCenter.x+3, ptCenter.y+4));
  426.                         pDC->SetPixel (ptCenter.x+1, ptCenter.y+2, crBackImg);
  427.                     }
  428.                     else
  429.                     {
  430.                         pDC->SetBkColor (crBackImg);
  431.                         HBITMAP hBmp = LoadBitmap (NULL, MAKEINTRESOURCE(OBM_CHECK));
  432.                         pDC->DrawState (CPoint (rc.left,rc.top+3), CSize(rc.Size()), hBmp, DSS_NORMAL, (HBRUSH)NULL);
  433.                         DeleteObject (hBmp);
  434.                     }
  435.                 }
  436.             }
  437.         }
  438.     }
  439.     return bMenuBarItemSelected;
  440. }
  443. ///////////////////////////////////////////////////////////////////////////////
  444. ///////////////////////////////////////////////////////////////////////////////
  445. CMap <int, int, CString, CString&> CMenuXP::ms_sCaptions;
  446. CMap <HMENU, HMENU, CString, CString&> CMenuXP::ms_sSubMenuCaptions;
  447. CMap <int, int, CImgDesc, CImgDesc&> CMenuXP::ms_Images;
  448. CMap <HMENU, HMENU, CImgDesc, CImgDesc&> CMenuXP::ms_SubMenuImages;
  450. ///////////////////////////////////////////////////////////////////////////////
  451. void CMenuXP::SetXPLookNFeel (CWnd* pWnd, bool bXPLook)
  452. {
  453.     if ( bXPLook )
  454.     {
  455.         ::SetProp (pWnd->GetSafeHwnd(), _WndPropName_MenuXP, (HANDLE)TRUE);
  456.     }
  457.     else
  458.     {
  459.         ::RemoveProp (pWnd->GetSafeHwnd(), _WndPropName_MenuXP);
  460.     }
  461. }
  463. ///////////////////////////////////////////////////////////////////////////////
  464. bool CMenuXP::GetXPLookNFeel (const CWnd* pWnd)
  465. {
  466.     return ::GetProp (pWnd->GetSafeHwnd(), _WndPropName_MenuXP) != NULL;
  467. }
  469. ///////////////////////////////////////////////////////////////////////////////
  470. void CMenuXP::UpdateMenuBar (CWnd* pWnd)
  471. {
  472.     if ( GetXPLookNFeel (pWnd) )
  473.     {
  474.         HMENU hMenu = pWnd->GetMenu()->GetSafeHmenu();
  476.         if ( hMenu != NULL )
  477.         {
  478.             SetXPLookNFeel (pWnd, hMenu, true, true);
  479.         }
  480.     }
  481. }
  483. ///////////////////////////////////////////////////////////////////////////////
  484. void CMenuXP::SetXPLookNFeel (CWnd* pWnd, HMENU hMenu, bool bXPLook, bool bMenuBar)
  485. {
  486.     if ( !bXPLook )
  487.     {
  488.         // TODO: Remove the ownerdraw style ?
  489.         return;
  490.     }
  491. //    TRACE(_T("Referenced captions : %in"), ms_sCaptions.GetCount()+ms_sSubMenuCaptions.GetCount());
  492.     // Clean up old references...
  493.     // ... for captions
  494.     POSITION pos = ms_sSubMenuCaptions.GetStartPosition();
  496.     while ( pos != NULL )
  497.     {
  498.         HMENU hSubMenu;
  499.         CString sBuff;
  501.         ms_sSubMenuCaptions.GetNextAssoc (pos, hSubMenu, sBuff);
  503.         if ( !::IsMenu (hSubMenu) )
  504.         {
  505.             ms_sSubMenuCaptions.RemoveKey (hSubMenu);
  506.         }
  507.     }
  508.     // ... for images
  509.     pos = ms_SubMenuImages.GetStartPosition();
  511.     while ( pos != NULL )
  512.     {
  513.         HMENU hSubMenu;
  514.         CImgDesc ImgDesc;
  516.         ms_SubMenuImages.GetNextAssoc (pos, hSubMenu, ImgDesc);
  518.         if ( !::IsMenu (hSubMenu) )
  519.         {
  520.             ms_SubMenuImages.RemoveKey (hSubMenu);
  521.         }
  522.     }
  523.     ASSERT(hMenu != NULL);
  524.     int nItemCount = ::GetMenuItemCount (hMenu);
  525.     MENUITEMINFO mii = { sizeof MENUITEMINFO, MIIM_ID|MIIM_TYPE|MIIM_SUBMENU };
  526.     CClientDC cDC (AfxGetMainWnd());
  527.     TEXTMETRIC tm;
  528.     CFontDC font (cDC, DEFAULT_GUI_FONT);
  530.     cDC.GetTextMetrics (&tm);
  532.     int nHeight = max(tm.tmHeight+2,IMGHEIGHT)+4;
  533.     int nSepHeight = tm.tmHeight/2+2;
  534.     int nCaptionLength = 0;
  535.     int nShortCutLength = 0;
  536.     CPtrList* pListControlBars = NULL;
  538.     if ( pWnd != NULL && !bMenuBar )
  539.     {
  540.         if ( pWnd->IsKindOf (RUNTIME_CLASS(CMDIFrameWnd)) )
  541.         {
  542.             CMDIChildWnd* pActiveChild = ((CMDIFrameWnd*)pWnd)->MDIGetActive();
  544.             if ( pActiveChild != NULL && pActiveChild->GetSystemMenu (false)->GetSafeHmenu() == hMenu )
  545.             {
  546.                 CMenuItem::ms_rcMRUMenuBarItem.SetRectEmpty();
  547.                 return;
  548.             }
  549.         }
  550.         if ( pWnd->IsKindOf (RUNTIME_CLASS(CFrameWnd)) && !((CFrameWnd*)pWnd)->m_listControlBars.IsEmpty() )
  551.         {
  552.             pListControlBars = &((CFrameWnd*)pWnd)->m_listControlBars;
  553.         }
  554.         else
  555.         {
  556.             CFrameWnd* pFrame = pWnd->GetParentFrame();
  558.             if ( pFrame != NULL && pFrame->IsKindOf (RUNTIME_CLASS(CMDIChildWnd)) )
  559.             {
  560.                 pFrame = pFrame->GetParentFrame();
  561.             }
  562.             if ( pFrame != NULL )
  563.             {
  564.                 pListControlBars = &pFrame->m_listControlBars;
  565.             }
  566.         }
  567.     }
  568.     for ( int i = 0; i < nItemCount; i++ )
  569.     {
  570.         TCHAR sCaption[256] = _T("");
  571.         mii.dwTypeData = sCaption;
  572.         mii.cch = 255;
  573.         mii.fMask &= ~MIIM_DATA;
  574.         ::GetMenuItemInfo (hMenu, i, true, &mii);
  576.         if ( (mii.fType & MFT_OWNERDRAW) == 0 && (!bMenuBar || (mii.fType & MFT_BITMAP) == 0) )
  577.         {
  578.             mii.fType |= MFT_OWNERDRAW;
  580.             if ( bMenuBar )
  581.             {
  582.                 CRect rcText (0, 0, 1000, 0);
  584.                 cDC.DrawText (sCaption, (int)_tcslen (sCaption), rcText, DT_SINGLELINE|DT_LEFT|DT_CALCRECT);
  585.                 mii.dwItemData = MAKELONG(MAKEWORD(0, 0), rcText.Width());
  586.                 mii.fMask |= MIIM_DATA;
  587.             }
  588.             ::SetMenuItemInfo (hMenu, i, true, &mii);
  590.             if ( (mii.fType & MFT_SEPARATOR) == 0 )
  591.             {
  592.                 CString sBuff(sCaption);
  594.                 if ( mii.hSubMenu != NULL )
  595.                 {
  596.                     ms_sSubMenuCaptions.SetAt (mii.hSubMenu, sBuff);
  597.                 }
  598.                 else
  599.                 {
  600.                     ms_sCaptions.SetAt (mii.wID, sBuff);
  601.                 }
  602.                 if ( pListControlBars != NULL )
  603.                 {
  604.                     POSITION pos = pListControlBars->GetHeadPosition();
  606.                     while ( pos != NULL )
  607.                     {
  608.                         CControlBar* pBar = (CControlBar*)pListControlBars->GetNext (pos);
  609.                         ASSERT(pBar != NULL);
  610.                         TCHAR sClassName[256];
  612.                         ::GetClassName (pBar->m_hWnd, sClassName, lengthof (sClassName));
  614.                         if ( !_tcsicmp (sClassName, _T("ToolbarWindow32")) )
  615.                         {
  616.                             TBBUTTONINFO tbbi = { sizeof(TBBUTTONINFO), TBIF_COMMAND|TBIF_IMAGE };
  618.                             if ( pBar->SendMessage (TB_GETBUTTONINFO, mii.wID, (LPARAM)&tbbi) != -1 &&
  619.                                  (UINT)tbbi.idCommand == mii.wID && tbbi.iImage != -1 )
  620.                             {
  621.                                 CImgDesc imgDesc ((HIMAGELIST)pBar->SendMessage (TB_GETIMAGELIST, 0, 0), tbbi.iImage);
  623.                                 if ( mii.hSubMenu != NULL )
  624.                                 {
  625.                                     ms_SubMenuImages.SetAt (mii.hSubMenu, imgDesc);
  626.                                 }
  627.                                 else
  628.                                 {
  629.                                     ms_Images.SetAt (mii.wID, imgDesc);
  630.                                 }
  631.                                 break;
  632.                             }
  633.                         }
  634.                     }
  635.                 }
  636.             }
  637.         }
  638.         if ( !bMenuBar )
  639.         {
  640.             CMenuItem mnuItem (hMenu, i);
  641.             int       nWidth = mnuItem.GetCaptionWidth (&cDC);
  643.             if ( nWidth > nCaptionLength )
  644.             {
  645.                 nCaptionLength = nWidth;
  646.             }
  647.             nWidth = mnuItem.GetShortCutWidth (&cDC);
  649.             if ( nWidth > nShortCutLength )
  650.             {
  651.                 nShortCutLength = nWidth;
  652.             }
  653.         }
  654.     }
  655.     if ( !bMenuBar )
  656.     {
  657.         for ( int j = 0; j < nItemCount; j++ )
  658.         {
  659.             mii.fMask = MIIM_TYPE;
  660.             ::GetMenuItemInfo (hMenu, j, true, &mii);
  662.             if ( (mii.fType & MFT_SEPARATOR) == 0 )
  663.             {
  664.                 mii.dwItemData = MAKELONG(MAKEWORD(nHeight, nShortCutLength), nCaptionLength);
  665.             }
  666.             else
  667.             {
  668.                 mii.dwItemData = nSepHeight;
  669.             }
  670.             mii.fMask = MIIM_DATA;
  671.             ::SetMenuItemInfo (hMenu, j, true, &mii);
  672.         }
  673.     }
  674. }
  676. ///////////////////////////////////////////////////////////////////////////////
  677. bool CMenuXP::IsOwnerDrawn (HMENU hMenu)
  678. {
  679.     MENUITEMINFO mii = { sizeof MENUITEMINFO, MIIM_TYPE };
  681.     ::GetMenuItemInfo (hMenu, 0, true, &mii);
  683.     return (mii.fType & MFT_OWNERDRAW) != 0;
  684. }
  686. ///////////////////////////////////////////////////////////////////////////////
  687. void CMenuXP::SetMRUMenuBarItem (RECT& rc)
  688. {
  689.     CMenuItem::ms_rcMRUMenuBarItem = rc;
  690. }
  692. ///////////////////////////////////////////////////////////////////////////////
  693. void CMenuXP::SetMenuItemImage (UINT nID, HIMAGELIST hImgList, int nIndex)
  694. {
  695.     CImgDesc imgDesc (hImgList, nIndex);
  696.     ms_Images.SetAt (nID, imgDesc);
  697. }
  699. ///////////////////////////////////////////////////////////////////////////////
  700. void CMenuXP::OnMeasureItem (MEASUREITEMSTRUCT* pMeasureItemStruct)
  701. {
  702.     if ( pMeasureItemStruct->CtlType == ODT_MENU )
  703.     {
  704.         pMeasureItemStruct->itemHeight = LOBYTE(LOWORD(pMeasureItemStruct->itemData));
  706.         if ( pMeasureItemStruct->itemHeight == 0 )
  707.         {
  708.             // This is a menubar item
  709.             pMeasureItemStruct->itemWidth = HIWORD(pMeasureItemStruct->itemData) + TEXTPADDING_MNUBR;
  710.         }
  711.         else
  712.         {
  713.             pMeasureItemStruct->itemWidth = IMGWIDTH + IMGPADDING + HIWORD(pMeasureItemStruct->itemData) + TEXTPADDING + HIBYTE(LOWORD(pMeasureItemStruct->itemData)) + TEXTPADDING + 4;
  714.         }
  715.     }
  716. }
  718. ///////////////////////////////////////////////////////////////////////////////
  719. bool CMenuXP::OnDrawItem (DRAWITEMSTRUCT* pDrawItemStruct, HWND hWnd)
  720. {
  721.     if ( pDrawItemStruct->CtlType != ODT_MENU )
  722.     {
  723.         return false;
  724.     }
  725.     ASSERT (pDrawItemStruct->CtlType == ODT_MENU);
  726.     CBufferDC cDC (pDrawItemStruct->hDC, pDrawItemStruct->rcItem);
  727.     CMenuItem item ((HMENU)pDrawItemStruct->hwndItem, pDrawItemStruct->itemID, false);
  728.     CFontDC font (cDC, DEFAULT_GUI_FONT);
  730.     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) )
  731.     {
  732.         CRect rc;
  734.         ::GetMenuItemRect (hWnd, (HMENU)pDrawItemStruct->hwndItem, 0, rc);
  735.         ::ClientToScreen (hWnd, CMenuItem::ms_rcMRUMenuBarItem);
  736.         CMenuItem::ms_rcMRUMenuBarItem.top = rc.top;
  737.         CMenuItem::ms_rcMRUMenuBarItem.bottom = rc.bottom;
  738.         
  739.         if ( CWnd::FromHandle (hWnd)->IsKindOf (RUNTIME_CLASS(CDialog)) )
  740.         {
  741.             CMenuItem::ms_rcMRUMenuBarItem.OffsetRect (1, 0);
  742.         }
  743.     }
  744.     CMenuItem::ms_nCheck++;
  745.     
  746.     return true;
  747. }
  749. ///////////////////////////////////////////////////////////////////////////////
  750. LRESULT CMenuXP::OnMenuChar (HMENU hMenu, UINT nChar, UINT nFlags)
  751. {
  752.     if ( (nFlags & (MF_POPUP|MF_SYSMENU)) == MF_POPUP || nFlags == 0 )
  753.     {
  754.         int nItemCount = ::GetMenuItemCount (hMenu);
  756.         nChar = toupper (nChar);
  758.         for ( int i = 0; i < nItemCount; i++ )
  759.         {
  760.             CMenuItem mnuItem (hMenu, i);
  761.             CString sCaption;
  763.             mnuItem.GetCaption (sCaption);
  764.             sCaption.MakeUpper();
  766.             for ( int nPos = sCaption.GetLength()-2; nPos >= 0; nPos-- )
  767.             {
  768.                 if ( sCaption[nPos] == '&' && (UINT)toupper (sCaption[nPos+1]) == nChar &&
  769.                      (nPos == 0 || sCaption[nPos-1] != '&') )
  770.                 {
  771.                     return MAKELRESULT(i,2);
  772.                 }
  773.             }
  774.         }
  775.     }
  776.     return 0;
  777. }
  780. ///////////////////////////////////////////////////////////////////////////////
  781. ///////////////////////////////////////////////////////////////////////////////
  782. // CWndMenuXP class : management of the window used by system to display popup menus
  783. //
  784. class CWndMenuXP
  785. {
  786. public:
  787.     CWndMenuXP (HWND hWnd);
  788.    ~CWndMenuXP ();
  790. public:
  791.     static CWndMenuXP* FromHandle (HWND hWnd, bool bPermanent = true);
  793. protected:
  794.     void OnWindowPosChanging (WINDOWPOS* pWP);
  795.     void OnEraseBkgnd ();
  796.     void OnPrint (CDC* pDC, bool bOwnerDrawnItems);
  797.     void OnNcPaint ();
  798.     void OnShowWindow (bool bShow);
  799.     void OnNcDestroy ();
  801. private:
  802.     static LRESULT CALLBACK WindowsHook (int code, WPARAM wParam, LPARAM lParam);
  803.     static LRESULT CALLBACK SubClassMenuProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  805. protected:
  806.     HWND m_hWnd;
  807.     CRect m_rcMenu;
  808.     CPoint m_ptMenu;
  809.     CBitmap m_bmpBkGnd;
  811.     static CMap <HWND, HWND, CWndMenuXP*, CWndMenuXP*> ms_WndMenuMap;
  812.     static DWORD ms_dwRefCount;
  813.     static HHOOK ms_hHookOldMenuCbtFilter;
  815. friend class CMenuXP;
  816. };
  818. ///////////////////////////////////////////////////////////////////////////////
  819. void CMenuXP::InitializeHook ()
  820. {
  821.     CWndMenuXP::ms_dwRefCount++;
  823.     if ( CWndMenuXP::ms_hHookOldMenuCbtFilter == NULL )
  824.     {
  825.         CWndMenuXP::ms_hHookOldMenuCbtFilter = ::SetWindowsHookEx (WH_CALLWNDPROC, CWndMenuXP::WindowsHook, AfxGetApp()->m_hInstance, ::GetCurrentThreadId());
  826.     }
  827. }
  829. ///////////////////////////////////////////////////////////////////////////////
  830. void CMenuXP::UninitializeHook ()
  831. {
  832.     if ( CWndMenuXP::ms_dwRefCount == 0 )
  833.     {
  834.         return;
  835.     }
  836.     if ( --CWndMenuXP::ms_dwRefCount == 0 )
  837.     {
  838.         POSITION pos = CWndMenuXP::ms_WndMenuMap.GetStartPosition();
  840.         while ( pos != NULL )
  841.         {
  842.             HWND hKey;
  843.             CWndMenuXP* pVal;
  845.             CWndMenuXP::ms_WndMenuMap.GetNextAssoc (pos, hKey, pVal);
  846.             delete pVal;
  847.         }
  848.         CWndMenuXP::ms_WndMenuMap.RemoveAll();
  850.         if ( CWndMenuXP::ms_hHookOldMenuCbtFilter != NULL )
  851.         {
  852.             ::UnhookWindowsHookEx (CWndMenuXP::ms_hHookOldMenuCbtFilter);
  853.         }
  854.     }
  855. }
  857. ///////////////////////////////////////////////////////////////////////////////
  858. CMap <HWND, HWND, CWndMenuXP*, CWndMenuXP*> CWndMenuXP::ms_WndMenuMap;
  859. DWORD CWndMenuXP::ms_dwRefCount = 0;
  860. HHOOK CWndMenuXP::ms_hHookOldMenuCbtFilter = NULL;
  862. ///////////////////////////////////////////////////////////////////////////////
  863. CWndMenuXP::CWndMenuXP (HWND hWnd)
  864.     : m_hWnd (hWnd), m_rcMenu (0, 0, 0, 0), m_ptMenu (-0xFFFF, -0xFFFF)
  865. {
  866. }
  868. ///////////////////////////////////////////////////////////////////////////////
  869. CWndMenuXP::~CWndMenuXP ()
  870. {
  871.     WNDPROC oldWndProc = (WNDPROC)::GetProp (m_hWnd, _WndPropName_OldProc);
  873.     if ( oldWndProc != NULL )
  874.     {
  875.         ::SetWindowLong (m_hWnd, GWL_WNDPROC, (DWORD)(DWORD_PTR)oldWndProc);
  876.         ::RemoveProp (m_hWnd, _WndPropName_OldProc);
  877.     }
  878.     ms_WndMenuMap.RemoveKey (m_hWnd);
  879. }
  881. ///////////////////////////////////////////////////////////////////////////////
  882. CWndMenuXP* CWndMenuXP::FromHandle (HWND hWnd, bool bPermanent)
  883. {
  884.     CWndMenuXP* pWnd = NULL;
  886.     if ( ms_WndMenuMap.Lookup (hWnd, pWnd) )
  887.     {
  888.         return pWnd;
  889.     }
  890.     if ( bPermanent )
  891.     {
  892.         return NULL;
  893.     }
  894.     pWnd = new CWndMenuXP (hWnd);
  895.     ms_WndMenuMap.SetAt (hWnd, pWnd);
  897.     return pWnd;
  898. }
  900. ///////////////////////////////////////////////////////////////////////////////
  901. void CWndMenuXP::OnWindowPosChanging (WINDOWPOS* pWP)
  902. {
  903.     if ( GetWinVersion() < wvWinXP )
  904.     {
  905.         pWP->cx += SM_CXSHADOW;
  906.         pWP->cy += SM_CXSHADOW;
  907.     }
  908.     pWP->y--;
  909.     m_ptMenu.x = pWP->x;
  910.     m_ptMenu.y = pWP->y;
  911. }
  913. ///////////////////////////////////////////////////////////////////////////////
  914. void CWndMenuXP::OnEraseBkgnd ()
  915. {
  916.     if ( !IsWindowVisible (m_hWnd) )
  917.     {
  918.         CClientRect rc (m_hWnd);
  920.         if ( m_bmpBkGnd.m_hObject != NULL )
  921.         {
  922.             m_bmpBkGnd.DeleteObject();
  923.         }
  924.         m_bmpBkGnd.Attach (GetScreenBitmap (CRect (m_ptMenu.x, m_ptMenu.y, rc.right+m_ptMenu.x+10,
  925.                                                    rc.bottom+m_ptMenu.y+10)));
  926.     }
  927. }
  929. ///////////////////////////////////////////////////////////////////////////////
  930. void DrawShadow (HDC hDCIn, HDC hDCOut, RECT& rc)
  931. {
  932.     for ( int x = 0; x < rc.right-1; x++ )
  933.     {
  934.         int nEnd = ( x > rc.right-SM_CXSHADOW*2 ) ? rc.right-SM_CXSHADOW-x : SM_CXSHADOW;
  936.         for ( int y = ( x < 2 ) ? 2-x : x > rc.right-SM_CXSHADOW-3 ? x-rc.right+SM_CXSHADOW+3 : 0; y < nEnd; y++ )
  937.         {
  938.             int nMakeSpec = 78+(3-(x==0?0:(x==1?(y<2?0:1):(x==2?(y<2?y:2):y))))*5;
  939.             COLORREF cr = GetPixel (hDCIn, x+SM_CXSHADOW, rc.bottom-y-1);
  940.             COLORREF cr2 = RGB(((nMakeSpec * int(GetRValue(cr))) / 100),
  941.                    ((nMakeSpec * int(GetGValue(cr))) / 100),
  942.                    ((nMakeSpec * int(GetBValue(cr))) / 100));
  943. SetPixel (hDCOut, x+SM_CXSHADOW, rc.bottom-y-1, cr2);
  944.         }
  945.     }
  946.     for ( x = 0; x < SM_CXSHADOW; x++ )
  947.     {
  948.         for ( int y = ( x < 2 ) ? 2-x : 0; y < rc.bottom-x-SM_CXSHADOW-((x>0)?1:2); y++ )
  949.         {
  950.             int nMakeSpec = 78+(3-(y==0?0:(y==1?(x<2?0:1):(y==2?(x<2?x:2):x))))*5;
  951.             COLORREF cr = GetPixel (hDCIn, rc.right-x-1, y+SM_CXSHADOW);
  952.             COLORREF cr2 = RGB(((nMakeSpec * int(GetRValue(cr))) / 100),
  953.                    ((nMakeSpec * int(GetGValue(cr))) / 100),
  954.                    ((nMakeSpec * int(GetBValue(cr))) / 100));
  955. SetPixel (hDCOut, rc.right-x-1, y+SM_CXSHADOW, cr2);
  956.         }
  957.     }
  958. }
  960. ///////////////////////////////////////////////////////////////////////////////
  961. void CWndMenuXP::OnPrint (CDC* pDC, bool bOwnerDrawnItems)
  962. {
  963.     CWindowRect rc (m_hWnd);
  964.     CBrushDC br (pDC->m_hDC);
  965.     CPenDC pen (pDC->m_hDC, ::GetSysColor (COLOR_3DDKSHADOW));
  967.     rc.OffsetRect (-rc.TopLeft());
  968.     m_rcMenu = rc;
  970.     if ( GetWinVersion() < wvWinXP )
  971.     {
  972.         rc.right -= SM_CXSHADOW;
  973.         rc.bottom -= SM_CXSHADOW;
  974.     }
  975.     pDC->Rectangle (rc);
  976.     pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +75, 0));
  977.     rc.DeflateRect (1, 1);
  978.     pDC->Rectangle (rc);
  979.     rc.DeflateRect (1, 1);
  980.     pDC->Rectangle (rc);
  982.     if ( bOwnerDrawnItems && !CMenuItem::ms_rcMRUMenuBarItem.IsRectEmpty() &&
  983.          CMenuItem::ms_rcMRUMenuBarItem.bottom == m_ptMenu.y+1 )
  984.     {
  985.         pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  986.         pDC->MoveTo (CMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x-3, 0);
  987.         pDC->LineTo (CMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x+CMenuItem::ms_rcMRUMenuBarItem.Width()-5, 0);
  988.     }
  989.     if ( GetWinVersion() < wvWinXP )
  990.     {
  991.         rc.right += SM_CXSHADOW+2;
  992.         rc.bottom += SM_CXSHADOW+2;
  994.         CDC cMemDC;
  995.         cMemDC.CreateCompatibleDC (pDC);
  996.         HGDIOBJ hOldBitmap = ::SelectObject (cMemDC.m_hDC, m_bmpBkGnd);
  997.         pDC->BitBlt (0, rc.bottom-SM_CXSHADOW, SM_CXSHADOW*2, SM_CXSHADOW, &cMemDC, 0, rc.bottom-SM_CXSHADOW, SRCCOPY);
  998.         pDC->BitBlt (rc.right-SM_CXSHADOW, rc.bottom-SM_CXSHADOW, SM_CXSHADOW, SM_CXSHADOW, &cMemDC, rc.right-SM_CXSHADOW, rc.bottom-SM_CXSHADOW, SRCCOPY);
  999.         pDC->BitBlt (rc.right-SM_CXSHADOW, 0, SM_CXSHADOW, SM_CXSHADOW*2, &cMemDC, rc.right-SM_CXSHADOW, 0, SRCCOPY);
  1000.         DrawShadow (cMemDC.m_hDC, pDC->m_hDC, rc);
  1001.         ::SelectObject (cMemDC.m_hDC, hOldBitmap);
  1002.     }
  1003. }
  1005. ///////////////////////////////////////////////////////////////////////////////
  1006. void CWndMenuXP::OnNcPaint ()
  1007. {
  1008.     CWindowDC cDC (CWnd::FromHandle (m_hWnd));
  1009.     CDC* pDC = &cDC;
  1010.     CWindowRect rc (m_hWnd);
  1012.     m_ptMenu.x = rc.left;
  1013.     m_ptMenu.y = rc.top;
  1014.     rc.OffsetRect (-rc.TopLeft());
  1016.     if ( rc != m_rcMenu )
  1017.     {
  1018.         m_rcMenu = rc;
  1020.         CBrushDC br (pDC->m_hDC);
  1021.         CPenDC pen (pDC->m_hDC, ::GetSysColor (COLOR_3DDKSHADOW));
  1023.         if ( GetWinVersion() < wvWinXP )
  1024.         {
  1025.             rc.right -= SM_CXSHADOW;
  1026.             rc.bottom -= SM_CXSHADOW;
  1027.         }
  1028.         pDC->Rectangle (rc);
  1029.         pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +75, 0));
  1030.         rc.DeflateRect (1, 1);
  1031.         pDC->Rectangle (rc);
  1032.         rc.DeflateRect (1, 1);
  1033.         pDC->Rectangle (rc);
  1035.         if ( !CMenuItem::ms_rcMRUMenuBarItem.IsRectEmpty() &&
  1036.              CMenuItem::ms_rcMRUMenuBarItem.bottom == m_ptMenu.y+1 )
  1037.         {
  1038.             pen.Color (HLS_TRANSFORM (::GetSysColor (COLOR_3DFACE), +20, 0));
  1039.             pDC->MoveTo (CMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x-3, 0);
  1040.             pDC->LineTo (CMenuItem::ms_rcMRUMenuBarItem.left-m_ptMenu.x+CMenuItem::ms_rcMRUMenuBarItem.Width()-5, 0);
  1041.         }
  1042.         if ( GetWinVersion() < wvWinXP )
  1043.         {
  1044.             rc.right += SM_CXSHADOW+2;
  1045.             rc.bottom += SM_CXSHADOW+2;
  1047.             DrawShadow (pDC->m_hDC, pDC->m_hDC, rc);
  1048.         }
  1049.     }
  1050. }
  1052. ///////////////////////////////////////////////////////////////////////////////
  1053. void CWndMenuXP::OnShowWindow (bool bShow)
  1054. {
  1055.     if ( !bShow )
  1056.     {
  1057.         delete this;
  1058.     }
  1059. }
  1061. ///////////////////////////////////////////////////////////////////////////////
  1062. void CWndMenuXP::OnNcDestroy ()
  1063. {
  1064.     delete this;
  1065. }
  1067. ///////////////////////////////////////////////////////////////////////////////
  1068. LRESULT CALLBACK CWndMenuXP::WindowsHook (int code, WPARAM wParam, LPARAM lParam)
  1069. {
  1070.     CWPSTRUCT* pStruct = (CWPSTRUCT*)lParam;
  1072.     // Not a real loop (just for 'break' branchment)
  1073.     while ( code == HC_ACTION )
  1074.     {
  1075.         HWND hWnd = pStruct->hwnd;
  1077.         // Normal and special handling for menu 0x10012
  1078.         if ( pStruct->message != WM_CREATE && pStruct->message != 0x01E2 )
  1079.         {
  1080.             break;
  1081.         }
  1082.         CWnd* pFrame = CWnd::GetForegroundWindow();
  1084.         if ( pFrame == NULL || !CMenuXP::GetXPLookNFeel (pFrame) )
  1085.         {
  1086.             break;
  1087.         }
  1088.         TCHAR sClassName[10];
  1089.         int Count = ::GetClassName (hWnd, sClassName, lengthof(sClassName));
  1091.         // Check for the menu-class
  1092.         if ( Count != 6 || _tcscmp (sClassName, _T("#32768")) != 0 )
  1093.         {
  1094.             break;
  1095.         }
  1096.         VERIFY(CWndMenuXP::FromHandle (pStruct->hwnd, false) != NULL);
  1098.         if ( ::GetProp (pStruct->hwnd, _WndPropName_OldProc) != NULL )
  1099.         {
  1100.             // Already subclassed
  1101.             break;
  1102.         }
  1103.         // Subclass the window
  1104.         WNDPROC oldWndProc = (WNDPROC)(LONG_PTR)::GetWindowLong (pStruct->hwnd, GWL_WNDPROC);
  1106.         if ( oldWndProc == NULL )
  1107.         {
  1108.             break;
  1109.         }
  1110.         ASSERT(oldWndProc != SubClassMenuProc);
  1112.         if ( !SetProp (pStruct->hwnd, _WndPropName_OldProc, oldWndProc) )
  1113.         {
  1114.             break;
  1115.         }
  1116.         if ( !SetWindowLong (pStruct->hwnd, GWL_WNDPROC,(DWORD)(DWORD_PTR)SubClassMenuProc) )
  1117.         {
  1118.             ::RemoveProp (pStruct->hwnd, _WndPropName_OldProc);
  1119.             break;
  1120.         }
  1121.         // Success !
  1122.         break;
  1123.     }
  1124.     return CallNextHookEx (CWndMenuXP::ms_hHookOldMenuCbtFilter, code, wParam, lParam);
  1125. }
  1127. ///////////////////////////////////////////////////////////////////////////////
  1128. LRESULT CALLBACK CWndMenuXP::SubClassMenuProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  1129. {
  1130.     WNDPROC oldWndProc = (WNDPROC)::GetProp (hWnd, _WndPropName_OldProc);
  1131.     CWndMenuXP* pWnd = NULL;
  1133.     switch ( uMsg )
  1134.     {
  1135.     case WM_NCCALCSIZE:
  1136.         {
  1137.             LRESULT lResult = CallWindowProc (oldWndProc, hWnd, uMsg, wParam, lParam);
  1139.             if ( GetWinVersion() < wvWinXP )
  1140.             {
  1141.                 NCCALCSIZE_PARAMS* lpncsp = (NCCALCSIZE_PARAMS*)lParam;
  1143.                 lpncsp->rgrc[0].right -= SM_CXSHADOW;
  1144.                 lpncsp->rgrc[0].bottom -= SM_CXSHADOW;
  1145.             }
  1146.             return lResult;
  1147.         }
  1149.     case WM_WINDOWPOSCHANGING:
  1150.         if ( (pWnd=CWndMenuXP::FromHandle (hWnd)) != NULL )
  1151.         {
  1152.             pWnd->OnWindowPosChanging ((LPWINDOWPOS)lParam);
  1153.         }
  1154.         break;
  1156.     case WM_ERASEBKGND:
  1157.         if ( (pWnd=CWndMenuXP::FromHandle (hWnd)) != NULL )
  1158.         {
  1159.             pWnd->OnEraseBkgnd();
  1160.         }
  1161.         break;
  1163.     case WM_PRINT:
  1164.         {
  1165.             BYTE nCheck = CMenuItem::ms_nCheck;
  1166.             LRESULT lResult = CallWindowProc (oldWndProc, hWnd, uMsg, wParam, lParam);
  1167.             bool bOwnerDrawnItems = nCheck != CMenuItem::ms_nCheck;
  1169.             if ( (pWnd=CWndMenuXP::FromHandle (hWnd)) != NULL )
  1170.             {
  1171.                 pWnd->OnPrint (CDC::FromHandle ((HDC)wParam), bOwnerDrawnItems);
  1172.             }
  1173.             return lResult;
  1174.         }
  1176.     case WM_NCPAINT:
  1177.         if ( (pWnd=CWndMenuXP::FromHandle (hWnd)) != NULL )
  1178.         {
  1179.             pWnd->OnNcPaint();
  1180.             return 0;
  1181.         }
  1182.         break;
  1184.     case WM_SHOWWINDOW:
  1185.         if ( (pWnd=CWndMenuXP::FromHandle (hWnd)) != NULL )
  1186.         {
  1187.             pWnd->OnShowWindow (wParam != 0);
  1188.         }
  1189.         break;
  1191.     case WM_NCDESTROY:
  1192.         if ( (pWnd=CWndMenuXP::FromHandle (hWnd)) != NULL )
  1193.         {
  1194.             pWnd->OnNcDestroy();
  1195.         }
  1196.         break;
  1197.     }
  1198.     return CallWindowProc (oldWndProc, hWnd, uMsg, wParam, lParam);
  1199. }