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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
NewMenu.cpp
资源名称：sourcecode.zip　[点击查看]
上传用户：wlkj888
上传日期：2022-08-01
资源大小：806k
文件大小：121k
源码类别：

对话框与窗口

开发平台：

Visual C++

NewMenu.cpp：源码内容
  1. /****************************************************************************
  2.  * *  
  3.  * GuiToolKit   *
  4.  *  (MFC extension) *  
  5.  * Created by Francisco Campos G. www.beyondata.com fcampos@beyondata.com *
  6.  *--------------------------------------------------------------------------*    
  7.  * *
  8.  * This program is free software;so you are free to use it any of your *
  9.  * applications (Freeware, Shareware, Commercial),but leave this header *
  10.  * intact. *
  11.  * *
  12.  * These files are provided "as is" without warranty of any kind. *
  13.  * *
  14.  *        GuiToolKit is forever FREE CODE !!!!! *
  15.  * *
  16.  *--------------------------------------------------------------------------*
  17.  * Bug Fixes and improvements : (Add your name) *
  18.  * -Francisco Campos *
  19.  * *
  20.  ****************************************************************************/
  22. //------------------------------------------------------------------------------
  23. // File    : NewMenu.cpp 
  24. // Version : 1.0
  25. // Date    : Mai 2002
  26. // Author  : Bruno Podetti
  27. // Email   : Podetti@gmx.net
  28. // Systems : VC6.0 and VC7.0 (Run under (Window 98/ME), Windows Nt 2000/XP)
  29. //
  30. // Bug Fixes and portions of code from previous version supplied by:
  31. //
  32. // Brent Corkum, Ben Ashley, Girish Bharadwaj, Jean-Edouard Lachand-Robert,
  33. // Robert Edward Caldecott, Kenny Goers, Leonardo Zide, Stefan Kuhr, 
  34. // Reiner Jung, Martin Vladic, Kim Yoo Chul, Oz Solomonovich, Tongzhe Cui, 
  35. // Stephane Clog, Warren Stevens, Damir Valiulin
  36. // 
  37. // You are free to use/modify this code but leave this header intact.
  38. // This class is public domain so you are free to use it any of your 
  39. // applications (Freeware, Shareware, Commercial). 
  40. // All I ask is that you let me know so that if you have a real winner I can
  41. // brag to my buddies that some of my code is in your app. I also wouldn't 
  42. // mind if you sent me a copy of your application since I like to play with
  43. // new stuff.
  44. //------------------------------------------------------------------------------
  46. #include "stdafx.h"        // Standard windows header file
  47. #include "NewMenu.h"       // CNewMenu class declaration
  48. #include "GuiDrawLayer.h"
  49. #include "MenuBar.h"
  50. //#define _TRACE_MENU_
  52. #ifdef _TRACE_MENU_
  53. #include "MyTrace.h"
  54. #endif
  56. #ifdef _DEBUG
  57. #define new DEBUG_NEW
  58. #undef THIS_FILE
  59. static char THIS_FILE[] = __FILE__;
  60. #endif
  62. #ifndef ARRAY_SIZE
  63. #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
  64. #endif
  66. #ifndef IS_INTRESOURCE
  67. #define IS_INTRESOURCE(hh) (HIWORD(hh)==NULL)
  68. #endif 
  70. #define GAP 2
  72. #ifndef ODS_HOTLIGHT
  73. #define ODS_HOTLIGHT        0x0040
  74. #endif
  76. #ifndef ODS_INACTIVE
  77. #define ODS_INACTIVE        0x0080
  78. #endif
  80. #ifndef COLOR_MENUBAR
  81. #define COLOR_MENUBAR       30
  82. #endif
  84. #ifndef SPI_GETDROPSHADOW
  85. #define SPI_GETDROPSHADOW   0x1024
  86. #endif
  88. #ifndef SPI_GETFLATMENU
  89. #define SPI_GETFLATMENU     0x1022
  90. #endif
  91. extern int gbintHorz; //Horz=0, Vert=1
  92. extern CRect rcMenu; //CRect of button
  94. /////////////////////////////////////////////////////////////////////////////
  95. #include "GuiDrawLayer.h"
  96. // Helpers for casting
  97. __inline HMENU UIntToHMenu(const unsigned int ui )
  98. {
  99.   return( (HMENU)(UINT_PTR)ui );
  100. }
  102. __inline HMENU HWndToHmenu(const HWND hwnd )
  103. {
  104.   return( (HMENU)hwnd );
  105. }
  107. __inline UINT HWndToUInt(const HWND hWnd )
  108. {
  109.   return( (UINT)(UINT_PTR) hWnd);
  110. }
  112. __inline HWND UIntToHWnd(const UINT hWnd )
  113. {
  114.   return( (HWND)(UINT_PTR) hWnd);
  115. }
  117. __inline UINT HMenuToUInt(const HMENU hMenu )
  118. {
  119.   return( (UINT)(UINT_PTR) hMenu);
  120. }
  122. //static CMenuBar* pBar=CNewMenu::m_pBar;
  123. CMenuButton* pb;
  124. static void ShowLastError()
  125. {
  126.   DWORD error = GetLastError();
  127.   if(error)
  128.   {
  129.     LPVOID lpMsgBuf=NULL;
  130.     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
  131.                   FORMAT_MESSAGE_FROM_SYSTEM | 
  132.                   FORMAT_MESSAGE_IGNORE_INSERTS,
  133.                   NULL,
  134.                   error,
  135.                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
  136.                   (LPTSTR) &lpMsgBuf,
  137.                   0,
  138.                   NULL );
  139.     if(lpMsgBuf)
  140.     {
  141.       // Display the string.
  142.       MessageBox( NULL, (LPCTSTR)lpMsgBuf, _T("Error"), MB_OK | MB_ICONINFORMATION );
  143.       // Free the buffer.
  144.       LocalFree( lpMsgBuf );
  145.     }
  146.     else
  147.     {
  148.       CString temp;
  149.       temp.Format(_T("Error message 0x%lx not found"),error);
  150.       // Display the string.
  151.       MessageBox( NULL,temp, _T("Error"), MB_OK | MB_ICONINFORMATION );
  152.     }
  153.   }
  154. }
  156. enum Win32Type
  157. {
  158.   Win32s,
  159.   WinNT3,
  160.   Win95,
  161.   Win98,
  162.   WinME,
  163.   WinNT4,
  164.   Win2000,
  165.   WinXP
  166. };
  168. Win32Type IsShellType()
  169. {
  170.   Win32Type  ShellType;
  171.   DWORD winVer;
  172.   OSVERSIONINFO *osvi;
  174.   winVer=GetVersion();
  175.   if(winVer<0x80000000)
  176.   {/*NT */
  177.     ShellType=WinNT3;
  178.     osvi= (OSVERSIONINFO *)malloc(sizeof(OSVERSIONINFO));
  179.     if (osvi!=NULL)
  180.     {
  181.       ZeroMemory(osvi,sizeof(OSVERSIONINFO));
  182.       osvi->dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
  183.       if(!GetVersionEx(osvi))
  184.       {
  185.         ShowLastError();
  186.       }
  187.       if(osvi->dwMajorVersion==4L)
  188.       {
  189.         ShellType=WinNT4;
  190.       }
  191.       else if(osvi->dwMajorVersion==5L && osvi->dwMinorVersion==0L)
  192.       {
  193.         ShellType=Win2000;
  194.       }
  195.       else if(osvi->dwMajorVersion==5L && osvi->dwMinorVersion==1L)
  196.       {
  197.         ShellType=WinXP;
  198.       }
  199.       free(osvi);
  200.     }
  201.   }
  202.   else if (LOBYTE(LOWORD(winVer))<4)
  203.   {
  204.     ShellType=Win32s;
  205.   }
  206.   else
  207.   {
  208.     ShellType=Win95;
  209.     osvi= (OSVERSIONINFO *)malloc(sizeof(OSVERSIONINFO));
  210.     if (osvi!=NULL)
  211.     {
  212.       memset(osvi,0,sizeof(OSVERSIONINFO));
  213.       osvi->dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
  214.       GetVersionEx(osvi);
  215.       if(osvi->dwMajorVersion==4L&&osvi->dwMinorVersion==10L)
  216.       {
  217.         ShellType=Win98;
  218.       }
  219.       else if(osvi->dwMajorVersion==4L&&osvi->dwMinorVersion==90L)
  220.       {
  221.         ShellType=WinME;
  222.       }
  223.       free(osvi);
  224.     }
  225.   }
  226.   return ShellType;
  227. }
  229. BOOL IsShadowEnabled()
  230. {
  231.   BOOL bEnabled=FALSE;
  232.   if(SystemParametersInfo(SPI_GETDROPSHADOW,0,&bEnabled,0))
  233.   {
  234.     return bEnabled;
  235.   }
  236.   return FALSE;
  237. }
  239. COLORREF DarkenColorXP(COLORREF ColA)
  240. {
  241.   return RGB( MulDiv(GetRValue(ColA),7,10),
  242.               MulDiv(GetGValue(ColA),7,10),
  243.               MulDiv(GetBValue(ColA)+55,7,10));
  244. }
  246. // Function splits a color into its RGB components and
  247. // transforms the color using a scale 0..255
  248. COLORREF DarkenColor( long lScale, COLORREF lColor)
  249. { 
  250.   long R = MulDiv(GetRValue(lColor),(255-lScale),255);
  251.   long G = MulDiv(GetGValue(lColor),(255-lScale),255);
  252.   long B = MulDiv(GetBValue(lColor),(255-lScale),255);
  254.   return RGB(R, G, B); 
  255. }
  257. COLORREF MixedColor(COLORREF ColA,COLORREF ColB)
  258. {
  259.   // ( 86a + 14b ) / 100
  260.   int Red   = MulDiv(86,GetRValue(ColA),100) + MulDiv(14,GetRValue(ColB),100);
  261.   int Green = MulDiv(86,GetGValue(ColA),100) + MulDiv(14,GetGValue(ColB),100);
  262.   int Blue  = MulDiv(86,GetBValue(ColA),100) + MulDiv(14,GetBValue(ColB),100);
  264.   return RGB( Red,Green,Blue);
  265. }
  267. COLORREF MidColor(COLORREF ColA,COLORREF ColB)
  268. { 
  269.   // (7a + 3b)/10
  270.   int Red   = MulDiv(7,GetRValue(ColA),10) + MulDiv(3,GetRValue(ColB),10);
  271.   int Green = MulDiv(7,GetGValue(ColA),10) + MulDiv(3,GetGValue(ColB),10);
  272.   int Blue  = MulDiv(7,GetBValue(ColA),10) + MulDiv(3,GetBValue(ColB),10);
  274.   return RGB( Red,Green,Blue);
  275. }
  277. // used for function gradientfill.
  278. //#pragma comment(lib,"Msimg32.lib")
  280. void DrawGradient(CDC* pDC,CRect& Rect,
  281.                   COLORREF StartColor,COLORREF EndColor, 
  282.                   BOOL bHorizontal)
  283. {
  284.   /*TRIVERTEX vert[2] ;
  285.   GRADIENT_RECT gRect;
  287.   vert [0].y = Rect.top;
  288.   vert [0].x = Rect.left;
  290.   vert [0].Red    = COLOR16(COLOR16(GetRValue(StartColor))<<8);
  291.   vert [0].Green  = COLOR16(COLOR16(GetGValue(StartColor))<<8);
  292.   vert [0].Blue   = COLOR16(COLOR16(GetBValue(StartColor))<<8);
  293.   vert [0].Alpha  = 0x0000;
  295.   vert [1].y = Rect.bottom;
  296.   vert [1].x = Rect.right;
  298.   vert [1].Red    = COLOR16(COLOR16(GetRValue(EndColor))<<8);
  299.   vert [1].Green  = COLOR16(COLOR16(GetGValue(EndColor))<<8);
  300.   vert [1].Blue   = COLOR16(COLOR16(GetBValue(EndColor))<<8);
  301.   vert [1].Alpha  = 0x0000;
  303.   gRect.UpperLeft  = 0;
  304.   gRect.LowerRight = 1;
  306.   if(bHorizontal)
  307.     GradientFill(pDC->m_hDC,vert,2,&gRect,1,GRADIENT_FILL_RECT_H);
  308.   else
  309.     GradientFill(pDC->m_hDC,vert,2,&gRect,1,GRADIENT_FILL_RECT_V);*/
  310. }
  312. /////////////////////////////////////////////////////////////////////////////
  313. // CMenuTheme for drawing border and the rest
  315. typedef void (CNewMenu::*pItemMeasureFkt) (LPMEASUREITEMSTRUCT lpMIS, BOOL bIsMenubar);
  316. typedef void (CNewMenu::*pItemDrawFkt) (LPDRAWITEMSTRUCT lpDIS, BOOL bIsMenubar);
  317. typedef BOOL (CNewMenu::*pEraseBkgndFkt) (HWND hWnd, HDC hDC);
  319. typedef void (CMenuTheme::*pDrawMenuBorder)( HWND hWnd, HDC hDC, CPoint screen);
  321. class CMenuTheme
  322. {
  323. public:
  324.   CMenuTheme();
  326.   CMenuTheme(DWORD dwThemeId, 
  327.              pItemMeasureFkt pMeasureItem,
  328.              pItemDrawFkt pDrawItem,
  329.              pItemDrawFkt pDrawTitle,
  330.              DWORD dwFlags=0);
  332.   virtual ~CMenuTheme();
  333.   virtual BOOL OnInitWnd(HWND hWnd);
  334.   virtual BOOL OnUnInitWnd(HWND hWnd);
  336.   virtual BOOL DoDrawBorder();
  338.   virtual BOOL OnDrawBorder(HWND hWnd, HDC hDC);
  339.   virtual BOOL OnEraseBkgnd(HWND hWnd, HDC hDC);
  340.   virtual BOOL OnNcCalcSize(HWND hWnd, NCCALCSIZE_PARAMS* pCalc);
  341.   virtual BOOL OnWindowPosChanging(HWND hWnd, LPWINDOWPOS pPos);
  343.   void DrawShade( HWND hWnd, HDC hDC, CPoint screen);
  344.   void DrawSmalBorder( HWND hWnd, HDC hDC);
  346. public:
  347.   DWORD m_dwThemeId;
  348.   DWORD m_dwFlags;
  350.   pItemMeasureFkt m_pMeasureItem;
  351.   pItemDrawFkt m_pDrawItem;
  352.   pItemDrawFkt m_pDrawTitle;
  354.   CSize m_BorderTopLeft;
  355.   CSize m_BorderBottomRight;
  356. };
  358. /////////////////////////////////////////////////////////////////////////////
  359. // CMenuThemeXP for drawing border and the rest
  361. class CMenuThemeXP :public CMenuTheme
  362. {
  363. public:
  364.   CMenuThemeXP(DWORD dwThemeId, 
  365.                 pItemMeasureFkt pMeasureItem,
  366.                 pItemDrawFkt pDrawItem,
  367.                 pItemDrawFkt pDrawTitle,
  368.                 DWORD dwFlags=0);
  370.   virtual BOOL OnDrawBorder(HWND hWnd, HDC hDC);
  371.   virtual BOOL OnEraseBkgnd(HWND hWnd, HDC hDC);
  372.   
  373. };
  375. /////////////////////////////////////////////////////////////////////////////
  376. // CNewMenuHook important class for subclassing menus!
  378. class CNewMenuHook
  379. {
  380. public:
  382.   class CMenuHookData 
  383.   {
  384.   public:
  385.     CMenuHookData(HWND hWnd,BOOL bSpecialWnd) 
  386.       : m_dwData(bSpecialWnd),m_bDrawBorder(TRUE),m_Point(0,0)
  387.     {
  388.       // Safe actual menu
  389.       m_hMenu = CNewMenuHook::m_hLastMenu;
  390.       // Reset for the next menu
  391.       CNewMenuHook::m_hLastMenu = NULL;
  393.       // Save actual border setting etc.
  394.       m_dwStyle = GetWindowLong(hWnd, GWL_STYLE) ;
  395.       m_dwExStyle = GetWindowLong(hWnd, GWL_EXSTYLE); 
  396.     }
  398.     DWORD m_dwStyle;
  399.     DWORD m_dwExStyle;
  401.     CPoint m_Point;
  402.     DWORD m_dwData;
  404.     BOOL m_bDrawBorder;
  405.     HMENU m_hMenu;
  406.   }; 
  408. public:
  409.   CNewMenuHook();
  410.   ~CNewMenuHook();
  412. public:
  413.   static CMenuHookData* GetMenuHookData(HWND hWnd);
  415.   static BOOL AddTheme(CMenuTheme*);
  416.   static CMenuTheme* RemoveTheme(DWORD dwThemeId);
  417.   static CMenuTheme* FindTheme(DWORD dwThemeId);
  419. private:
  420.   static LRESULT CALLBACK NewMenuHook(int code, WPARAM wParam, LPARAM lParam);
  421.   static BOOL CheckSubclassing(HWND hWnd,BOOL bSpecialWnd);
  422.   static LRESULT CALLBACK SubClassMenu(HWND hWnd,  UINT uMsg, WPARAM wParam,  LPARAM lParam );
  423.   static void UnsubClassMenu(HWND hWnd);
  424.  
  425.   static BOOL SubClassMenu2(HWND hWnd,  UINT uMsg, WPARAM wParam,  LPARAM lParam, DWORD* pResult);
  427. public:
  428.   static HMENU m_hLastMenu;
  429.   static DWORD m_dwMsgPos; 
  430.   
  431. private:
  432.   static HHOOK HookOldMenuCbtFilter;
  433.   // an map of actual opened Menu and submenu
  434.   static CTypedPtrMap<CMapPtrToPtr,HWND,CMenuHookData*> m_MenuHookData;
  435.   // Stores list of all defined Themes
  436.   static CTypedPtrList<CPtrList, CMenuTheme*>* m_pRegisteredThemesList; 
  437. };
  439. //////////////////////////////////////////////////////////////////////
  440. // Construction/Destruction
  441. //////////////////////////////////////////////////////////////////////
  443. IMPLEMENT_DYNAMIC(CNewMenuItemData,CObject); 
  445. CNewMenuItemData::CNewMenuItemData()
  446. : m_nTitleFlags(0),
  447.   m_nFlags(0),
  448.   m_nID(0),
  449.   m_nSyncFlag(0),
  450.   m_nxOffset(-1),
  451.   m_pBitmap(NULL),
  452.   m_nMenuIconNormal(-1),
  453.   m_pData(NULL)
  454. {
  455. }
  457. CNewMenuItemData::~CNewMenuItemData()
  458. {
  459.   if(m_pBitmap)
  460.   {
  461.     delete m_pBitmap;
  462.     m_pBitmap = NULL;
  463.   }
  464. }
  466. LPCTSTR CNewMenuItemData::GetString()
  467. {
  468.   return m_szMenuText;
  469. }
  470.  
  471. void CNewMenuItemData::SetString(LPCTSTR szMenuText)
  472. {
  473.   m_szMenuText = szMenuText;
  474. }
  476. #if defined(_DEBUG) || defined(_AFXDLL)
  477. // Diagnostic Support
  478. void CNewMenuItemData::AssertValid() const
  479. {
  480.   CObject::AssertValid();
  481. }
  483. void CNewMenuItemData::Dump(CDumpContext& dc) const
  484. {
  485.   CObject::Dump(dc);
  486.   dc << _T("MenuItem: ") << m_szMenuText << _T("n"); 
  487. }
  489. #endif
  491. //////////////////////////////////////////////////////////////////////
  492. // Construction/Destruction
  493. //////////////////////////////////////////////////////////////////////
  495. IMPLEMENT_DYNAMIC(CNewMenu,CMenu);
  497. // Stores list of all sub-menus
  498. CTypedPtrArray<CPtrArray, HMENU> CNewMenu::m_AllSubMenus;
  500. // actual selectet menu-draw mode
  501. CMenuTheme* CNewMenu::m_pActMenuDrawing = NULL;
  503. // one instance of the hook for menu-subclassing
  504. static CNewMenuHook MyNewMenuHookInstance;
  506. // color for drawing menubar
  507. int CNewMenu::cCOLOR_MENUBAR = COLOR_MENU;
  508. DWORD CNewMenu::m_StyleMenu= GUISTYLE_XP;
  510. // how the menu's are drawn in winXP
  511. BOOL CNewMenu::m_bSelectDisable=TRUE;
  513. static Win32Type g_Shell=IsShellType();
  515. CNewMenu::CNewMenu(HMENU hParent)
  516. : m_hParentMenu(hParent),
  517.   m_bIsPopupMenu(FALSE),
  518.   m_dwOpenMenu(NULL),
  519.   m_LastActiveMenuRect(0,0,0,0)
  520. {
  521.   // O.S. - no dynamic icons by default
  522.   m_bDynIcons = FALSE;
  523.   // Icon sizes default to 16 x 16
  524.   m_iconX = 16;
  525.   m_iconY = 15;
  526.   m_selectcheck = -1;
  527.   m_unselectcheck = -1;
  528.   checkmaps=NULL;
  529.   checkmapsshare=FALSE;
  530.   CMenuButton* m_pBar=NULL;
  531.   // set the color used for the transparent background in all bitmaps
  532.   m_bitmapBackground = CLR_DEFAULT;
  533. }
  535. CNewMenu::~CNewMenu()
  536. {
  537.   DestroyMenu();
  538. }
  540. void CNewMenu::SetLastMenuRect(HDC hDC, LPRECT pRect)
  541. {
  542.   if(!m_bIsPopupMenu)
  543.   {
  544.     HWND hWnd = WindowFromDC(hDC);
  545.     if(hWnd && pRect)
  546.     {
  547.       CRect Temp;
  548.       GetWindowRect(hWnd,Temp);
  549.       m_LastActiveMenuRect = *pRect;
  550.       m_LastActiveMenuRect.OffsetRect(Temp.TopLeft());
  551.     }
  552.   }
  553. }
  555. BOOL CNewMenu::IsNewShell ()
  556. {
  557.   return (g_Shell>=Win95);
  558. }
  560. BOOL CNewMenu::OnMeasureItem(const MSG* pMsg)
  561. {
  562.   if(pMsg->message==WM_MEASUREITEM)
  563.   {
  564.     LPMEASUREITEMSTRUCT lpMIS = (LPMEASUREITEMSTRUCT)pMsg->lParam;
  565.     if(lpMIS->CtlType==ODT_MENU)
  566.     {
  567.       CMenu* pMenu=NULL;
  568.       if(::IsMenu(UIntToHMenu(lpMIS->itemID)) )
  569.       {
  570.         pMenu = CMenu::FromHandlePermanent(UIntToHMenu(lpMIS->itemID) );
  571.       }
  572.       else
  573.       {
  574.         _AFX_THREAD_STATE* pThreadState = AfxGetThreadState ();
  575.         if (pThreadState->m_hTrackingWindow == pMsg->hwnd)
  576.         {
  577.           // start from popup
  578.           pMenu = FindPopupMenuFromIDData(pThreadState->m_hTrackingMenu,lpMIS->itemID,lpMIS->itemData);
  579.         }
  580.         if(pMenu==NULL)
  581.         {
  582.           // start from menubar
  583.           pMenu = FindPopupMenuFromIDData(::GetMenu(pMsg->hwnd),lpMIS->itemID,lpMIS->itemData);
  584.           if(pMenu==NULL)
  585.           {
  586.             // finaly start from system menu.
  587.             pMenu = FindPopupMenuFromIDData(::GetSystemMenu(pMsg->hwnd,FALSE),lpMIS->itemID,lpMIS->itemData);
  588.           }
  589.         }
  590.       }
  591.       if(pMenu!=NULL)
  592.       {
  593.         pMenu->MeasureItem(lpMIS);
  594.         return TRUE;
  595.       }
  596.     }
  597.   }
  598.   return FALSE;
  599. }
  601. CMenu* CNewMenu::FindPopupMenuFromID(HMENU hMenu, UINT nID)
  602. {
  603.   // check for a valid menu-handle
  604.   if ( ::IsMenu(hMenu))
  605.   {
  606.     CMenu *pMenu = CMenu::FromHandlePermanent(hMenu);
  607.     if(pMenu)
  608.     {
  609.       return FindPopupMenuFromID(pMenu,nID);
  610.     }
  611.   }
  612.   return NULL; 
  613. }
  615. CMenu* CNewMenu::FindPopupMenuFromIDData(HMENU hMenu, UINT nID, ULONG_PTR pData)
  616. {
  617.   // check for a valid menu-handle
  618.   if ( ::IsMenu(hMenu))
  619.   {
  620.     CMenu *pMenu = CMenu::FromHandlePermanent(hMenu);
  621.     if(pMenu)
  622.     {
  623.       return FindPopupMenuFromIDData(pMenu,nID,pData);
  624.     }
  625.   }
  626.   return NULL; 
  627. }
  629. CMenu* CNewMenu::FindPopupMenuFromIDData(CMenu* pMenu, UINT nID, ULONG_PTR pData)
  630. {
  631.   ASSERT_VALID(pMenu);
  632.   // walk through all items, looking for ID match
  633.   UINT nItems = pMenu->GetMenuItemCount();
  634.   for (int iItem = 0; iItem < (int)nItems; iItem++)
  635.   {
  636.     CMenu* pPopup = pMenu->GetSubMenu(iItem);
  637.     if (pPopup != NULL)
  638.     {
  639.       // recurse to child popup
  640.       pPopup = FindPopupMenuFromIDData(pPopup, nID, pData);
  641.       // check popups on this popup
  642.       if (pPopup != NULL)
  643.         return pPopup;
  644.     }
  645.     else if (pMenu->GetMenuItemID(iItem) == nID)
  646.     { 
  647.       MENUITEMINFO MenuItemInfo;
  648.       ::ZeroMemory(&MenuItemInfo,sizeof(MenuItemInfo));
  649.       MenuItemInfo.cbSize = sizeof(MenuItemInfo);
  650.       MenuItemInfo.fMask = MIIM_DATA;
  652.       if(pMenu->GetMenuItemInfo(iItem,&MenuItemInfo,TRUE))
  653.       {
  654.         if(MenuItemInfo.dwItemData==pData)
  655.         {
  656.           // it is a normal item inside our popup
  657.           return pMenu;
  658.         }
  659.       }
  660.     }
  661.   }
  662.   // not found
  663.   return NULL;
  664. }
  666. CMenu* CNewMenu::FindPopupMenuFromID(CMenu* pMenu, UINT nID)
  667. {
  668.   ASSERT_VALID(pMenu);
  669.   // walk through all items, looking for ID match
  670.   UINT nItems = pMenu->GetMenuItemCount();
  671.   for (int iItem = 0; iItem < (int)nItems; iItem++)
  672.   {
  673.     CMenu* pPopup = pMenu->GetSubMenu(iItem);
  674.     if (pPopup != NULL)
  675.     {
  676.       // recurse to child popup
  677.       pPopup = FindPopupMenuFromID(pPopup, nID);
  678.       // check popups on this popup
  679.       if (pPopup != NULL)
  680.         return pPopup;
  681.     }
  682.     else if (pMenu->GetMenuItemID(iItem) == nID)
  683.     {
  684.       // it is a normal item inside our popup
  685.       return pMenu;
  686.     }
  687.   }
  688.   // not found
  689.   return NULL;
  690. }
  692. BOOL CNewMenu::DestroyMenu()
  693. {
  694.   // Destroy Sub menus:
  695.   int m,n;
  696.   int numAllSubMenus = (int)m_AllSubMenus.GetUpperBound();
  697.   for(n = numAllSubMenus; n>= 0; n--)
  698.   {
  699.     if(m_AllSubMenus[n]==this->m_hMenu)
  700.       m_AllSubMenus.RemoveAt(n);
  701.   }
  702.   int numSubMenus = (int)m_SubMenus.GetUpperBound();
  703.   for(m = numSubMenus; m >= 0; m--)
  704.   {
  705.     numAllSubMenus = (int)m_AllSubMenus.GetUpperBound();
  706.     for(n = numAllSubMenus; n>= 0; n--)
  707.     {
  708.       if(m_AllSubMenus[n]==m_SubMenus[m])
  709.         m_AllSubMenus.RemoveAt(n);
  710.     }
  711.     delete((CNewMenu *)FromHandle(m_SubMenus[m]));
  712.   }
  713.   m_SubMenus.RemoveAll();
  714.   // Destroy menu data
  715.   int numItems = (int)m_MenuList.GetUpperBound();
  716.   for(m = 0; m <= numItems; m++)
  717.   {
  718.     delete(m_MenuList[m]);
  719.   }
  720.   
  721.   m_MenuList.RemoveAll();
  722.   if(checkmaps&&!checkmapsshare)
  723.   {
  724.     delete checkmaps;
  725.     checkmaps=NULL;
  726.   }
  727.   // Call base-class implementation last:
  728.   return(CMenu::DestroyMenu());
  729. };
  731. int CNewMenu::GetMenuDrawMode()
  732. {
  733.   ASSERT(m_pActMenuDrawing);
  734.   return m_pActMenuDrawing->m_dwThemeId;
  735. }
  737. void CNewMenu::SetMenuDrawMode(UINT mode)
  738. {
  739.   CMenuTheme* pTheme = CNewMenuHook::FindTheme(mode);
  740.   if(pTheme)
  741.   {
  742.     m_pActMenuDrawing = pTheme;
  743.   }
  744. }
  746. HMENU CNewMenu::GetParent()
  747. {
  748.   return m_hParentMenu;
  749. }
  751. BOOL CNewMenu::IsPopup()
  752. {
  753.   return m_bIsPopupMenu;
  754. }
  756. BOOL CNewMenu::SetSelectDisableMode(BOOL mode)
  757. {
  758.   BOOL bOldMode = m_bSelectDisable;
  759.   m_bSelectDisable=mode;
  761.   return bOldMode;
  762. }
  764. BOOL CNewMenu::GetSelectDisableMode()
  765. {
  766.   return m_bSelectDisable;
  767. }
  769. void CNewMenu::MeasureItem( LPMEASUREITEMSTRUCT lpMIS )
  770. {
  771.   ASSERT(m_pActMenuDrawing);
  773.   BOOL bIsMenuBar = IsMenuBar(UIntToHMenu(lpMIS->itemID));
  775.   ((*this).*m_pActMenuDrawing->m_pMeasureItem)(lpMIS,bIsMenuBar);
  776. }
  778. void CNewMenu::DrawItem (LPDRAWITEMSTRUCT lpDIS)
  779. {
  780.   ASSERT(m_pActMenuDrawing);
  781.   
  782.   BOOL bIsMenuBar = m_hParentMenu ? FALSE: ((m_bIsPopupMenu)?FALSE:TRUE);
  784.   (this->*m_pActMenuDrawing->m_pDrawItem)(lpDIS,bIsMenuBar);
  785. }
  787. // Erase the Background of the menu
  788. BOOL CNewMenu::EraseBkgnd(HWND hWnd, HDC hDC)
  789. {
  790.   CDC* pDC = CDC::FromHandle (hDC);
  791.   CRect Rect;
  792.   //  Get the size of the menu... 
  793.   GetClientRect(hWnd, Rect );
  795.   pDC->FillSolidRect (Rect,GetSysColor(cCOLOR_MENUBAR));
  797.   return TRUE;
  798. }
  800. void CNewMenu::DrawTitle(LPDRAWITEMSTRUCT lpDIS,BOOL bIsMenuBar)
  801. {
  802.   ASSERT(m_pActMenuDrawing);
  803.   (this->*m_pActMenuDrawing->m_pDrawTitle)(lpDIS,bIsMenuBar);
  804. }
  806. void CNewMenu::DrawMenuTitle(LPDRAWITEMSTRUCT lpDIS, BOOL bIsMenuBar)
  807. {
  808.   UNREFERENCED_PARAMETER(bIsMenuBar);
  810.   CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  812.   CNewMenuItemData* pMenuData = (CNewMenuItemData*)(lpDIS->itemData);
  813.   ASSERT(pMenuData);
  815.   COLORREF ColA = GetSysColor(COLOR_WINDOW);
  816.   COLORREF ColB = GetSysColor(cCOLOR_MENUBAR);
  817.   
  818.   COLORREF colorMenu = MixedColor(ColA,ColB);
  820.   CRect rcClipBox;
  821.   pDC->GetClipBox(rcClipBox);
  823.   // draw the title bar
  824.   CRect rect = lpDIS->rcItem;
  825.   CPoint TextPoint;
  827.   CFont Font;
  828.   if(pMenuData->m_nTitleFlags&MFT_SIDE_TITLE)
  829.   {
  830.     rect.top = rcClipBox.top;
  831.     rect.bottom = rcClipBox.bottom;
  832.     rect.right += GetSystemMetrics(SM_CXMENUCHECK);
  833.     Font.CreateFont(16, 0, 900, 900, FW_BOLD,
  834.                         0, 0, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
  835.                         CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
  836.                         DEFAULT_PITCH,_T("Arial"));
  838.     TextPoint = CPoint(rect.left+2, rect.bottom-4);
  839.     // DrawGradient(pDC,rect,colorMenu,::GetSysColor(COLOR_ACTIVECAPTION),false);
  840.   }
  841.   else
  842.   {
  843.     Font.CreateFont(16, 0, 0, 0, FW_BOLD,
  844.                         0, 0, 0, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
  845.                         CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
  846.                         DEFAULT_PITCH,_T("Arial"));
  848.     TextPoint = CPoint(rect.left+2, rect.top);
  850.     // DrawGradient(pDC,rect,::GetSysColor(COLOR_ACTIVECAPTION),colorMenu,true);
  851.   }
  852.   if(pMenuData->m_nTitleFlags&MFT_GRADIENT)
  853.   {
  854.     if(pMenuData->m_nTitleFlags&MFT_SIDE_TITLE)
  855.     {
  856.       DrawGradient(pDC,rect,colorMenu,::GetSysColor(COLOR_ACTIVECAPTION),false);
  857.     }
  858.     else
  859.     {
  860.       DrawGradient(pDC,rect,::GetSysColor(COLOR_ACTIVECAPTION),colorMenu,true);
  861.     }
  862.   }
  863.   else
  864.   {
  865.     if(pMenuData->m_nTitleFlags&MFT_ROUND)
  866.     {
  867.       if(pMenuData->m_nTitleFlags&MFT_SIDE_TITLE)
  868.       {
  869.         TextPoint.y-=2;
  870.         rect.right = rect.left+21;
  871.       }
  872.       else
  873.       {
  874.         TextPoint.x+=10;
  875.       }
  877.       CBrush brush(GetSysColor(COLOR_ACTIVECAPTION));
  878.       CPen* pOldPen = (CPen*)pDC->SelectStockObject(WHITE_PEN);
  879.       CBrush* pOldBrush = pDC->SelectObject(&brush);
  881.       pDC->RoundRect(rect,CPoint(10,10));
  882.       pDC->SelectObject(pOldBrush);
  883.       pDC->SelectObject(pOldPen); 
  884.       
  885.     }
  886.     else
  887.     {
  888.       pDC->FillSolidRect(rect,GetSysColor(COLOR_ACTIVECAPTION));
  889.     }
  890.   }
  891.   if (pMenuData->m_nTitleFlags&MFT_SUNKEN)
  892.   {
  893.     pDC->Draw3dRect(rect,GetSysColor(COLOR_3DSHADOW),GetSysColor(COLOR_3DHILIGHT));
  894.   }
  896.   CFont *pOldFont = pDC->SelectObject(&Font);
  897.   COLORREF oldColor = pDC->SetTextColor(::GetSysColor(COLOR_CAPTIONTEXT));
  898.   int OldMode = pDC->SetBkMode(TRANSPARENT);
  900.   if (pMenuData->m_nTitleFlags&MFT_CENTER)
  901.   {
  902.     SIZE size;
  903.     VERIFY(::GetTextExtentPoint32(pDC->m_hDC,pMenuData->m_szMenuText,pMenuData->m_szMenuText.GetLength(),&size));
  904.     if (pMenuData->m_nTitleFlags&MFT_SIDE_TITLE)
  905.     {
  906.       TextPoint.y = rect.bottom - ((rect.Height()-size.cx)>>1);
  907.     }
  908.     else
  909.     {
  910.       TextPoint.x = rect.left + ((rect.Width()-size.cx)>>1);
  911.     }
  912.   }
  914.   pDC->TextOut(TextPoint.x,TextPoint.y, pMenuData->GetString());
  916.   if(pMenuData->m_nTitleFlags&MFT_LINE)
  917.   {
  918.     if(pMenuData->m_nTitleFlags&MFT_SIDE_TITLE)
  919.     {
  920.       CRect rect2(rect.left+20,rect.top+5,rect.left+22,rect.bottom-5);
  921.       pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),GetSysColor(COLOR_3DHILIGHT));
  922.       rect2.OffsetRect(3,0);
  923.       rect2.InflateRect(0,-10);
  924.       pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),GetSysColor(COLOR_3DHILIGHT));
  925.     }
  926.     else
  927.     {
  928.       CRect rect2(rect.left+2,rect.bottom-7,rect.right-2,rect.bottom-5);
  929.       pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DHILIGHT),GetSysColor(COLOR_3DSHADOW));
  930.       rect2.OffsetRect(0,3);
  931.       rect2.InflateRect(-10,0);
  932.       pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),GetSysColor(COLOR_3DHILIGHT));
  933.     }
  934.   }
  935.   
  936.   pDC->SetBkMode(OldMode);
  937.   pDC->SetTextColor(oldColor);  
  938.   pDC->SelectObject(pOldFont);
  939. }
  941. void CNewMenu::DrawItem_WinXP(LPDRAWITEMSTRUCT lpDIS, BOOL bIsMenuBar)
  942. {
  943.   ASSERT(lpDIS != NULL);
  944.   CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  945.   CRect rect;
  947.   CNewMenuItemData* pMenuData = (CNewMenuItemData*)(lpDIS->itemData);
  948.   ASSERT(pMenuData);
  950.   UINT state = pMenuData->m_nFlags;
  952.   COLORREF ColA = GetSysColor(COLOR_WINDOW);
  953.   COLORREF ColB = GetSysColor(cCOLOR_MENUBAR);
  955.   COLORREF colorMenu = MixedColor(ColA,ColB);
  956.   COLORREF colorBitmap = MixedColor(ColB,ColA);
  958.   COLORREF colorSel = MidColor(ColA,GetSysColor(COLOR_HIGHLIGHT));
  960.   CPen Pen(PS_SOLID,0,GetSysColor(COLOR_HIGHLIGHT));
  962.   if(bIsMenuBar)
  963.   {
  964. #ifdef _TRACE_MENU_
  965.     TRACE(_T("BarState: 0x%lX Menus %ldn"),lpDIS->itemState,m_dwOpenMenu);
  966. #endif
  967.     if(!m_dwOpenMenu && lpDIS->itemState&ODS_SELECTED)
  968.     {
  969.       lpDIS->itemState = (lpDIS->itemState&~ODS_SELECTED)|ODS_HOTLIGHT;
  970.     }
  971.     if(!(lpDIS->itemState&ODS_HOTLIGHT))
  972.     { 
  973.       colorSel = colorBitmap;
  974.     }
  975.     colorMenu = ColB;
  976.   }
  978.   CBrush m_brBackground(colorMenu);
  979.   CBrush m_brSel(colorSel);
  980.   CBrush m_brBitmap(colorBitmap);
  982.   CRect RectL(lpDIS->rcItem);
  983.   CRect RectR(lpDIS->rcItem);
  984.   CRect RectSel(lpDIS->rcItem);
  986.   if(bIsMenuBar)
  987.   {
  988.     RectR.InflateRect (0,0,0,0);
  989.     RectSel.InflateRect (0,0,-2 -2,0);
  990.   }  
  991.   else
  992.   {
  993.     RectL.right = RectL.left + m_iconX + 8;
  994.     RectR.left  = RectL.right;
  995.     // Draw for Bitmapbackground
  996.     pDC->FillSolidRect (RectL,colorBitmap);
  997.   }
  998.   // Draw for Textbackground
  999.   pDC->FillSolidRect (RectR,colorMenu);
  1001.   // Spacing for submenu only in popups
  1002.   if(!bIsMenuBar)
  1003.   {
  1004.     RectR.left += 4;
  1005.     RectR.right-= 15;
  1006.   }
  1008.   //  Flag for highlighted item
  1009.   if(lpDIS->itemState & (ODS_HOTLIGHT|ODS_INACTIVE) )
  1010.   {
  1011.     lpDIS->itemState |= ODS_SELECTED;
  1012.   }
  1014.   if(bIsMenuBar && (lpDIS->itemState&ODS_SELECTED) )
  1015.   {
  1016.     if(!(lpDIS->itemState&ODS_INACTIVE) )
  1017.     {
  1018.       SetLastMenuRect(lpDIS->hDC,RectSel);
  1019.       if(!(lpDIS->itemState&ODS_HOTLIGHT) )
  1020.       { 
  1021.         int X,Y;
  1022.         CRect rect = RectR;
  1023.         int winH = rect.Height(); 
  1025.         // Simulate a shadow on right edge... 
  1026.         for (X=1; X<=4 ;X++)
  1027.         { 
  1028.           for (Y=0; Y<4 ;Y++)
  1029.           {
  1030.             pDC->SetPixel(rect.right-X,Y+rect.top, ColB );
  1031.           }
  1032.           for (Y=4; Y<8 ;Y++)
  1033.           {
  1034.             pDC->SetPixel(rect.right-X,Y+rect.top,DarkenColor(3 * X * (Y - 3), ColB)) ;
  1035.           }
  1036.           for (Y=8; Y<=(winH-1) ;Y++)
  1037.           {
  1038.             pDC->SetPixel(rect.right - X, Y+rect.top, DarkenColor(15 * X, ColB) );
  1039.           }
  1040.         }
  1041.       }
  1042.     }
  1043.   }
  1044.   // For keyboard navigation only
  1045.   BOOL bDrawSmalSelection = FALSE;
  1046.   // remove the selected bit if it's grayed out
  1047.   if( (lpDIS->itemState&ODS_GRAYED) && !m_bSelectDisable)
  1048.   {
  1049.     if( lpDIS->itemState & ODS_SELECTED )
  1050.     {
  1051.       lpDIS->itemState=lpDIS->itemState & ~ODS_SELECTED;
  1052.       DWORD MsgPos = ::GetMessagePos();
  1053.       if(MsgPos==CNewMenuHook::m_dwMsgPos)
  1054.       {
  1055.         bDrawSmalSelection = TRUE;
  1056.       }
  1057.       else
  1058.       {
  1059.         CNewMenuHook::m_dwMsgPos = MsgPos;
  1060.       }
  1061.     }
  1062.   }
  1064.   // Draw the seperator
  1065.   if(state & MF_SEPARATOR)
  1066.   {
  1067.     if(pMenuData->m_nTitleFlags&MFT_TITLE)
  1068.     {
  1069.       DrawTitle(lpDIS,bIsMenuBar);
  1070.     }
  1071.     else
  1072.     {
  1073.       // Draw only the seperator
  1074.       CRect rect;
  1075.       rect.top = RectR.CenterPoint().y;
  1076.       rect.bottom = rect.top+1;
  1077.       rect.right = lpDIS->rcItem.right+1;
  1078.       rect.left = RectR.left;
  1079.       pDC->FillSolidRect(rect,GetSysColor(COLOR_GRAYTEXT));
  1080.     }
  1081.   }
  1082.   else
  1083.   {
  1084.     if( (lpDIS->itemState & ODS_SELECTED) && !(lpDIS->itemState&ODS_INACTIVE) )
  1085.     {
  1086.       // Draw the selection
  1087.       CPen* pOldPen = pDC->SelectObject(&Pen);
  1088.       CBrush* pOldBrush = pDC->SelectObject(&m_brSel);
  1089.       pDC->Rectangle(RectSel);
  1090.       pDC->SelectObject(pOldBrush);
  1091.       pDC->SelectObject(pOldPen);
  1092.     }
  1093.     else if (bDrawSmalSelection)
  1094.     {
  1095.       // Draw the selection for keyboardnavigation
  1096.       CPen* pOldPen = pDC->SelectObject(&Pen);
  1097.       CBrush* pOldBrush = pDC->SelectObject(&m_brBackground);
  1098.       pDC->Rectangle(RectSel);
  1099.       pDC->SelectObject(pOldBrush);
  1100.       pDC->SelectObject(pOldPen);
  1101.     }
  1103.     UINT state = lpDIS->itemState;
  1105.     BOOL standardflag=FALSE;
  1106.     BOOL selectedflag=FALSE;
  1107.     BOOL disableflag=FALSE;
  1108.     BOOL checkflag=FALSE;
  1110.     CBrush m_brSelect;
  1111.     CPen m_penBack;
  1113.     CImageList* bitmap = pMenuData->m_pBitmap;
  1114.     CString strText = pMenuData->GetString();
  1116.     if((state&ODS_CHECKED) && (pMenuData->m_nMenuIconNormal<0))
  1117.     {
  1118.       if(state&ODS_SELECTED && m_selectcheck>0)
  1119.       {
  1120.         checkflag=TRUE;
  1121.       }
  1122.       else if(m_unselectcheck>0)
  1123.       {
  1124.         checkflag=TRUE;
  1125.       }
  1126.     }
  1127.     else if(pMenuData->m_nMenuIconNormal != -1)
  1128.     {
  1129.       standardflag=TRUE;
  1130.       if(state&ODS_SELECTED)
  1131.       {
  1132.         selectedflag=TRUE;
  1133.       }
  1134.       else if(state&ODS_GRAYED) 
  1135.       {
  1136.         disableflag=TRUE;
  1137.       }
  1138.     }
  1140.     // draw the menutext
  1141.     if(!strText.IsEmpty())
  1142.     {
  1143.       LOGFONT LogFontMenu;
  1144.       CFont FontMenu;
  1146.       NONCLIENTMETRICS nm;
  1147.       ::ZeroMemory(&nm,sizeof(nm));
  1148.       nm.cbSize = sizeof (nm);
  1149.       VERIFY (SystemParametersInfo(SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
  1150.       LogFontMenu =  nm.lfMenuFont;
  1152.       // Default selection?
  1153.       if(state&ODS_DEFAULT)
  1154.       {
  1155.         // Make the font bold
  1156.         LogFontMenu.lfWeight = FW_BOLD;
  1157.       }
  1158.       FontMenu.CreateFontIndirect(&LogFontMenu);
  1160.       CString leftStr;
  1161.       CString rightStr;
  1162.       leftStr.Empty();
  1163.       rightStr.Empty();
  1165.       int tablocr=strText.ReverseFind(_T('t'));
  1166.       if(tablocr!=-1)
  1167.       {
  1168.         rightStr=strText.Mid(tablocr+1);
  1169.         leftStr=strText.Left(strText.Find(_T('t')));
  1170.       }
  1171.       else 
  1172.         leftStr=strText;
  1174.       // Draw the text in the correct colour:
  1175.       UINT nFormat  = DT_LEFT| DT_SINGLELINE|DT_VCENTER;
  1176.       UINT nFormatr = DT_RIGHT|DT_SINGLELINE|DT_VCENTER;
  1178.       int iOldMode = pDC->SetBkMode( TRANSPARENT);
  1179.       CFont* pOldFont = pDC->SelectObject (&FontMenu);
  1181.       COLORREF OldTextColor;
  1182.       if( (lpDIS->itemState&ODS_GRAYED) || 
  1183.           (bIsMenuBar && lpDIS->itemState&ODS_INACTIVE) )
  1184.       {
  1185.         // Draw the text disabled? 
  1186.         OldTextColor = pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
  1187.       }
  1188.       else
  1189.       {
  1190.         // Draw the text normal
  1191.         OldTextColor = pDC->SetTextColor(GetSysColor(COLOR_MENUTEXT));
  1192.       }
  1193.       if(bIsMenuBar)
  1194.       {
  1195.         pDC->DrawText(leftStr,RectSel, DT_SINGLELINE|DT_VCENTER|DT_CENTER);
  1196.       }
  1197.       else
  1198.       {
  1199.         pDC->DrawText(leftStr,RectR, nFormat);
  1200.         if(tablocr!=-1) 
  1201.           pDC->DrawText (rightStr,RectR,nFormatr);
  1202.       }
  1203.       pDC->SetTextColor(OldTextColor);
  1204.       pDC->SelectObject(pOldFont);
  1205.       pDC->SetBkMode(iOldMode);
  1206.     }
  1208.     // Draw the Bitmap or checkmarks
  1209.     if(!bIsMenuBar)
  1210.     {
  1211.       CRect rect2 = RectR;
  1212.       
  1213.       if(checkflag||standardflag||selectedflag||disableflag)
  1214.       {
  1215.         if(checkflag && checkmaps)
  1216.         {
  1217.           CPoint ptImage(RectL.left+3,RectL.top+4);
  1218.           
  1219.           if(state&ODS_SELECTED)
  1220.             checkmaps->Draw(pDC,1,ptImage,ILD_TRANSPARENT);
  1221.           else 
  1222.             checkmaps->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
  1223.         }
  1224.         else
  1225.         {
  1226.           //CPoint ptImage(rect.left+3,rect.top+2+dy);
  1227.           HICON hDrawIcon = bitmap->ExtractIcon(0);
  1228.           int cx,cy;
  1229.           ::ImageList_GetIconSize(*bitmap, &cx, &cy);
  1230.           CSize size(cx,cy);
  1232.           CPoint ptImage(RectL.left+3,RectL.top+4);
  1234.           CBrush* pBrush = &m_brBitmap; 
  1236.           // Need to draw the checked state
  1237.           if (state&ODS_CHECKED)
  1238.           {
  1239.             CRect rect = RectL;
  1240.             rect.InflateRect (-1,-1);
  1242.             CBrush Brush;
  1243.             if(selectedflag)
  1244.               Brush.CreateSolidBrush(DarkenColorXP(colorSel));
  1245.             else
  1246.               Brush.CreateSolidBrush(DarkenColorXP(colorMenu));
  1248.             CPen* pOldPen = pDC->SelectObject(&Pen);
  1249.             CBrush* pOldBrush = pDC->SelectObject(&Brush);
  1251.             pDC->Rectangle(rect);
  1253.             pDC->SelectObject(pOldBrush);
  1254.             pDC->SelectObject(pOldPen);
  1255.           } 
  1256.           else if(selectedflag)
  1257.           {
  1258.             CBrush Brush;
  1259.             Brush.CreateSolidBrush(DarkenColorXP(colorSel));
  1261.             ptImage.x++; ptImage.y++;
  1262.             pDC->DrawState(ptImage, size, hDrawIcon, DSS_NORMAL | DSS_MONO, &Brush);
  1263.             ptImage.x-=2; ptImage.y-=2;
  1264.           }
  1266.           if(state & ODS_DISABLED)
  1267.             pDC->DrawState(ptImage, size, hDrawIcon, DSS_DISABLED, pBrush);
  1268.           else
  1269.             pDC->DrawState(ptImage, size, hDrawIcon, DSS_NORMAL,(HBRUSH)NULL);
  1270.         }
  1271.       }
  1272.       if(pMenuData->m_nMenuIconNormal<0 && state&ODS_CHECKED && !checkflag)
  1273.       {
  1274.         MENUITEMINFO info;
  1275.         ZeroMemory(&info,sizeof(info));
  1277.         info.cbSize = sizeof(info);
  1278.         info.fMask = MIIM_CHECKMARKS;
  1280.         ::GetMenuItemInfo(HWndToHmenu(lpDIS->hwndItem),lpDIS->itemID,MF_BYCOMMAND, &info);
  1282.         if(state&ODS_CHECKED || info.hbmpUnchecked) 
  1283.         {
  1284.           CRect rect = RectL;
  1285.           rect.InflateRect (-1,-1);
  1287.           COLORREF transparentcol;
  1288.           if(state&ODS_SELECTED)
  1289.             transparentcol = DarkenColorXP(colorSel);
  1290.           else
  1291.             transparentcol = DarkenColorXP(colorMenu);
  1293.           CBrush Brush;
  1294.           Brush.CreateSolidBrush(transparentcol);
  1296.           CPen* pOldPen = pDC->SelectObject(&Pen);
  1297.           CBrush* pOldBrush = pDC->SelectObject(&Brush);
  1299.           pDC->Rectangle(rect);
  1301.           pDC->SelectObject(pOldBrush);
  1302.           pDC->SelectObject(pOldPen);
  1303.           if (state&ODS_CHECKED)
  1304.           {
  1305.             rect.InflateRect (-1,-1);
  1306.             if (!info.hbmpChecked)
  1307.             { // Checkmark
  1308.               DrawSpecialCharStyle(pDC,rect,98,state);
  1309.             }
  1310.             else
  1311.             { // Bullet
  1312.               DrawSpecialCharStyle(pDC,rect,105,state);
  1313.             }
  1314.           }
  1315.           else
  1316.           {
  1317.             CSize size = rect.Size();
  1318.             CPoint ptImage = rect.TopLeft();
  1319.             if(state & ODS_DISABLED)
  1320.               pDC->DrawState(ptImage, size, info.hbmpUnchecked, DSS_DISABLED, (HBRUSH)NULL);
  1321.             else
  1322.               pDC->DrawState(ptImage, size, info.hbmpUnchecked, DSS_NORMAL,(HBRUSH)NULL);
  1323.           }
  1324.         }
  1325.       }
  1326.       else if (lpDIS->itemID>=SC_SIZE && lpDIS->itemID<=SC_HOTKEY )
  1327.       {
  1328.         DrawSpecial_WinXP(pDC,RectL,lpDIS->itemID,state);
  1329.       }
  1330.     }
  1331.   }
  1332. }
  1334. void CNewMenu::DrawItem_SpecialStyle (LPDRAWITEMSTRUCT lpDIS, BOOL bIsMenuBar)
  1335. {
  1336.   if(!bIsMenuBar)
  1337.   {
  1338.     DrawItem_OldStyle(lpDIS,bIsMenuBar);
  1339.     return;
  1340.   }
  1342.   ASSERT(lpDIS != NULL);
  1343.   CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  1345.   ASSERT(lpDIS->itemData);
  1346.   CNewMenuItemData* pMenuData = (CNewMenuItemData*)(lpDIS->itemData);
  1348.   CRect rect(lpDIS->rcItem);
  1349.   //rect.InflateRect(0,-1);
  1351.   COLORREF ColorBack;
  1352.   if(lpDIS->itemState&(ODS_SELECTED|ODS_HOTLIGHT))
  1353.   {
  1354.     ColorBack = GetSysColor(COLOR_HIGHLIGHT);
  1355.     SetLastMenuRect(lpDIS->hDC,rect);
  1356.   }
  1357.   else
  1358.   {
  1359.     ColorBack = GetSysColor(cCOLOR_MENUBAR);
  1360.   }
  1361.   pDC->FillSolidRect(rect,ColorBack);
  1363.   int iOldMode = pDC->SetBkMode( TRANSPARENT);
  1364.   CString strText = pMenuData->GetString();
  1365.   COLORREF crTextColor;
  1366.   if(!(lpDIS->itemState & ODS_GRAYED))
  1367.   {
  1368.     if(lpDIS->itemState&(ODS_SELECTED|ODS_HOTLIGHT)) 
  1369.       crTextColor = GetSysColor(COLOR_HIGHLIGHTTEXT);
  1370.     else
  1371.       crTextColor = GetSysColor(COLOR_MENUTEXT);
  1372.   }
  1373.   else
  1374.   {
  1375.     crTextColor = GetSysColor(COLOR_GRAYTEXT);
  1376.   }
  1377.   COLORREF oldColor = pDC->SetTextColor(crTextColor);
  1378.   
  1379.   pDC->DrawText(strText,rect,DT_CENTER|DT_SINGLELINE|DT_VCENTER);
  1380.   
  1381.   pDC->SetTextColor(oldColor);
  1382.   pDC->SetBkMode( iOldMode);
  1383. }
  1385. void CNewMenu::DrawItem_OldStyle (LPDRAWITEMSTRUCT lpDIS, BOOL bIsMenuBar)
  1386. {
  1387.   ASSERT(lpDIS != NULL);
  1388.   CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  1389.   CRect rect;
  1391.   ASSERT(lpDIS->itemData);
  1392.   CNewMenuItemData* pMenuData = (CNewMenuItemData*)(lpDIS->itemData);
  1394.   UINT state = pMenuData->m_nFlags;
  1395.   CBrush m_brBackground;
  1397.   COLORREF ColorBack = bIsMenuBar?GetSysColor(cCOLOR_MENUBAR):GetSysColor(COLOR_MENU);
  1399.   m_brBackground.CreateSolidBrush(ColorBack);
  1401.   CRect RectL(lpDIS->rcItem);
  1402.   CRect RectR(lpDIS->rcItem);
  1403.   CRect RectSel(lpDIS->rcItem);
  1405.   RectL.InflateRect (-1,0,0,0);
  1406.   RectR.InflateRect (-1,0,0,0);
  1407.   RectSel.InflateRect (0,0,0,0);
  1409.   if(!bIsMenuBar)
  1410.   {
  1411.     RectL.right = RectL.left + m_iconX + 6 + GAP;
  1412.     RectR.left  = RectL.right;
  1413.     // Draw for Bitmapbackground
  1414.     pDC->FillSolidRect (RectL,ColorBack);
  1415.   }
  1416.   else
  1417.   {
  1418. #ifdef _TRACE_MENU_
  1419.     TRACE(_T("BarState: 0x%lX Menus %ldn"),lpDIS->itemState,m_dwOpenMenu);
  1420. #endif
  1421.     if(!m_dwOpenMenu && lpDIS->itemState&ODS_SELECTED)
  1422.     {
  1423.       lpDIS->itemState = (lpDIS->itemState&~ODS_SELECTED)|ODS_HOTLIGHT;
  1424.     }
  1426.     RectR.InflateRect (1,0,0,0);
  1427.     RectSel.InflateRect (0,0,-5,0);
  1428.     RectSel.OffsetRect(1,-1);
  1430.     SetLastMenuRect(lpDIS->hDC,RectSel);
  1431.   }
  1433.    // For keyboard navigation only
  1434.   BOOL bDrawSmalSelection = FALSE;
  1436.   // remove the selected bit if it's grayed out
  1437.   if( (lpDIS->itemState&ODS_GRAYED) && !m_bSelectDisable )
  1438.   {
  1439.     if(lpDIS->itemState & ODS_SELECTED)
  1440.     {
  1441.       lpDIS->itemState &= ~ODS_SELECTED;
  1442.       DWORD MsgPos = ::GetMessagePos();
  1443.       if(MsgPos==CNewMenuHook::m_dwMsgPos)
  1444.       {
  1445.         bDrawSmalSelection = TRUE;
  1446.       }
  1447.       else
  1448.       {
  1449.         CNewMenuHook::m_dwMsgPos = MsgPos;
  1450.       }
  1451.     }
  1452.   }
  1454.   if(state & MF_SEPARATOR)
  1455.   {
  1456.     if(pMenuData->m_nTitleFlags&MFT_TITLE)
  1457.     {
  1458.       DrawTitle(lpDIS,bIsMenuBar);
  1459.     }
  1460.     else
  1461.     {
  1462.       rect = lpDIS->rcItem; 
  1463.       rect.left += 1;
  1464.       pDC->FillSolidRect(rect,ColorBack);
  1465.       pDC->DrawEdge(&rect,EDGE_ETCHED,BF_TOP);
  1466.     }
  1467.   }
  1468.   else
  1469.   {
  1470.     CRect rect2;
  1471.     BOOL standardflag=FALSE,selectedflag=FALSE,disableflag=FALSE;
  1472.     BOOL checkflag=FALSE;
  1474.     CBrush m_brSelect;
  1475.     int nIconNormal=-1,xoffset=-1;
  1476.     CImageList *bitmap=NULL;
  1478.     // set some colors and the font
  1479.     m_brSelect.CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
  1481.     // draw the colored rectangle portion
  1482.     rect.CopyRect(&lpDIS->rcItem);
  1483.     rect.OffsetRect (1,1);
  1484.     rect2=rect=RectSel;
  1486.     // draw the up/down/focused/disabled state
  1488.     UINT state = lpDIS->itemState;
  1489.     CString strText;
  1491.     nIconNormal = pMenuData->m_nMenuIconNormal;
  1492.     xoffset = pMenuData->m_nxOffset;
  1493.     bitmap = pMenuData->m_pBitmap;
  1494.     strText = pMenuData->GetString();
  1496.     if( (state&ODS_CHECKED) && nIconNormal<0)
  1497.     {
  1498.       if(state&ODS_SELECTED && m_selectcheck>0)
  1499.         checkflag=TRUE;
  1500.       else if(m_unselectcheck>0) 
  1501.         checkflag=TRUE;
  1502.     }
  1503.     else if(nIconNormal != -1)
  1504.     {
  1505.       standardflag=TRUE;
  1506.       if(state&ODS_SELECTED && !(state&ODS_GRAYED))
  1507.         selectedflag=TRUE;
  1508.       else if(state&ODS_GRAYED)
  1509.         disableflag=TRUE;
  1510.     }
  1512.     if(bIsMenuBar)
  1513.     {
  1514.       //rect.InflateRect (1,0,0,0);
  1515.       rect.OffsetRect(-1,1);
  1516.       rect2=rect;
  1517.       pDC->FillSolidRect (rect,ColorBack);
  1518.     }
  1519.     else
  1520.     {
  1521.       // Draw the background
  1522.       pDC->FillSolidRect (rect,ColorBack);
  1523.     }
  1524.     // Draw the selection
  1525.     if(state&ODS_SELECTED)
  1526.     {
  1527.       // You need only Text highlight and thats what you get
  1528.       if(!bIsMenuBar)
  1529.       {
  1530.         if(checkflag||standardflag||selectedflag||disableflag||state&ODS_CHECKED)
  1531.         {
  1532.           rect2.SetRect(rect.left+m_iconX+4+GAP,rect.top,rect.right,rect.bottom);
  1533.         }
  1534.         pDC->FillRect(rect2,&m_brSelect);
  1535.       }
  1536.       else
  1537.       {
  1538.         pDC->Draw3dRect(rect ,GetSysColor(COLOR_3DSHADOW),GetSysColor(COLOR_3DHILIGHT));
  1539.       }
  1540.     }
  1541.     else if(bIsMenuBar && (state&ODS_HOTLIGHT) && !(state&ODS_INACTIVE))
  1542.     {
  1543.       pDC->Draw3dRect(rect,GetSysColor(COLOR_3DHILIGHT),GetSysColor(COLOR_3DSHADOW));
  1544.     }
  1545.     else if (bDrawSmalSelection)
  1546.     {
  1547.       pDC->DrawFocusRect(rect);
  1548.     }
  1550.     // Draw the Bitmap or checkmarks
  1551.     if(!bIsMenuBar)
  1552.     {
  1553.       CRect IconRect(rect.TopLeft(),CSize(m_iconX,m_iconY));
  1554.       IconRect.OffsetRect(GAP+1,1+((rect.Height()-m_iconY)>>2));
  1556.       CPoint ptImage = IconRect.TopLeft();
  1557.       IconRect.InflateRect(2,2);
  1558.       if(checkflag||standardflag||selectedflag||disableflag)
  1559.       {
  1560.         if(checkflag && checkmaps)
  1561.         {
  1562.           if(state&ODS_SELECTED)
  1563.             checkmaps->Draw(pDC,1,ptImage,ILD_TRANSPARENT);
  1564.           else 
  1565.             checkmaps->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
  1566.         }
  1567.         else
  1568.         {
  1569.           // Need to draw the checked state
  1570.           if (IsNewShell())
  1571.           {
  1572.             if(state&ODS_CHECKED)
  1573.             {
  1574.               pDC->Draw3dRect(IconRect,GetSysColor(COLOR_3DSHADOW),GetSysColor(COLOR_3DHILIGHT));
  1575.             }
  1576.             else if (selectedflag)
  1577.             {
  1578.               pDC->Draw3dRect(IconRect,GetSysColor(COLOR_3DHILIGHT),GetSysColor(COLOR_3DSHADOW));
  1579.             }
  1580.           }
  1582.           if(state & ODS_DISABLED)
  1583.           {
  1584.             HICON hDrawIcon = bitmap->ExtractIcon(0);
  1585.             int cx,cy;
  1586.             ::ImageList_GetIconSize(*bitmap, &cx, &cy);
  1587.             CSize size(cx,cy);
  1588.           
  1589.             pDC->DrawState(ptImage, size, hDrawIcon, DSS_DISABLED, (HBRUSH)NULL);
  1590.           }
  1591.           else
  1592.           {
  1593.             bitmap->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
  1594.           }
  1595.         }
  1596.       }
  1597.       if(pMenuData->m_nMenuIconNormal<0 && state&ODS_CHECKED && !checkflag)
  1598.       {
  1599.         MENUITEMINFO info;
  1600.         ZeroMemory(&info, sizeof(info));
  1602.         info.cbSize = sizeof(info);
  1603.         info.fMask = MIIM_CHECKMARKS;
  1605.         ::GetMenuItemInfo(HWndToHmenu(lpDIS->hwndItem),lpDIS->itemID,MF_BYCOMMAND, &info);
  1607.         if(state&ODS_CHECKED || info.hbmpUnchecked) 
  1608.         {
  1609.           // Rectangle for checkmarks
  1610.           CRect rect = IconRect;
  1611.           if (state&ODS_CHECKED)
  1612.             Draw3DCheckmark(pDC, IconRect,info.hbmpChecked,state);
  1613.           else
  1614.             Draw3DCheckmark(pDC, IconRect,info.hbmpUnchecked,state);
  1615.         }
  1616.       }
  1617.       else if (lpDIS->itemID>=SC_SIZE && lpDIS->itemID<=SC_HOTKEY)
  1618.       {
  1619.         DrawSpecial_OldStyle(pDC,IconRect,lpDIS->itemID,state);
  1620.       } 
  1621.     }
  1623.     if(!strText.IsEmpty())
  1624.     {
  1625.       COLORREF crText = GetSysColor(COLOR_MENUTEXT);
  1627.       if(bIsMenuBar)
  1628.       {
  1629.         rect.left += 6;
  1630.         if(lpDIS->itemState&ODS_INACTIVE) 
  1631.           crText = GetSysColor(COLOR_GRAYTEXT);
  1632.       }
  1633.       else
  1634.       {
  1635.         if(lpDIS->itemState&ODS_SELECTED) 
  1636.           crText = GetSysColor(COLOR_HIGHLIGHTTEXT);
  1638.         rect.left += m_iconX + 12;
  1639.       }
  1640.       CRect rectt(rect.left,rect.top-1,rect.right,rect.bottom-1);
  1641.       
  1642.       // Find tabs
  1643.       CString leftStr,rightStr;
  1644.       leftStr.Empty();rightStr.Empty();
  1646.       int tablocr=strText.ReverseFind(_T('t'));
  1647.       if(tablocr!=-1)
  1648.       {
  1649.         rightStr=strText.Mid(tablocr+1);
  1650.         leftStr=strText.Left(strText.Find(_T('t')));
  1651.         rectt.right-=m_iconX;
  1652.       }
  1653.       else
  1654.         leftStr=strText;
  1656.       int iOldMode = pDC->SetBkMode( TRANSPARENT);
  1657.       // Draw the text in the correct colour:
  1658.       UINT nFormat  = DT_LEFT|DT_SINGLELINE|DT_VCENTER;
  1659.       UINT nFormatr = DT_RIGHT|DT_SINGLELINE|DT_VCENTER;
  1661.       if(bIsMenuBar)
  1662.       {
  1663.         rectt = RectSel;
  1664.         if(state & ODS_SELECTED)
  1665.         {
  1666.           rectt.OffsetRect(1,1);
  1667.         } 
  1668.         nFormat = DT_CENTER|DT_SINGLELINE|DT_VCENTER;
  1669.       }
  1671.       if(!(lpDIS->itemState & ODS_GRAYED))
  1672.       {
  1673.         pDC->SetTextColor(crText);
  1674.         pDC->DrawText (leftStr,rectt,nFormat);
  1675.         if(tablocr!=-1)
  1676.           pDC->DrawText (rightStr,rectt,nFormatr);
  1677.       }
  1678.       else
  1679.       {
  1680.         // Draw the disabled text
  1681.         if(!(state & ODS_SELECTED))
  1682.         {
  1683.           CRect offset = rectt;
  1684.           offset.OffsetRect (1,1);
  1686.           pDC->SetTextColor(GetSysColor(COLOR_BTNHILIGHT));
  1687.           pDC->DrawText(leftStr,&offset, nFormat);
  1688.           if(tablocr!=-1) 
  1689.             pDC->DrawText (rightStr,&offset,nFormatr);
  1691.           pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
  1692.           pDC->DrawText(leftStr,rectt, nFormat);
  1693.           if(tablocr!=-1)
  1694.             pDC->DrawText(rightStr,rectt,nFormatr);
  1695.         }
  1696.         else
  1697.         {
  1698.           // And the standard Grey text:
  1699.           pDC->SetTextColor(ColorBack);
  1700.           pDC->DrawText(leftStr,rectt, nFormat);
  1701.           if(tablocr!=-1) 
  1702.             pDC->DrawText (rightStr,rectt,nFormatr);
  1703.         }
  1704.       }
  1705.       pDC->SetBkMode( iOldMode );
  1706.     }
  1707.     m_brSelect.DeleteObject();
  1708.   }
  1709.   m_brBackground.DeleteObject();
  1710. }
  1712. BOOL CNewMenu::IsMenuBar(HMENU hMenu)
  1713. {
  1714.   BOOL bIsMenuBar = ::IsMenu(hMenu);
  1715.   if(bIsMenuBar)
  1716.   {
  1717.     CNewMenu* pMenu = DYNAMIC_DOWNCAST(CNewMenu,CMenu::FromHandlePermanent(m_hParentMenu));
  1718.     if (pMenu!=NULL && pMenu->m_hParentMenu!=NULL)
  1719.     {
  1720.       bIsMenuBar = FALSE;
  1721.     }
  1722.   }
  1723.   return bIsMenuBar;
  1724. }
  1726. /*
  1727. ==========================================================================
  1728. void CNewMenu::MeasureItem(LPMEASUREITEMSTRUCT)
  1729. ---------------------------------------------
  1731.   Called by the framework when it wants to know what the width and height
  1732.   of our item will be.  To accomplish this we provide the width of the
  1733.   icon plus the width of the menu text, and then the height of the icon.
  1734.   
  1735. ==========================================================================
  1736. */
  1737. void CNewMenu::MeasureItem_OldStyle( LPMEASUREITEMSTRUCT lpMIS, BOOL bIsMenuBar )
  1738. {
  1739.   ASSERT(lpMIS->itemData);
  1740.   CNewMenuItemData* pMenuData = (CNewMenuItemData*)(lpMIS->itemData);
  1742.   UINT state = pMenuData->m_nFlags;
  1743.   if(state & MF_SEPARATOR)
  1744.   {
  1745.     if(pMenuData->m_nTitleFlags&MFT_TITLE)
  1746.     {
  1747.       // DC of the desktop
  1748.       CClientDC myDC(NULL);          
  1750.       CFont font;
  1751.       font.CreatePointFont(160,_T("Arial"));
  1752.       CFont* pOldFont = myDC.SelectObject (&font);
  1753.       LPCTSTR lpstrText = pMenuData->GetString();
  1754.       SIZE size;
  1755.       VERIFY(::GetTextExtentPoint32(myDC.m_hDC,lpstrText,(int)_tcslen(lpstrText),&size));
  1756.       // Select old font in
  1757.       myDC.SelectObject(pOldFont);  
  1759.       if(pMenuData->m_nTitleFlags&MFT_SIDE_TITLE)
  1760.       {
  1761.         lpMIS->itemWidth = size.cy*3/4 -GetSystemMetrics(SM_CXMENUCHECK);
  1762.         // Don't make the menu higher than menuitems in it
  1763.         lpMIS->itemHeight = 0;
  1764.         if(pMenuData->m_nTitleFlags&MFT_LINE)
  1765.         {
  1766.           lpMIS->itemWidth += 6;
  1767.         }
  1768.        }
  1769.       else
  1770.       {
  1771.         lpMIS->itemWidth = size.cx*3/4;
  1772.         lpMIS->itemHeight = size.cy*3/4;
  1773.         if(pMenuData->m_nTitleFlags&MFT_LINE)
  1774.         {
  1775.           lpMIS->itemHeight += 6;
  1776.         }
  1777.       }
  1778.     }
  1779.     else
  1780.     {
  1781.       lpMIS->itemHeight = 3;
  1782.     }
  1783.   }
  1784.   else
  1785.   {
  1786.     CFont m_fontMenu;
  1787.     LOGFONT m_lf;
  1788.     ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  1789.     NONCLIENTMETRICS nm;
  1790.     nm.cbSize = sizeof (NONCLIENTMETRICS);
  1791.     VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, nm.cbSize,&nm,0)); 
  1792.     m_lf =  nm.lfMenuFont;
  1793.     // Default selection?
  1794.     if(state&ODS_DEFAULT)
  1795.     {
  1796.       // Make the font bold
  1797.       m_lf.lfWeight = FW_BOLD;
  1798.     }
  1800.     m_fontMenu.CreateFontIndirect (&m_lf);
  1801.     
  1802.     // DC of the desktop
  1803.     CClientDC myDC(NULL);
  1804.     
  1805.     // Select menu font in...    
  1806.     CFont* pOldFont = myDC.SelectObject (&m_fontMenu);
  1807.     //Get pointer to text SK
  1808.     const LPCTSTR lpstrText = pMenuData->GetString();
  1809.     SIZE size;
  1810.     VERIFY(::GetTextExtentPoint32(myDC.m_hDC,lpstrText,(int)_tcslen(lpstrText),&size));
  1811.     // Select old font in
  1812.     myDC.SelectObject(pOldFont);  
  1813.   
  1814.     // Set width and height:
  1815.     if(bIsMenuBar)
  1816.     {
  1817.       lpMIS->itemWidth = size.cx ;
  1818.     }
  1819.     else
  1820.     {
  1821.       lpMIS->itemWidth = m_iconX + size.cx + m_iconX + GAP;
  1822.     }
  1824.     // Check the Key-Shortcut
  1825.     if(_tcsstr(lpstrText, _T("t")) != NULL)
  1826.       lpMIS->itemWidth += 15;
  1828.     int temp = GetSystemMetrics(SM_CYMENU);
  1829.     lpMIS->itemHeight = (temp>(m_iconY+4)) ? temp : (m_iconY+4);
  1830.     
  1831.     m_fontMenu.DeleteObject();
  1833.     // set status bar as appropriate
  1834.     UINT nItemID = (lpMIS->itemID & 0xFFF0);
  1835.     // Special case for system menu
  1836.     if (nItemID>=SC_SIZE && nItemID<=SC_HOTKEY) 
  1837.     {
  1838.       BOOL bGetNext = FALSE;
  1839.       // search the actual menu item
  1840.       for (int j=0;j<m_MenuList.GetUpperBound();++j)
  1841.       {
  1842.         CNewMenuItemData* pTemp = m_MenuList[j];
  1843.         if(pTemp==pMenuData || bGetNext==TRUE)
  1844.         {
  1845.           bGetNext = TRUE;
  1846.           pTemp = m_MenuList[j+1];
  1847.           if(pTemp->m_nID)
  1848.           {
  1849.             lpMIS->itemData = (ULONG_PTR)pTemp;
  1850.             lpMIS->itemID = pTemp->m_nID; 
  1851.             UINT nOrgWidth = lpMIS->itemWidth;
  1852.             MeasureItem_OldStyle(lpMIS,bIsMenuBar);
  1853.             // Restore old values
  1854.             lpMIS->itemData = (ULONG_PTR)pMenuData;
  1855.             lpMIS->itemID = pMenuData->m_nID;
  1856.             lpMIS->itemWidth = max(lpMIS->itemWidth,nOrgWidth);
  1857.             break;
  1858.           }
  1859.         }
  1860.       }
  1861.       lpMIS->itemHeight = temp;
  1862.     } 
  1863.   }
  1864. }
  1865. void CNewMenu::MeasureItem_WinXP( LPMEASUREITEMSTRUCT lpMIS, BOOL bIsMenuBar )
  1866. {
  1867.   ASSERT(lpMIS->itemData);
  1868.   CNewMenuItemData* pMenuData = (CNewMenuItemData*)(lpMIS->itemData);
  1870.   UINT state = pMenuData->m_nFlags;
  1871.   if(state & MF_SEPARATOR)
  1872.   {
  1873.     if(pMenuData->m_nTitleFlags&MFT_TITLE)
  1874.     {
  1875.       // DC of the desktop
  1876.       CClientDC myDC(NULL);
  1878.       CFont font;
  1879.       font.CreatePointFont(160,_T("Arial"));
  1880.       CFont* pOldFont = myDC.SelectObject (&font);
  1881.       LPCTSTR lpstrText = pMenuData->GetString();
  1882.       SIZE size;
  1883.       VERIFY(::GetTextExtentPoint32(myDC.m_hDC,lpstrText,(int)_tcslen(lpstrText),&size));
  1884.       // Select old font in
  1885.       myDC.SelectObject(pOldFont);  
  1887.       if(pMenuData->m_nTitleFlags&MFT_SIDE_TITLE)
  1888.       {
  1889.         lpMIS->itemWidth = size.cy*3/4 -GetSystemMetrics(SM_CXMENUCHECK);
  1890.         // Don't make the menu higher than menuitems in it
  1891.         lpMIS->itemHeight = 0;
  1892.         if(pMenuData->m_nTitleFlags&MFT_LINE)
  1893.         {
  1894.           lpMIS->itemWidth += 6;
  1895.         }
  1896.       }
  1897.       else
  1898.       {
  1899.         lpMIS->itemWidth = size.cx*3/4;
  1900.         lpMIS->itemHeight = size.cy*3/4;
  1901.         if(pMenuData->m_nTitleFlags&MFT_LINE)
  1902.         {
  1903.           lpMIS->itemHeight += 6;
  1904.         }
  1905.       }
  1906.     }
  1907.     else
  1908.     {
  1909.       lpMIS->itemHeight = 3;
  1910.     }
  1911.   }
  1912.   else
  1913.   {
  1914.     CFont m_fontMenu;
  1915.     LOGFONT m_lf;
  1916.     ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  1917.     NONCLIENTMETRICS nm;
  1918.     nm.cbSize = sizeof (NONCLIENTMETRICS);
  1919.     VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS, nm.cbSize,&nm,0)); 
  1920.     m_lf =  nm.lfMenuFont;
  1921.     // Default selection?
  1922.     if(state&ODS_DEFAULT)
  1923.     {
  1924.       // Make the font bold
  1925.       m_lf.lfWeight = FW_BOLD;
  1926.     }
  1928.     m_fontMenu.CreateFontIndirect (&m_lf);
  1929.     
  1930.     // DC of the desktop
  1931.     CClientDC myDC(NULL);
  1932.     
  1933.     // Select menu font in...    
  1934.     CFont* pOldFont = myDC.SelectObject (&m_fontMenu);
  1935.     //Get pointer to text SK
  1936.     const LPCTSTR lpstrText = pMenuData->GetString();
  1937.     SIZE size;
  1938.     VERIFY(::GetTextExtentPoint32(myDC.m_hDC,lpstrText,(int)_tcslen(lpstrText),&size));
  1939.     // Select old font in
  1940.     myDC.SelectObject(pOldFont);  
  1941.   
  1942.     // Set width and height:
  1943.     if(bIsMenuBar)
  1944.     {
  1945.       lpMIS->itemWidth = size.cx ;
  1946.     }
  1947.     else
  1948.     {
  1949.       lpMIS->itemWidth = m_iconX + size.cx + m_iconX + GAP;
  1950.     }
  1952.     // Check the Key-Shortcut
  1953.     if(_tcsstr(lpstrText, _T("t")) != NULL)
  1954.       lpMIS->itemWidth += 15;
  1956.     int temp = GetSystemMetrics(SM_CYMENU);
  1957.     lpMIS->itemHeight = temp>m_iconY+8 ? temp : m_iconY+8;
  1958.     
  1959.     m_fontMenu.DeleteObject();
  1961.     // set status bar as appropriate
  1962.     UINT nItemID = (lpMIS->itemID & 0xFFF0);
  1963.     // Special case for system menu
  1964.     if (nItemID>=SC_SIZE && nItemID<=SC_HOTKEY) 
  1965.     {
  1966.       BOOL bGetNext = FALSE;
  1967.       // search the actual menu item
  1968.       for (int j=0;j<m_MenuList.GetUpperBound();++j)
  1969.       {
  1970.         CNewMenuItemData* pTemp = m_MenuList[j];
  1971.         if(pTemp==pMenuData || bGetNext==TRUE)
  1972.         {
  1973.           bGetNext = TRUE;
  1974.           pTemp = m_MenuList[j+1];
  1975.           if(pTemp->m_nID)
  1976.           {
  1977.             lpMIS->itemData = (ULONG_PTR)pTemp;
  1978.             lpMIS->itemID = pTemp->m_nID; 
  1979.             UINT nOrgWidth = lpMIS->itemWidth;
  1980.             MeasureItem_WinXP(lpMIS,bIsMenuBar);
  1981.             // Restore old values
  1982.             lpMIS->itemData = (ULONG_PTR)pMenuData;
  1983.             lpMIS->itemID = pMenuData->m_nID;
  1984.             lpMIS->itemWidth = max(lpMIS->itemWidth,nOrgWidth);
  1985.             break;
  1986.           }
  1987.         }
  1988.       }
  1989.       lpMIS->itemHeight = temp;
  1990.     } 
  1991.   }
  1992. }
  1994. void CNewMenu::SetIconSize (int width, int height)
  1995. {
  1996.   m_iconX = width;
  1997.   m_iconY = height;
  1998. }
  2000. BOOL CNewMenu::AppendODMenu(LPCTSTR lpstrText,UINT nFlags,UINT nID,int nIconNormal)
  2001. {
  2002.   // Add the MF_OWNERDRAW flag if not specified:
  2003.   if(!nID)
  2004.   {
  2005.     if(nFlags&MF_BYPOSITION)
  2006.       nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  2007.     else
  2008.       nFlags=MF_SEPARATOR|MF_OWNERDRAW;
  2009.   }
  2010.   else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
  2011.   
  2012.   if(nFlags & MF_POPUP)
  2013.   {
  2014.     m_AllSubMenus.Add(UIntToHMenu(nID));
  2015.     m_SubMenus.Add(UIntToHMenu(nID));
  2016.   }
  2017.   
  2018.   CNewMenuItemData *mdata = new CNewMenuItemData;
  2019.   m_MenuList.Add(mdata);
  2020.   mdata->SetString(lpstrText);
  2021.   
  2022.   mdata->m_nMenuIconNormal = nIconNormal;
  2023.   mdata->m_nxOffset=-1;
  2024.   if(nIconNormal>=0)
  2025.   {
  2026.     mdata->m_nxOffset=0;
  2027.     LoadFromToolBar(nID,nIconNormal,mdata->m_nxOffset);
  2028.     if(mdata->m_pBitmap)
  2029.       mdata->m_pBitmap->DeleteImageList();
  2030.     else
  2031.       mdata->m_pBitmap=new(CImageList);
  2032.     mdata->m_pBitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  2033.     if(!AddBitmapToImageList(mdata->m_pBitmap,nIconNormal))
  2034.     {
  2035.       mdata->m_pBitmap->DeleteImageList();
  2036.       delete mdata->m_pBitmap;
  2037.       mdata->m_pBitmap=NULL;
  2038.       mdata->m_nMenuIconNormal = nIconNormal = -1;
  2039.       mdata->m_nxOffset = -1;
  2040.     }
  2041.   }
  2042.   mdata->m_nFlags = nFlags;
  2043.   mdata->m_nID = nID;
  2044.   return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
  2045. }
  2047. BOOL CNewMenu::AppendODMenu(LPCTSTR lpstrText,UINT nFlags,UINT nID,
  2048.                            CImageList *il,int xoffset)
  2049. {
  2050.   // Add the MF_OWNERDRAW flag if not specified:
  2051.   if(!nID)
  2052.   {
  2053.     if(nFlags&MF_BYPOSITION)
  2054.       nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  2055.     else 
  2056.       nFlags=MF_SEPARATOR|MF_OWNERDRAW;
  2057.   }
  2058.   else if(!(nFlags & MF_OWNERDRAW))
  2059.     nFlags |= MF_OWNERDRAW;
  2060.   
  2061.   if(nFlags & MF_POPUP)
  2062.   {
  2063.     m_AllSubMenus.Add(UIntToHMenu(nID));
  2064.     m_SubMenus.Add(UIntToHMenu(nID));
  2065.   }
  2067.   CNewMenuItemData* mdata = new CNewMenuItemData;
  2068.   m_MenuList.Add(mdata);
  2069.   mdata->SetString(lpstrText);
  2071.   if(il)
  2072.   {
  2073.     mdata->m_nMenuIconNormal = 0;
  2074.     mdata->m_nxOffset=0;
  2075.     if(mdata->m_pBitmap)
  2076.       mdata->m_pBitmap->DeleteImageList();
  2077.     else 
  2078.       mdata->m_pBitmap=new(CImageList);
  2079.     
  2080.     ImageListDuplicate(il,xoffset,mdata->m_pBitmap);
  2081.   }
  2082.   else
  2083.   {
  2084.     mdata->m_nMenuIconNormal = -1;
  2085.     mdata->m_nxOffset = -1;
  2086.   }
  2087.   mdata->m_nFlags = nFlags;
  2088.   mdata->m_nID = nID;
  2089.   return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
  2090. }
  2092. BOOL CNewMenu::InsertODMenu(UINT nPosition,LPCTSTR lpstrText,UINT nFlags,UINT nID,
  2093.                            int nIconNormal)
  2094. {
  2095.   if(!(nFlags & MF_BYPOSITION))
  2096.   {
  2097.     int iPosition =0;
  2098.     CNewMenu* pMenu = FindMenuOption(nPosition,iPosition);
  2099.     if(pMenu)
  2100.     {
  2101.       return(pMenu->InsertODMenu(iPosition,lpstrText,nFlags|MF_BYPOSITION,nID,nIconNormal));
  2102.     }
  2103.     else 
  2104.       return(FALSE);
  2105.   }
  2106.   
  2107.   if(!nID)
  2108.     nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  2109.   else if(!(nFlags & MF_OWNERDRAW))
  2110.     nFlags |= MF_OWNERDRAW;
  2111.   
  2112.   if(nFlags & MF_POPUP)
  2113.   {
  2114.     m_AllSubMenus.Add(UIntToHMenu(nID));
  2115.     m_SubMenus.InsertAt(nPosition,UIntToHMenu(nID));
  2116.   }
  2118.   //Stephane Clog suggested adding this, believe it or not it's in the help 
  2119.   if(nPosition==(UINT)-1)
  2120.     nPosition=GetMenuItemCount();
  2122.   CNewMenuItemData *mdata = new CNewMenuItemData;
  2123.   m_MenuList.InsertAt(nPosition,mdata);
  2124.   mdata->SetString(lpstrText);
  2125.   
  2126.   mdata->m_nMenuIconNormal = nIconNormal;
  2127.   mdata->m_nxOffset=-1;
  2128.   if(nIconNormal>=0)
  2129.   {
  2130.     mdata->m_nxOffset=0;
  2131.     LoadFromToolBar(nID,nIconNormal,mdata->m_nxOffset);
  2132.     if(mdata->m_pBitmap)
  2133.       mdata->m_pBitmap->DeleteImageList();
  2134.     else
  2135.       mdata->m_pBitmap=new(CImageList);
  2137.     mdata->m_pBitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  2138.     if(!AddBitmapToImageList(mdata->m_pBitmap,nIconNormal))
  2139.     {
  2140.       mdata->m_pBitmap->DeleteImageList();
  2141.       delete mdata->m_pBitmap;
  2142.       mdata->m_pBitmap=NULL;
  2143.       mdata->m_nMenuIconNormal = nIconNormal = -1;
  2144.       mdata->m_nxOffset = -1;
  2145.     }
  2146.   }
  2147.   mdata->m_nFlags = nFlags;
  2148.   mdata->m_nID = nID;
  2149.   return(CMenu::InsertMenu(nPosition,nFlags,nID,(LPCTSTR)mdata));
  2150. }
  2152. BOOL CNewMenu::InsertODMenu(UINT nPosition,LPCTSTR lpstrText,UINT nFlags,UINT nID,
  2153.                            CImageList *il,int xoffset)
  2154. {
  2155.   if(!(nFlags & MF_BYPOSITION))
  2156.   {
  2157.     int iPosition =0;
  2158.     CNewMenu* pMenu = FindMenuOption(nPosition,iPosition);
  2159.     if(pMenu)
  2160.     {
  2161.       return(pMenu->InsertODMenu(iPosition,lpstrText,nFlags|MF_BYPOSITION,nID,il,xoffset));
  2162.     }
  2163.     else 
  2164.       return(FALSE);
  2165.   }
  2166.   
  2167.   if(!nID)
  2168.     nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  2169.   else if(!(nFlags & MF_OWNERDRAW))
  2170.     nFlags |= MF_OWNERDRAW;
  2171.   
  2172.   if(nFlags & MF_POPUP)
  2173.   {
  2174.     m_AllSubMenus.Add(UIntToHMenu(nID));
  2175.     m_SubMenus.InsertAt(nPosition,UIntToHMenu(nID));
  2176.   }
  2177.   
  2178.   //Stephane Clog suggested adding this, believe it or not it's in the help 
  2179.   if(nPosition==(UINT)-1)
  2180.     nPosition=GetMenuItemCount();
  2181.   
  2182.   CNewMenuItemData *mdata = new CNewMenuItemData;
  2183.   m_MenuList.InsertAt(nPosition,mdata);
  2184.   mdata->SetString(lpstrText);
  2186.   if(il)
  2187.   {
  2188.     mdata->m_nMenuIconNormal = 0;
  2189.     mdata->m_nxOffset=0;
  2190.     if(mdata->m_pBitmap)
  2191.       mdata->m_pBitmap->DeleteImageList();
  2192.     else
  2193.       mdata->m_pBitmap=new(CImageList);
  2194.     ImageListDuplicate(il,xoffset,mdata->m_pBitmap);
  2195.   }
  2196.   else
  2197.   {
  2198.     mdata->m_nMenuIconNormal = -1;
  2199.     mdata->m_nxOffset = -1;
  2200.   }
  2201.   mdata->m_nFlags = nFlags;
  2202.   mdata->m_nID = nID;
  2203.   return(CMenu::InsertMenu(nPosition,nFlags,nID,(LPCTSTR)mdata));
  2204. }
  2206. BOOL CNewMenu::ModifyODMenu(LPCTSTR lpstrText,UINT nID,int nIconNormal)
  2207. {
  2208.   int nLoc;
  2209.   CNewMenuItemData *mdata;
  2210.   CArray<CNewMenu*,CNewMenu*>newSubs;
  2211.   CArray<int,int&>newLocs;
  2213.   // Find the old CNewMenuItemData structure:
  2214.   CNewMenu *psubmenu = FindMenuOption(nID,nLoc);
  2215.   do {
  2216.     if(psubmenu && nLoc>=0)
  2217.       mdata = psubmenu->m_MenuList[nLoc];
  2218.     else
  2219.     {
  2220.       // Create a new CNewMenuItemData structure:
  2221.       mdata = new CNewMenuItemData;
  2222.       m_MenuList.Add(mdata);
  2223.     }
  2225.     ASSERT(mdata);
  2226.     if(lpstrText)
  2227.       mdata->SetString(lpstrText);
  2228.     mdata->m_nMenuIconNormal = nIconNormal;
  2229.     mdata->m_nxOffset=-1;
  2230.     if(nIconNormal>=0)
  2231.     {
  2232.       mdata->m_nxOffset=0;
  2233.       LoadFromToolBar(nID,nIconNormal,mdata->m_nxOffset);
  2234.       if(mdata->m_pBitmap)
  2235.         mdata->m_pBitmap->DeleteImageList();
  2236.       else
  2237.         mdata->m_pBitmap=new CImageList;
  2239.       mdata->m_pBitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  2240.       if(!AddBitmapToImageList(mdata->m_pBitmap,nIconNormal))
  2241.       {
  2242.         mdata->m_pBitmap->DeleteImageList();
  2243.         delete mdata->m_pBitmap;
  2244.         mdata->m_pBitmap=NULL;
  2245.         mdata->m_nMenuIconNormal = nIconNormal = -1;
  2246.         mdata->m_nxOffset = -1;
  2247.       }
  2248.     }
  2249.     mdata->m_nFlags &= ~(MF_BYPOSITION);
  2250.     mdata->m_nFlags |= MF_OWNERDRAW;
  2251.     mdata->m_nID = nID;
  2252.     newSubs.Add(psubmenu);
  2253.     newLocs.Add(nLoc);
  2254.     if(psubmenu && nLoc>=0)
  2255.       psubmenu = FindAnotherMenuOption(nID,nLoc,newSubs,newLocs);
  2256.     else 
  2257.       psubmenu=NULL;
  2258.   
  2259.   }while(psubmenu);
  2261.   return (CMenu::ModifyMenu(nID,mdata->m_nFlags,nID,(LPCTSTR)mdata));
  2262. }
  2264. BOOL CNewMenu::ModifyODMenu(LPCTSTR lpstrText,UINT nID,CImageList *pil,int xoffset)
  2265. {
  2266.   int nLoc;
  2267.   CNewMenuItemData *mdata;
  2268.   CArray<CNewMenu*,CNewMenu*>newSubs;
  2269.   CArray<int,int&>newLocs;
  2270.   
  2271.   // Find the old CNewMenuItemData structure:
  2272.   CNewMenu *psubmenu = FindMenuOption(nID,nLoc);
  2273.   do {
  2274.     if(psubmenu && nLoc>=0)
  2275.     {
  2276.       mdata = psubmenu->m_MenuList[nLoc];
  2277.     }
  2278.     else
  2279.     {
  2280.       // Create a new CNewMenuItemData structure:
  2281.       mdata = new CNewMenuItemData;
  2282.       m_MenuList.Add(mdata);
  2283.     }
  2285.     ASSERT(mdata);
  2286.     if(lpstrText)
  2287.     {
  2288.       mdata->SetString(lpstrText);
  2289.     }
  2291.     if(pil)
  2292.     {
  2293.       mdata->m_nMenuIconNormal = 0;
  2294.       mdata->m_nxOffset=0;
  2295.       if(mdata->m_pBitmap)
  2296.         mdata->m_pBitmap->DeleteImageList();
  2297.       else 
  2298.         mdata->m_pBitmap=new(CImageList);
  2300.       ImageListDuplicate(pil,xoffset,mdata->m_pBitmap);
  2301.       int x=0;
  2302.       int y=0;
  2303.       if(psubmenu && ImageList_GetIconSize(pil->m_hImageList,&x,&y))
  2304.       {
  2305.         // Correct the size of the menuitem
  2306.         psubmenu->m_iconX = max(psubmenu->m_iconX,x);
  2307.         psubmenu->m_iconY = max(psubmenu->m_iconY,y);
  2308.       }
  2309.     }
  2310.     else
  2311.     {
  2312.       mdata->m_nMenuIconNormal = -1;
  2313.       mdata->m_nxOffset = -1;
  2314.     }
  2315.     mdata->m_nFlags &= ~(MF_BYPOSITION);
  2316.     mdata->m_nFlags |= MF_OWNERDRAW;
  2317.     mdata->m_nID = nID;
  2318.     newSubs.Add(psubmenu);
  2319.     newLocs.Add(nLoc);
  2320.     if(psubmenu && nLoc>=0)
  2321.       psubmenu = FindAnotherMenuOption(nID,nLoc,newSubs,newLocs);
  2322.     else 
  2323.       psubmenu=NULL;
  2324.   } while(psubmenu);
  2326.   return (CMenu::ModifyMenu(nID,mdata->m_nFlags,nID,(LPCTSTR)mdata));
  2327. }
  2329. BOOL CNewMenu::ModifyODMenu(LPCTSTR lpstrText,UINT nID,CBitmap *bmp)
  2330. {
  2331.   if (bmp)
  2332.   {
  2333.     CImageList temp;
  2334.     temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  2335.     
  2336.     temp.Add(bmp,GetBitmapBackground());
  2338.     return ModifyODMenu(lpstrText,nID,&temp,0);
  2339.   }
  2340.   return ModifyODMenu(lpstrText,nID,NULL,0);
  2341. }
  2343. BOOL CNewMenu::ModifyODMenu(LPCTSTR lpstrText,UINT nID,COLORREF fill,COLORREF border,int hatchstyle)
  2344. {
  2345.   // Get device context
  2346.   CClientDC DC(0);
  2347.   CSize bitmap_size(m_iconX,m_iconY);
  2348.   CBitmap bmp;
  2349.   ColorBitmap(&DC,bmp,bitmap_size,fill,border,hatchstyle);  
  2350.   return ModifyODMenu(lpstrText,nID,&bmp);
  2351. }
  2353. BOOL CNewMenu::ModifyODMenu(LPCTSTR lpstrText,LPCTSTR OptionText, int nIconNormal)
  2354. {
  2355.   int nIndex = 0;
  2356.   CNewMenu* pOptionMenu = FindMenuOption(OptionText,nIndex);
  2358.   if(pOptionMenu!=NULL && nIndex>=0)
  2359.   {
  2360.     CNewMenuItemData* pmdata = pOptionMenu->m_MenuList[nIndex];
  2361.     if(lpstrText)
  2362.     {
  2363.       pmdata->SetString(lpstrText);
  2364.     }
  2365.     pmdata->m_nMenuIconNormal = nIconNormal;
  2366.     pmdata->m_nxOffset=-1;
  2367.     if(nIconNormal>=0)
  2368.     {
  2369.       pmdata->m_nxOffset=0;
  2370.       if(pmdata->m_pBitmap)
  2371.         pmdata->m_pBitmap->DeleteImageList();
  2372.       else
  2373.         pmdata->m_pBitmap=new(CImageList);
  2375.       if (!m_bDynIcons)
  2376.       {
  2377.         CBitmap temp;
  2378.         // Try to load the bitmap for getting dimension
  2379.         if(temp.LoadBitmap(nIconNormal))
  2380.         {
  2381.           BITMAP bitmap;
  2382.           ZeroMemory(&bitmap,sizeof(bitmap));
  2383.           if(temp.GetBitmap(&bitmap))
  2384.           {
  2385.             pOptionMenu->m_iconX = max(pOptionMenu->m_iconX,bitmap.bmWidth);
  2386.             pOptionMenu->m_iconY = max(pOptionMenu->m_iconY,bitmap.bmHeight);
  2387.           }
  2388.         }
  2389.       }
  2391.       pmdata->m_pBitmap->Create(pOptionMenu->m_iconX,pOptionMenu->m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  2393.       if(!AddBitmapToImageList(pmdata->m_pBitmap,nIconNormal))
  2394.       {
  2395.         pmdata->m_pBitmap->DeleteImageList();
  2396.         delete pmdata->m_pBitmap;
  2397.         pmdata->m_pBitmap=NULL;
  2398.         pmdata->m_nMenuIconNormal = nIconNormal = -1;
  2399.         pmdata->m_nxOffset = -1;
  2400.       }
  2401.     }
  2402.     return TRUE;
  2403.   }
  2404.   return FALSE;
  2405. }
  2407. CNewMenuItemData* CNewMenu::NewODMenu(UINT pos,UINT nFlags,UINT nID,LPCTSTR string)
  2408. {
  2409.   CNewMenuItemData* mdata;
  2411.   mdata = new CNewMenuItemData;
  2412.   mdata->m_nMenuIconNormal = -1;
  2413.   mdata->m_nxOffset=-1;
  2414.   mdata->m_nFlags = nFlags;
  2415.   mdata->m_nID = nID;
  2416.   mdata->SetString (string);
  2418.   //  if(nFlags & MF_POPUP)m_AllSubMenus.Add(UIntToHMenu(nID));
  2420.   if (nFlags&MF_OWNERDRAW)
  2421.   {
  2422.     ASSERT(!(nFlags&MF_STRING));
  2423.     ModifyMenu(pos,nFlags,nID,(LPCTSTR)mdata);
  2424.   }
  2425.   else if (nFlags&MF_BITMAP)
  2426.   {
  2427.     ModifyMenu(pos,nFlags,nID,(CBitmap*)string);
  2428.   }
  2429.   else if (nFlags&MF_SEPARATOR)
  2430.   {
  2431.     ASSERT(nFlags&MF_SEPARATOR);
  2432.     ModifyMenu(pos,nFlags,nID);
  2433.   }
  2434.   else // (nFlags&MF_STRING)
  2435.   {
  2436.     ASSERT(!(nFlags&MF_OWNERDRAW));
  2437.     ModifyMenu(pos,nFlags,nID,mdata->GetString());
  2438.   }
  2439.   
  2440.   return(mdata);
  2441. };
  2443. BOOL CNewMenu::LoadToolBars(const UINT* arID, int n)
  2444. {
  2445.   ASSERT(arID);
  2446.   BOOL returnflag=TRUE;
  2447.   for(int i=0;i<n;++i)
  2448.   {
  2449.     if(!LoadToolBar(arID[i]))
  2450.       returnflag=FALSE;
  2451.   }
  2452.   return(returnflag);
  2453. }
  2455. struct CToolBarData
  2456. {
  2457.   WORD wVersion;
  2458.   WORD wWidth;
  2459.   WORD wHeight;
  2460.   WORD wItemCount;
  2461.   //WORD aItems[wItemCount]
  2463.   WORD* items()
  2464.     { return (WORD*)(this+1); }
  2465. };
  2467. BOOL CNewMenu::LoadToolBar(LPCTSTR lpszResourceName)
  2468. {
  2469.   ASSERT_VALID(this);
  2470.   ASSERT(lpszResourceName != NULL);
  2472.   // determine location of the bitmap in resource
  2473.   HINSTANCE hInst = AfxFindResourceHandle(lpszResourceName, RT_TOOLBAR);
  2474.   HRSRC hRsrc = ::FindResource(hInst, lpszResourceName, RT_TOOLBAR);
  2475.   if (hRsrc == NULL)
  2476.     return FALSE;
  2478.   HGLOBAL hGlobal = LoadResource(hInst, hRsrc);
  2479.   if (hGlobal == NULL)
  2480.     return FALSE;
  2482.   CToolBarData* pData = (CToolBarData*)LockResource(hGlobal);
  2483.   if (pData == NULL)
  2484.     return FALSE;
  2485.   ASSERT(pData->wVersion == 1);
  2487.   CImageList myImageList;
  2488.   myImageList.Create(pData->wWidth,pData->wHeight,ILC_COLORDDB|ILC_MASK,0,10);
  2489.   // load bitmap now that sizes are known by the toolbar control
  2490.   BOOL bResult = AddBitmapToImageList(&myImageList,(UINT)(UINT_PTR)lpszResourceName);
  2491.   
  2492.   if (bResult)
  2493.   {
  2494.     m_iconX = max(pData->wWidth,m_iconX);
  2495.     m_iconY = max(pData->wHeight,m_iconY);
  2497.     int xoffset=0;
  2498.     for (int i = 0; i < pData->wItemCount; i++)
  2499.     { 
  2500.       UINT nID = pData->items()[i];
  2501.       if (nID)
  2502.       {
  2503.         ModifyODMenu(NULL,nID,&myImageList,xoffset++);
  2504.       }
  2505.     }
  2506.   }
  2508.   UnlockResource(hGlobal);
  2509.   FreeResource(hGlobal);
  2511.   return bResult;
  2512. }
  2514. struct SToolInfo
  2515. {
  2516.   WORD wBitmapID;
  2517.   WORD wWidth;
  2518.   WORD wHeight;
  2520.   WORD* ids(){ return (WORD*)(this+1); }
  2521. };
  2523. BOOL CNewMenu::LoadToolBar(WORD* pToolInfo, COLORREF crTransparent)
  2524. {
  2525.   COLORREF oldColor = m_bitmapBackground;
  2526.   if(crTransparent!=CLR_NONE)
  2527.   { 
  2528.     oldColor = SetBitmapBackground(crTransparent);
  2529.   }  
  2530.   SToolInfo* pInfo = (SToolInfo*)pToolInfo; 
  2531.   CImageList myImageList;
  2532.   myImageList.Create(pInfo->wWidth,pInfo->wHeight,ILC_COLORDDB|ILC_MASK,0,10);
  2533.   // load bitmap now that sizes are known by the toolbar control
  2534.   BOOL bResult = AddBitmapToImageList(&myImageList,pInfo->wBitmapID);
  2535.   
  2536.   if (bResult)
  2537.   {
  2538.     WORD* pID = pInfo->ids();
  2539.     int nIndex=0;
  2540.     while(*pID)
  2541.     {
  2542.       ModifyODMenu(NULL,*pID++,&myImageList,nIndex++);
  2543.     }
  2544.   }
  2545.   SetBitmapBackground(oldColor);
  2546.   return bResult;
  2547. }
  2549. BOOL CNewMenu::LoadToolBar(UINT nToolBar)
  2550. {
  2551.   return LoadToolBar((LPCTSTR)(UINT_PTR)nToolBar);
  2552. }
  2554. BOOL CNewMenu::LoadFromToolBar(UINT nID,UINT nToolBar,int& xoffset)
  2555. {
  2556.   int xset,offset;
  2557.   UINT nStyle;
  2558.   BOOL returnflag=FALSE;
  2559.   CToolBar bar;
  2561.   CWnd* pWnd = AfxGetMainWnd();
  2562.   if (pWnd == NULL)
  2563.   {
  2564.     pWnd = CWnd::GetDesktopWindow();
  2565.   }
  2566.   bar.Create(pWnd);
  2568.   if(bar.LoadToolBar(nToolBar))
  2569.   {
  2570.     offset=bar.CommandToIndex(nID);
  2571.     if(offset>=0)
  2572.     {
  2573.       bar.GetButtonInfo(offset,nID,nStyle,xset);
  2574.       if(xset>0)
  2575.         xoffset=xset;
  2576.       returnflag=TRUE;
  2577.     }
  2578.   }
  2579.   return returnflag;
  2580. }
  2582. // O.S.
  2583. CNewMenuItemData* CNewMenu::FindMenuItem(UINT nID)
  2584. {
  2585.   CNewMenuItemData *pData = NULL;
  2586.   int i;
  2587.   
  2588.   for(i = 0; i <= m_MenuList.GetUpperBound(); i++)
  2589.   {
  2590.     if (m_MenuList[i]->m_nID == nID)
  2591.     {
  2592.       pData = m_MenuList[i];
  2593.       break;
  2594.     }
  2595.   }
  2596.   if (!pData)
  2597.   {
  2598.     int loc;
  2599.     CNewMenu *pMenu = FindMenuOption(nID, loc);
  2600.     ASSERT(pMenu != this);
  2601.     if (loc >= 0)
  2602.     {
  2603.       return pMenu->FindMenuItem(nID);
  2604.     }
  2605.   }
  2606.   return pData;
  2607. }
  2610. CNewMenu* CNewMenu::FindAnotherMenuOption(int nId,int& nLoc,
  2611.                                           CArray<CNewMenu*,CNewMenu*>&newSubs,
  2612.                                           CArray<int,int&>&newLocs)
  2613. {
  2614.   int i,numsubs,j;
  2615.   CNewMenu *psubmenu,*pgoodmenu;
  2616.   BOOL foundflag;
  2617.   
  2618.   for(i=0;i<(int)(GetMenuItemCount());++i)
  2619.   {
  2620.     psubmenu = DYNAMIC_DOWNCAST(CNewMenu,GetSubMenu(i));
  2621.     if(psubmenu)
  2622.     {
  2623.       pgoodmenu=psubmenu->FindAnotherMenuOption(nId,nLoc,newSubs,newLocs);
  2624.       if(pgoodmenu)
  2625.         return(pgoodmenu);
  2626.     }
  2627.     else if(nId==(int)GetMenuItemID(i))
  2628.     {
  2629.       numsubs = (int)newSubs.GetSize();
  2630.       foundflag=TRUE;
  2631.       for(j=0;j<numsubs;++j)
  2632.       {
  2633.         if(newSubs[j]==this&&newLocs[j]==i)
  2634.         {
  2635.           foundflag=FALSE;
  2636.           break;
  2637.         }
  2638.       }
  2639.       if(foundflag)
  2640.       {
  2641.         nLoc=i;
  2642.         return(this);
  2643.       }
  2644.     }
  2645.   }
  2646.   nLoc = -1;
  2647.   return(NULL);
  2648. }
  2650. CNewMenu* CNewMenu::FindMenuOption(int nId, int& nLoc)
  2651. {
  2652.   int i;
  2653.   CNewMenu *psubmenu,*pgoodmenu;
  2654.   
  2655.   for(i=0;i<(int)(GetMenuItemCount());++i)
  2656.   {
  2657.     psubmenu = DYNAMIC_DOWNCAST(CNewMenu,GetSubMenu(i));
  2658.     if(psubmenu)
  2659.     {
  2660.       pgoodmenu=psubmenu->FindMenuOption(nId,nLoc);
  2661.       if(pgoodmenu)
  2662.         return(pgoodmenu);
  2663.     }
  2664.     else if(nId==(int)GetMenuItemID(i))
  2665.     {
  2666.       nLoc=i;
  2667.       return(this);
  2668.     }
  2669.   }
  2670.   nLoc = -1;
  2671.   return NULL;
  2672. }
  2674. CNewMenu* CNewMenu::FindMenuOption(LPCTSTR lpstrText, int& nLoc)
  2675. { 
  2676.   int i;
  2677.   // First look for all item text.
  2678.   for(i=0;i<=(int)m_MenuList.GetUpperBound();++i)
  2679.   {  
  2680.     if(m_MenuList[i]->m_szMenuText.Compare(lpstrText)==NULL)
  2681.     {
  2682.       nLoc = i;
  2683.       return this;
  2684.     }
  2685.   }
  2686.   CNewMenu* psubmenu;
  2687.   // next, look in all submenus
  2688.   for(i=0; i<(int)(GetMenuItemCount());++i)
  2689.   {
  2690.     psubmenu = DYNAMIC_DOWNCAST(CNewMenu,GetSubMenu(i));
  2691.     if(psubmenu)
  2692.     {
  2693.       psubmenu = psubmenu->FindMenuOption(lpstrText,nLoc);
  2694.       if(psubmenu)
  2695.       {
  2696.         return psubmenu;
  2697.       }
  2698.     }
  2699.   }
  2700.   nLoc = -1;
  2701.   return NULL;
  2702. } 
  2704. BOOL CNewMenu::LoadMenu(HMENU hMenu)
  2705. {
  2706.   if(!::IsMenu(hMenu) || !Attach(hMenu))
  2707.   {
  2708.     return FALSE;
  2709.   } 
  2710.   for(int i=0;i<(int)(GetMenuItemCount());++i)
  2711.   { 
  2712.     HMENU hSubMenu = ::GetSubMenu(m_hMenu,i);
  2713.     if(hSubMenu)
  2714.     {
  2715.       CNewMenu* pMenu = new CNewMenu(m_hMenu);
  2716.       m_SubMenus.Add(hSubMenu);
  2717.       pMenu->LoadMenu(hSubMenu); 
  2718.     }
  2719.   }  
  2720.   SynchronizeMenu();
  2721.   return TRUE;
  2722. }
  2724. BOOL CNewMenu::LoadMenu(int nResource)
  2725. {
  2726.   return(CNewMenu::LoadMenu(MAKEINTRESOURCE(nResource)));
  2727. }
  2729. BOOL CNewMenu::LoadMenu(LPCTSTR lpszResourceName)
  2730. {
  2731.   ASSERT_VALID(this);
  2732.   ASSERT(lpszResourceName != NULL);
  2733.   
  2734.   // Find the Menu Resource:
  2735.   HINSTANCE m_hInst = AfxFindResourceHandle(lpszResourceName,RT_MENU);
  2736.   HRSRC hRsrc = ::FindResource(m_hInst,lpszResourceName,RT_MENU);
  2737.   if(hRsrc == NULL)
  2738.     return FALSE;
  2739.   
  2740.   // Load the Menu Resource:
  2741.   HGLOBAL hGlobal = LoadResource(m_hInst, hRsrc);
  2742.   if(hGlobal == NULL)
  2743.     return FALSE;
  2744.   
  2745.   // Attempt to create us as a menu...  
  2746.   if(!CMenu::CreateMenu())
  2747.     return FALSE;
  2749.   // Get Item template Header, and calculate offset of MENUITEMTEMPLATES
  2750.   MENUITEMTEMPLATEHEADER* pTpHdr= (MENUITEMTEMPLATEHEADER*)LockResource(hGlobal);
  2751.   BYTE* pTp=(BYTE*)pTpHdr +  (sizeof(MENUITEMTEMPLATEHEADER) + pTpHdr->offset);
  2752.   
  2753.   MENUITEMTEMPLATE* pTemplate = (MENUITEMTEMPLATE*)pTp;
  2754.   // Variables needed during processing of Menu Item Templates:
  2755.   
  2756.   // ID of the Menu Item
  2757.   WORD dwID  = 0;
  2758.   CString  szCaption;
  2759.   // Popup menu stack
  2760.   CTypedPtrArray<CPtrArray, CNewMenu*>  m_Stack;
  2761.   // Popup menu stack
  2762.   CArray<BOOL,BOOL>  m_StackEnd;
  2763.   // Add it to this...
  2764.   m_Stack.Add(this);
  2765.   m_StackEnd.Add(FALSE);
  2766.   
  2767.   do{
  2768.     WORD wFlags = pTemplate->mtOption; 
  2769.     // Obtain Flags and (if necessary), the ID...
  2770.     if(!(wFlags & MF_POPUP))
  2771.     {
  2772.       dwID = pTemplate->mtID;
  2773.       #ifdef UNICODE
  2774.         szCaption = pTemplate->mtString;
  2775.       #else
  2776.         szCaption.Format("%S",pTemplate->mtString);
  2777.       #endif 
  2778.           
  2779.       pTemplate = (MENUITEMTEMPLATE*)(DWORD_PTR)((DWORD)(DWORD_PTR)(pTemplate+1) +
  2780.                                       wcslen(pTemplate->mtString)*sizeof(wchar_t));
  2781.     }
  2782.     else
  2783.     {
  2784.       dwID = 0;
  2786.       #ifdef UNICODE
  2787.         szCaption = (wchar_t*)&pTemplate->mtID;
  2788.       #else
  2789.         szCaption.Format("%S",(wchar_t*)&pTemplate->mtID);
  2790.       #endif 
  2791.           
  2792.       pTemplate = (MENUITEMTEMPLATE*)(DWORD_PTR)((DWORD)(DWORD_PTR)(pTemplate+1) +
  2793.                                       wcslen(pTemplate->mtString)*sizeof(wchar_t));
  2794.     }
  2795.     // Handle popup menus first....
  2796.     if(wFlags & MF_POPUP)
  2797.     {
  2798.       if(wFlags & MF_END)
  2799.       {
  2800.         m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
  2801.         wFlags &= ~MF_END;
  2802.       }
  2804.       CNewMenu* pParent = m_Stack[m_Stack.GetUpperBound()];
  2805.       CNewMenu* pSubMenu = new CNewMenu(pParent->m_hMenu);
  2807.       pSubMenu->m_unselectcheck=m_unselectcheck;
  2808.       pSubMenu->m_selectcheck=m_selectcheck;
  2809.       pSubMenu->checkmaps=checkmaps;
  2810.       pSubMenu->checkmapsshare=TRUE;
  2811.       pSubMenu->CreatePopupMenu();
  2813.       // Append it to the top of the stack:
  2814.       pParent->AppendODMenu(szCaption,wFlags,HMenuToUInt(pSubMenu->m_hMenu), -1);
  2815.       m_Stack.Add(pSubMenu);
  2816.       m_StackEnd.Add(FALSE);
  2817.     }
  2818.     else
  2819.     {
  2820.       m_Stack[m_Stack.GetUpperBound()]->AppendODMenu(szCaption,wFlags&~MF_END,dwID,-1);
  2822.       if(wFlags & MF_END)
  2823.         m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
  2825.       for(int j=(int)m_Stack.GetUpperBound(); j>=0 && m_StackEnd.GetAt(j) ; --j)
  2826.       {
  2827.         m_Stack.RemoveAt(j);
  2828.         m_StackEnd.RemoveAt(j);
  2829.       }
  2830.     }
  2831.   }
  2832.   while(m_Stack.GetUpperBound() != -1);
  2833.   return(TRUE);
  2834. }
  2836. void CNewMenu::LoadCheckmarkBitmap(int unselect, int select)
  2837. {
  2838.   if(unselect>0 && select>0)
  2839.   {
  2840.     m_selectcheck=select;
  2841.     m_unselectcheck=unselect;
  2842.     if(checkmaps)
  2843.       checkmaps->DeleteImageList();
  2844.     else
  2845.       checkmaps=new(CImageList);
  2847.     checkmaps->Create(m_iconX,m_iconY,ILC_MASK,2,1);
  2848.     BOOL flag1=AddBitmapToImageList(checkmaps,unselect);
  2849.     BOOL flag2=AddBitmapToImageList(checkmaps,select);
  2851.     if(!flag1||!flag2)
  2852.     {
  2853.       checkmaps->DeleteImageList();
  2854.       delete checkmaps;
  2855.       checkmaps=NULL;
  2856.     }
  2857.   }
  2858. }
  2860. BOOL CNewMenu::GetMenuText(UINT id, CString& string, UINT nFlags/*= MF_BYPOSITION*/)
  2861. {
  2862.   BOOL returnflag=FALSE;
  2864.   if(MF_BYPOSITION&nFlags)
  2865.   {
  2866.     UINT numMenuItems = (int)m_MenuList.GetUpperBound();
  2867.     if(id<=numMenuItems)
  2868.     {
  2869.       string=m_MenuList[id]->GetString();
  2870.       returnflag=TRUE;
  2871.     }
  2872.   }
  2873.   else
  2874.   {
  2875.     int uiLoc;
  2876.     CNewMenu* pMenu = FindMenuOption(id,uiLoc);
  2877.     if(NULL!=pMenu)
  2878.     {
  2879.       returnflag = pMenu->GetMenuText(uiLoc,string);
  2880.     }
  2881.   }
  2882.   return returnflag;
  2883. }
  2885. CNewMenuItemData *CNewMenu::FindMenuList(UINT nID)
  2886. {
  2887.   for(int i=0;i<=m_MenuList.GetUpperBound();++i)
  2888.   {
  2889.     if(m_MenuList[i]->m_nID==nID && !m_MenuList[i]->m_nSyncFlag)
  2890.     {
  2891.       m_MenuList[i]->m_nSyncFlag=1;
  2892.       return(m_MenuList[i]);
  2893.     }
  2894.   }
  2895.   return(NULL);
  2896. }
  2898. void CNewMenu::InitializeMenuList(int value)
  2899. {
  2900.   for(int i=0;i<=m_MenuList.GetUpperBound();++i)
  2901.   {
  2902.     m_MenuList[i]->m_nSyncFlag=value;
  2903.   }
  2904. }
  2906. void CNewMenu::DeleteMenuList()
  2907. {
  2908.   for(int i=0;i<=m_MenuList.GetUpperBound();++i)
  2909.   {
  2910.     if(!m_MenuList[i]->m_nSyncFlag)
  2911.     {
  2912.       delete m_MenuList[i];
  2913.     }
  2914.   }
  2915. }
  2917. void CNewMenu::SynchronizeMenu()
  2918. {
  2919.   CTypedPtrArray<CPtrArray, CNewMenuItemData*> temp;
  2920.   CNewMenuItemData *mdata;
  2921.   CString string;
  2922.   UINT submenu,nID=0,state,j;
  2924.   InitializeMenuList(0);
  2925.   for(j=0;j<GetMenuItemCount();++j)
  2926.   {
  2927.     mdata=NULL;
  2928.     state=GetMenuState(j,MF_BYPOSITION);
  2930.     if(state&MF_POPUP)
  2931.     {
  2932.       submenu=HMenuToUInt(GetSubMenu(j)->m_hMenu);
  2933.       mdata=FindMenuList(submenu);
  2934.       GetMenuString(j,string,MF_BYPOSITION);
  2936.       if(!mdata)
  2937.       {
  2938.         mdata=NewODMenu(j,(state&0xFF)|MF_BYPOSITION|MF_POPUP|MF_OWNERDRAW,submenu,string);
  2939.       }
  2940.       else if(!string.IsEmpty ())
  2941.       { 
  2942.         mdata->SetString(string);  
  2943.       }
  2944.     }
  2945.     else if(state&MF_SEPARATOR)
  2946.     {
  2947.       mdata=FindMenuList(0);
  2948.       if(!mdata)
  2949.         mdata=NewODMenu(j,state|MF_BYPOSITION|MF_SEPARATOR|MF_OWNERDRAW,0,_T(""));
  2950.       else 
  2951.         ModifyMenu(j,mdata->m_nFlags,nID,(LPCTSTR)mdata);
  2952.     }
  2953.     else
  2954.     {
  2955.       nID=GetMenuItemID(j);
  2956.       mdata=FindMenuList(nID);
  2957.       GetMenuString(j,string,MF_BYPOSITION);
  2958.       
  2959.       if(!mdata)
  2960.       {
  2961.         mdata=NewODMenu(j,state|MF_BYPOSITION|MF_OWNERDRAW,nID,string);
  2962.       }
  2963.       else
  2964.       {
  2965.         mdata->m_nFlags=state|MF_BYPOSITION|MF_OWNERDRAW;
  2966.         if(string.GetLength()>0)
  2967.         {
  2968.           mdata->SetString(string);
  2969.         }
  2970.         ModifyMenu(j,mdata->m_nFlags,nID,(LPCTSTR)mdata);
  2971.       }
  2972.     }
  2973.     if(mdata)
  2974.       temp.Add(mdata);
  2975.   }
  2976.   DeleteMenuList();
  2977.   m_MenuList.RemoveAll();
  2978.   m_MenuList.Append(temp);
  2979.   temp.RemoveAll(); 
  2980. }
  2982. void CNewMenu::OnInitMenuPopup(HWND hWnd, CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
  2983. {
  2984.   UNREFERENCED_PARAMETER(nIndex);
  2985.   UNREFERENCED_PARAMETER(bSysMenu);
  2987. #ifdef _TRACE_MENU_
  2988.   TRACE(_T("InitMenuPopup: 0x%lx from Wnd 0x%lxn"),HMenuToUInt(pPopupMenu->m_hMenu),HWndToUInt(hWnd));
  2989. #endif
  2990.   CNewMenuHook::m_hLastMenu = pPopupMenu->m_hMenu;
  2992.   if(pPopupMenu->m_hMenu)
  2993.   {
  2994.     CNewMenu* pSubmenu = DYNAMIC_DOWNCAST(CNewMenu,pPopupMenu);
  2995.     if(pSubmenu)
  2996.     {
  2997.       pSubmenu->OnInitMenuPopup();
  2998.       HMENU hMenu = pSubmenu->GetParent();
  2999.       CNewMenu* pParent = DYNAMIC_DOWNCAST(CNewMenu,CMenu::FromHandlePermanent(hMenu));
  3000.       if(pParent)
  3001.       {
  3002.         pParent->m_dwOpenMenu += 1;
  3003.         if(pParent->m_dwOpenMenu==1 && !pParent->m_bIsPopupMenu)
  3004.         {
  3005.           // Redraw the menubar for the shade
  3006.           DrawMenuBar(hWnd);
  3007.         }
  3008.       }
  3009.     }
  3010.   }
  3011. }
  3013. BOOL CNewMenu::Replace(UINT nID,UINT nNewID)
  3014. {
  3015.   int nLoc=0;
  3016.   CNewMenu* pTempMenu = FindMenuOption(nID,nLoc);
  3017.   if(pTempMenu && nLoc >= 0)
  3018.   {
  3019.     CNewMenuItemData* pData = pTempMenu->m_MenuList[nLoc];
  3020.     UINT nFlags = pData->m_nFlags|MF_OWNERDRAW|MF_BYPOSITION;
  3021.     pData->m_nID = nNewID;
  3022.     pTempMenu->ModifyMenu(nLoc,nFlags,nNewID,(LPCTSTR)pData);
  3023.     return TRUE;
  3024.   }
  3025.   return FALSE;
  3026. }
  3028. void CNewMenu::OnInitMenuPopup()
  3029. {
  3030.   m_bIsPopupMenu = true;
  3031.   SynchronizeMenu();
  3032.   // Special purpose for windows XP with themes!!!
  3033.   Replace(SC_RESTORE,SC_RESTORE+1);
  3034.   Replace(SC_CLOSE,SC_CLOSE+1);
  3035.   Replace(SC_MINIMIZE,SC_MINIMIZE+1);
  3036. }
  3038. BOOL CNewMenu::OnUnInitPopupMenu()
  3039. {
  3040.   // Special purpose for windows XP with themes!!!
  3041.   // Restore old values otherwise you have disabled windowbuttons
  3042.   Replace(SC_RESTORE+1,SC_RESTORE);
  3043.   Replace(SC_CLOSE+1,SC_CLOSE);
  3044.   Replace(SC_MINIMIZE+1,SC_MINIMIZE);
  3046.   HMENU hMenu = GetParent();
  3047.   CNewMenu* pParent = DYNAMIC_DOWNCAST(CNewMenu,CMenu::FromHandlePermanent(hMenu));
  3048.   if(pParent)
  3049.   {
  3050.     pParent->m_dwOpenMenu -= 1;
  3051.     if(pParent->m_dwOpenMenu==NULL && !pParent->m_bIsPopupMenu)
  3052.     {
  3053.       return TRUE;
  3054.     }
  3055.   }
  3056.   return FALSE;
  3057. }
  3059. LRESULT CNewMenu::FindKeyboardShortcut(UINT nChar, UINT nFlags, CMenu *pMenu)
  3060. {
  3061.   UNREFERENCED_PARAMETER(nFlags);
  3063.   CNewMenu* pNewMenu = DYNAMIC_DOWNCAST(CNewMenu,pMenu);
  3064.   if(pNewMenu)
  3065.   {
  3066.     //SK: modified for Unicode correctness
  3067.     CString key(_T('&'),2);
  3068.     key.SetAt(1,(TCHAR)nChar);
  3069.     key.MakeLower();
  3070.     CString menutext;
  3071.     int menusize = (int)pNewMenu->GetMenuItemCount();
  3072.     if(menusize!=(pNewMenu->m_MenuList.GetUpperBound()+1))
  3073.     {
  3074.       pNewMenu->SynchronizeMenu();
  3075.     }
  3076.     for(int i=0;i<menusize;++i)
  3077.     {
  3078.       if(pNewMenu->GetMenuText(i,menutext))
  3079.       {
  3080.         menutext.MakeLower();
  3081.         if(menutext.Find(key)>=0)
  3082.         {
  3083.           return(MAKELRESULT(i,2));
  3084.         }
  3085.       }
  3086.     }
  3087.   }
  3088.   return NULL;
  3089. }
  3091. BOOL CNewMenu::AddBitmapToImageList(CImageList *bmplist,UINT nResourceID)
  3092. {
  3093.   // O.S.
  3094.   if (m_bDynIcons)
  3095.   {
  3096.     bmplist->Add((HICON)(UINT_PTR)nResourceID);
  3097.     return TRUE;
  3098.   }
  3100.   CBitmap mybmp;
  3101.   HBITMAP hbmp = LoadSysColorBitmap(nResourceID);
  3102.   if(hbmp)
  3103.   {
  3104.     // Object will be destroyd by destructor of CBitmap
  3105.     mybmp.Attach(hbmp);
  3106.   }
  3107.   else
  3108.   {  
  3109.     mybmp.LoadBitmap(nResourceID);
  3110.   }
  3112.   if (mybmp.m_hObject && bmplist->Add(&mybmp,GetBitmapBackground())>=0 )
  3113.   {
  3114.     return TRUE;
  3115.   }
  3117.   return FALSE;
  3118. }
  3120. COLORREF CNewMenu::SetBitmapBackground(COLORREF newColor)
  3121. {
  3122.   COLORREF oldColor = m_bitmapBackground;
  3123.   m_bitmapBackground = newColor;
  3124.   return oldColor;
  3125. }
  3127. COLORREF CNewMenu::GetBitmapBackground()
  3128. {
  3129.   if(m_bitmapBackground==CLR_DEFAULT)
  3130.     return GetSysColor(COLOR_3DFACE);
  3132.   return m_bitmapBackground;
  3133. }
  3136. // Given a toolbar, append all the options from it to this menu
  3137. // Passed a ptr to the toolbar object and the toolbar ID
  3138. // Author : Robert Edward Caldecott
  3139. void CNewMenu::AddFromToolBar(CToolBar* pToolBar, int nResourceID)
  3140. {
  3141.   for (int i = 0; i < pToolBar->GetCount(); i++) 
  3142.   {
  3143.     UINT nID = pToolBar->GetItemID(i);
  3144.     // See if this toolbar option
  3145.     // appears as a command on this
  3146.     // menu or is a separator
  3147.     if (nID == 0 || GetMenuState(nID, MF_BYCOMMAND) == 0xFFFFFFFF)
  3148.       continue; // Item doesn't exist
  3149.     UINT nStyle;
  3150.     int nImage;
  3151.     // Get the toolbar button info
  3152.     pToolBar->GetButtonInfo(i, nID, nStyle, nImage);
  3153.     // OK, we have the command ID of the toolbar
  3154.     // option, and the tollbar bitmap offset
  3155.     int nLoc;
  3156.     CNewMenuItemData* pData;
  3157.     CNewMenu *pSubMenu = FindMenuOption(nID, nLoc);
  3158.     if (pSubMenu && nLoc >= 0)
  3159.     {
  3160.       pData = pSubMenu->m_MenuList[nLoc];
  3161.     }
  3162.     else 
  3163.     {
  3164.       // Create a new CNewMenuItemData structure
  3165.       pData = new CNewMenuItemData;
  3166.       m_MenuList.Add(pData);
  3167.     }
  3168.     // Set some default structure members
  3169.     pData->m_nMenuIconNormal = nResourceID;
  3170.     pData->m_nID = nID;
  3171.     pData->m_nFlags =  MF_BYCOMMAND | MF_OWNERDRAW;
  3172.     pData->m_nxOffset = nImage;
  3173.     if (pData->m_pBitmap)
  3174.       pData->m_pBitmap->DeleteImageList();
  3175.     else
  3176.       pData->m_pBitmap = new CImageList;
  3178.     pData->m_pBitmap->Create(m_iconX, m_iconY,ILC_COLORDDB|ILC_MASK, 1, 1);
  3180.     if(!AddBitmapToImageList(pData->m_pBitmap, nResourceID))
  3181.     {
  3182.       pData->m_pBitmap->DeleteImageList();
  3183.       delete pData->m_pBitmap;
  3184.       pData->m_pBitmap=NULL;
  3185.       pData->m_nMenuIconNormal = -1;
  3186.       pData->m_nxOffset = -1;
  3187.     }    
  3188.     // Modify our menu
  3189.     ModifyMenu(nID,pData->m_nFlags,nID,(LPCTSTR)pData);
  3190.   }
  3191. }
  3193. BOOL CNewMenu::Draw3DCheckmark(CDC *pDC, const CRect& rc, HBITMAP hbmCheck, DWORD dwStyle)
  3194. {
  3195.   CRect rect(rc);
  3196.   rect.InflateRect (-1,-1);
  3198.   if (IsNewShell()) //SK: looks better on the old shell
  3199.     pDC->DrawEdge(rect, BDR_SUNKENOUTER, BF_RECT);
  3201.   rect.InflateRect (2,2);
  3202.   if (!hbmCheck)
  3203.   {
  3204.     // Checkmark
  3205.     rect.OffsetRect(1,2);
  3206.     DrawSpecialCharStyle(pDC,rect,98,dwStyle);
  3207.   }
  3208.   else
  3209.   {
  3210.     // Bullet
  3211.     DrawSpecialCharStyle(pDC,rect,105,dwStyle);
  3212.   }
  3213.   return TRUE;
  3214. }
  3216. WORD CNewMenu::NumBitmapColors(LPBITMAPINFOHEADER lpBitmap)
  3217. {
  3218.   if ( lpBitmap->biClrUsed != 0)
  3219.     return (WORD)lpBitmap->biClrUsed;
  3220.   
  3221.   switch (lpBitmap->biBitCount)
  3222.   {
  3223.   case 1:
  3224.     return 2;
  3225.   case 4:
  3226.     return 16;
  3227.   case 8:
  3228.     return 256;
  3229.   }
  3230.   return 0;
  3231. }
  3233. HBITMAP CNewMenu::LoadSysColorBitmap(int nResourceId)
  3234. {
  3235.   HINSTANCE hInst = AfxFindResourceHandle(MAKEINTRESOURCE(nResourceId),RT_BITMAP);
  3236.   HRSRC hRsrc = ::FindResource(hInst,MAKEINTRESOURCE(nResourceId),RT_BITMAP);
  3237.   if (hRsrc == NULL)
  3238.     return NULL;
  3240.   // determine how many colors in the bitmap
  3241.   HGLOBAL hglb;
  3242.   if ((hglb = LoadResource(hInst, hRsrc)) == NULL)
  3243.     return NULL;
  3244.   LPBITMAPINFOHEADER lpBitmap = (LPBITMAPINFOHEADER)LockResource(hglb);
  3245.   if (lpBitmap == NULL)
  3246.     return NULL;
  3247.   WORD numcol = NumBitmapColors(lpBitmap);
  3248.   ::FreeResource(hglb);
  3250.   if(numcol!=16)
  3251.   {
  3252.     return(NULL);
  3253.   }
  3254.   return AfxLoadSysColorBitmap(hInst, hRsrc, FALSE);
  3255. }
  3257. BOOL CNewMenu::RemoveMenu(UINT uiId,UINT nFlags)
  3258. {
  3259.   if(MF_BYPOSITION&nFlags)
  3260.   {
  3261.     UINT uint = GetMenuState(uiId,MF_BYPOSITION);
  3262.     if(uint&MF_SEPARATOR && !(uint&MF_POPUP))
  3263.     {
  3264.       delete m_MenuList.GetAt(uiId);
  3265.       m_MenuList.RemoveAt(uiId);
  3266.     }
  3267.     else
  3268.     {
  3269.       CNewMenu* pSubMenu = (CNewMenu*) GetSubMenu(uiId);
  3270.       if(NULL==pSubMenu)
  3271.       {
  3272.         UINT uiCommandId = GetMenuItemID(uiId);
  3273.         for(int i=0;i<m_MenuList.GetSize(); i++)
  3274.         {
  3275.           if(m_MenuList[i]->m_nID==uiCommandId)
  3276.           {
  3277.             delete m_MenuList.GetAt(i);
  3278.             m_MenuList.RemoveAt(i);
  3279.             break;
  3280.           }
  3281.         }
  3282.       }
  3283.       else
  3284.       {
  3285.         int numSubMenus = (int)m_SubMenus.GetUpperBound();
  3286.         for(int m = numSubMenus; m >= 0; m--)
  3287.         {
  3288.           if(m_SubMenus[m]==pSubMenu->m_hMenu)
  3289.           {
  3290.             int numAllSubMenus = (int)m_AllSubMenus.GetUpperBound();
  3291.             for(int n = numAllSubMenus; n>= 0; n--)
  3292.             {
  3293.               if(m_AllSubMenus[n]==m_SubMenus[m])
  3294.                 m_AllSubMenus.RemoveAt(n);
  3295.             }
  3296.             m_SubMenus.RemoveAt(m);
  3297.           }
  3298.         }
  3299.         int num = pSubMenu->GetMenuItemCount();
  3300.         for(int i=num-1;i>=0;--i)
  3301.         {
  3302.           pSubMenu->RemoveMenu(i,MF_BYPOSITION);
  3303.         }
  3304.         for(i=(int)m_MenuList.GetUpperBound();i>=0;i--)
  3305.         {
  3306.           if(m_MenuList[i]->m_nID==HMenuToUInt(pSubMenu->m_hMenu) )
  3307.           {
  3308.             delete m_MenuList.GetAt(i);
  3309.             m_MenuList.RemoveAt(i);
  3310.             break;
  3311.           }
  3312.         }
  3313.         delete pSubMenu;
  3314.       }
  3315.     }
  3316.   }
  3317.   else
  3318.   {
  3319.     int iPosition =0;
  3320.     CNewMenu* pMenu = FindMenuOption(uiId,iPosition);
  3321.     if(pMenu)
  3322.     {
  3323.       return pMenu->RemoveMenu(iPosition,MF_BYPOSITION);
  3324.     }
  3325.   }
  3326.   return CMenu::RemoveMenu(uiId,nFlags);
  3327. }
  3329. BOOL CNewMenu::DeleteMenu(UINT uiId,UINT nFlags)
  3330. {
  3331.   if(MF_BYPOSITION&nFlags)
  3332.   {
  3333.     UINT uint = GetMenuState(uiId,MF_BYPOSITION);
  3334.     if(uint&MF_SEPARATOR && !(uint&MF_POPUP))
  3335.     {
  3336.       delete m_MenuList.GetAt(uiId);
  3337.       m_MenuList.RemoveAt(uiId);
  3338.     }
  3339.     else
  3340.     {
  3341.       CNewMenu* pSubMenu = (CNewMenu*) GetSubMenu(uiId);
  3342.       if(NULL==pSubMenu)
  3343.       {
  3344.         UINT uiCommandId = GetMenuItemID(uiId);
  3345.         for(int i=0;i<m_MenuList.GetSize(); i++)
  3346.         {
  3347.           if(m_MenuList[i]->m_nID==uiCommandId)
  3348.           {
  3349.             delete m_MenuList.GetAt(i);
  3350.             m_MenuList.RemoveAt(i);
  3351.             break;
  3352.           }
  3353.         }
  3354.       }
  3355.       else
  3356.       {
  3357.         int numSubMenus = (int)m_SubMenus.GetUpperBound();
  3358.         for(int m = numSubMenus; m >= 0; m--)
  3359.         {
  3360.           if(m_SubMenus[m]==pSubMenu->m_hMenu)
  3361.           {
  3362.             int numAllSubMenus = (int)m_AllSubMenus.GetUpperBound();
  3363.             for(int n = numAllSubMenus; n>= 0; n--)
  3364.             {
  3365.               if(m_AllSubMenus[n]==m_SubMenus[m])
  3366.               {
  3367.                 m_AllSubMenus.RemoveAt(n);
  3368.               }
  3369.             }
  3370.             m_SubMenus.RemoveAt(m);
  3371.           }
  3372.         }
  3373.         int num = pSubMenu->GetMenuItemCount();
  3374.         for(int i=num-1;i>=0;--i)
  3375.         {
  3376.           pSubMenu->DeleteMenu(i,MF_BYPOSITION);
  3377.         }
  3378.         for(i=(int)m_MenuList.GetUpperBound();i>=0;i--)
  3379.         {
  3380.           if(m_MenuList[i]->m_nID==HMenuToUInt(pSubMenu->m_hMenu) )
  3381.           {
  3382.             delete m_MenuList.GetAt(i);
  3383.             m_MenuList.RemoveAt(i);
  3384.             break;
  3385.           }
  3386.         }
  3387.         delete pSubMenu;
  3388.       }
  3389.     }
  3390.   }
  3391.   else
  3392.   {
  3393.     int iPosition =0;
  3394.     CNewMenu* pMenu = FindMenuOption(uiId,iPosition);
  3395.     if(pMenu)
  3396.     {
  3397.       pMenu->DeleteMenu(iPosition,MF_BYPOSITION);
  3398.     }
  3399.   }
  3400.   return CMenu::DeleteMenu(uiId,nFlags);
  3401. } 
  3403. BOOL CNewMenu::AppendMenu(UINT nFlags,UINT nIDNewItem,LPCTSTR lpszNewItem,int nIconNormal)
  3404. {
  3405.   return AppendODMenu(lpszNewItem,nFlags,nIDNewItem,nIconNormal);
  3406. }
  3408. BOOL CNewMenu::AppendMenu(UINT nFlags,UINT nIDNewItem,LPCTSTR lpszNewItem,CImageList *il,int xoffset)
  3409. {
  3410.   return AppendODMenu(lpszNewItem,nFlags,nIDNewItem,il,xoffset);
  3411. }
  3413. BOOL CNewMenu::AppendMenu(UINT nFlags,UINT nIDNewItem,LPCTSTR lpszNewItem,CBitmap *bmp)
  3414. {
  3415.   if(bmp)
  3416.   {
  3417.     CImageList temp;
  3418.     temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  3419.     temp.Add(bmp,GetBitmapBackground());
  3421.     return AppendODMenu(lpszNewItem,nFlags,nIDNewItem,&temp,0);
  3422.   }
  3423.   return AppendODMenu(lpszNewItem,nFlags,nIDNewItem,NULL,0);
  3424. }
  3426. BOOL CNewMenu::InsertMenu(UINT nPosition,UINT nFlags,UINT nIDNewItem,LPCTSTR lpszNewItem,int nIconNormal)
  3427. {
  3428.   return InsertODMenu(nPosition,lpszNewItem,nFlags,nIDNewItem,nIconNormal);
  3429. }
  3431. BOOL CNewMenu::InsertMenu(UINT nPosition,UINT nFlags,UINT nIDNewItem,LPCTSTR lpszNewItem,CImageList *il,int xoffset)
  3432. {
  3433.   return InsertODMenu(nPosition,lpszNewItem,nFlags,nIDNewItem,il,xoffset);
  3434. }
  3436. BOOL CNewMenu::InsertMenu(UINT nPosition,UINT nFlags,UINT nIDNewItem,LPCTSTR lpszNewItem,CBitmap *bmp)
  3437. {
  3438.   if(bmp)
  3439.   {
  3440.     CImageList temp;
  3441.     temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  3442.     temp.Add(bmp,GetBitmapBackground());
  3443.     return InsertODMenu(nPosition,lpszNewItem,nFlags,nIDNewItem,&temp,0);
  3444.   }
  3445.   return InsertODMenu(nPosition,lpszNewItem,nFlags,nIDNewItem,NULL,0);
  3446. }
  3448. CNewMenu* CNewMenu::AppendODPopupMenu(LPCTSTR lpstrText)
  3449. {
  3450.   CNewMenu* pSubMenu = new CNewMenu(m_hMenu);
  3451.   pSubMenu->m_unselectcheck=m_unselectcheck;
  3452.   pSubMenu->m_selectcheck=m_selectcheck;
  3453.   pSubMenu->checkmaps=checkmaps;
  3454.   pSubMenu->checkmapsshare=TRUE;
  3455.   pSubMenu->CreatePopupMenu();
  3456.   AppendODMenu(lpstrText,MF_POPUP,HMenuToUInt(pSubMenu->m_hMenu), -1);
  3457.   return pSubMenu;
  3458. }
  3460. BOOL CNewMenu::ImageListDuplicate(CImageList *il,int xoffset,CImageList *newlist)
  3461. {
  3462.   if (il == NULL||newlist==NULL||xoffset<0)
  3463.     return FALSE;
  3464.   
  3465.   HICON hIcon = il->ExtractIcon(xoffset);
  3466.   int cx, cy;
  3467.   ImageList_GetIconSize(il->m_hImageList, &cx, &cy);
  3468.   newlist->Create(cx,cy,ILC_COLORDDB|ILC_MASK,1,1);
  3469.   newlist->Add(hIcon);
  3470.   ::DestroyIcon(hIcon);
  3471.   return TRUE;
  3472. }
  3474. CMenu* CNewMenu::GetSubMenu(int nPos)
  3475. {
  3476.   return CMenu::GetSubMenu (nPos);
  3477. }
  3479. CMenu* CNewMenu::GetSubMenu(LPCTSTR lpszSubMenuName)
  3480. {
  3481.   int num = GetMenuItemCount ();
  3482.   CString name;
  3484.   for (int i=0; i<num; i++)
  3485.   {
  3486.     GetMenuString (i, name, MF_BYPOSITION);
  3487.     if (name.Compare (lpszSubMenuName) == 0)
  3488.     {
  3489.       return CMenu::GetSubMenu (i);
  3490.     }
  3491.   }
  3492.   return NULL;
  3493. }
  3495. // Tongzhe Cui, Functions to remove a popup menu based on its name. Seperators
  3496. // before and after the popup menu can also be removed if they exist.
  3497. int CNewMenu::GetMenuPosition(LPCTSTR pText)
  3498. {
  3499.   for(int i=0;i<(int)(GetMenuItemCount());++i)
  3500.   {
  3501.     if(!GetSubMenu(i))
  3502.     { 
  3503.       for(int j=0;j<=m_MenuList.GetUpperBound();++j)
  3504.       {  
  3505.         if(m_MenuList[j]->m_szMenuText.Compare(pText)==NULL)
  3506.           return j;
  3507.       }
  3508.     }
  3509.   }
  3510.   // means no found;
  3511.   return -1;
  3512. }
  3514. // sPos means Seperator's position, since we have no way to find the 
  3515. // seperator's position in the menu we have to specify them when we call the 
  3516. // RemoveMenu to make sure the unused seperators are removed;
  3517. // sPos  = None no seperator removal;
  3518. //       = Head  seperator in front of this menu item;
  3519. //       = Tail  seperator right after this menu item;
  3520. //       = Both  seperators at both ends;
  3521. // remove the menu item based on their text, return -1 if not found, otherwise 
  3522. // return the menu position;
  3523. int CNewMenu::RemoveMenu(LPCTSTR pText, ESeperator sPos)
  3524. {
  3525.   int nPos = GetMenuPosition(pText);
  3526.   if(nPos != -1)
  3527.   {
  3528.     switch (sPos)
  3529.     {
  3530.     case CNewMenu::NONE:
  3531.       RemoveMenu(nPos, MF_BYPOSITION);
  3532.       break;
  3534.     case CNewMenu::HEAD:
  3535.       ASSERT(nPos - 1 >= 0);
  3536.       RemoveMenu(nPos-1, MF_BYPOSITION);
  3537.       break;
  3539.     case CNewMenu::TAIL:
  3540.       RemoveMenu(nPos+1, MF_BYPOSITION);
  3541.       break;
  3543.     case CNewMenu::BOTH:
  3544.       // remove the end first;
  3545.       RemoveMenu(nPos+1, MF_BYPOSITION);
  3546.       // remove the head;
  3547.       ASSERT(nPos - 1 >= 0);
  3548.       RemoveMenu(nPos-1, MF_BYPOSITION);
  3549.       break;
  3550.     }
  3551.   }
  3552.   return nPos;
  3553. }
  3555. BOOL CNewMenu::RemoveMenuTitle()
  3556. {
  3557.   int numMenuItems = (int)m_MenuList.GetSize();
  3559.   // We need a seperator at the beginning of the menu
  3560.   if(!numMenuItems || !((m_MenuList[0]->m_nFlags)&MF_SEPARATOR) )
  3561.   {
  3562.     return FALSE;
  3563.   }
  3564.   CNewMenuItemData* pMenuData = m_MenuList[0];
  3565.   // Check for title
  3566.   if(pMenuData->m_nTitleFlags&MFT_TITLE)
  3567.   {
  3568.     if(numMenuItems>0)
  3569.     {
  3570.       CNewMenuItemData* pMenuNextData = m_MenuList[1];
  3571.       if((pMenuNextData->m_nFlags&MF_MENUBREAK))
  3572.       {
  3573.         pMenuNextData->m_nFlags &= ~MF_MENUBREAK;
  3574.         CMenu::ModifyMenu(1,MF_BYPOSITION|pMenuNextData->m_nFlags,pMenuNextData->m_nID,(LPCTSTR)pMenuNextData);
  3575.       }
  3576.     }
  3577.     // Now remove the title
  3578.     RemoveMenu(0,MF_BYPOSITION);
  3579.     return TRUE;
  3580.   }
  3581.   return FALSE;
  3582. } 
  3584. BOOL CNewMenu::SetMenuTitle(LPCTSTR pTitle,UINT nTitleFlags)
  3585. {
  3586.   // Check the menu integrity
  3587.   if((int)GetMenuItemCount()!=(int)m_MenuList.GetSize())
  3588.   {
  3589.     SynchronizeMenu();
  3590.   }
  3592.   int numMenuItems = (int)m_MenuList.GetSize();
  3594.   // We need a seperator at the beginning of the menu
  3595.   if(!numMenuItems || !((m_MenuList[0]->m_nFlags)&MF_SEPARATOR) )
  3596.   {
  3597.     InsertMenu(0,MF_SEPARATOR|MF_BYPOSITION);
  3598.   }
  3600.   numMenuItems = (int)m_MenuList.GetSize();
  3601.   if(numMenuItems)
  3602.   {
  3603.     CNewMenuItemData* pMenuData = m_MenuList[0];
  3604.     if(pMenuData->m_nFlags&MF_SEPARATOR)
  3605.     {
  3606.       pMenuData->SetString(pTitle);
  3607.       pMenuData->m_nTitleFlags = nTitleFlags|MFT_TITLE;
  3609.       if(numMenuItems>1)
  3610.       {
  3611.         CNewMenuItemData* pMenuData = m_MenuList[1];
  3613.         if(nTitleFlags&MFT_SIDE_TITLE)
  3614.         {
  3615.           if(!(pMenuData->m_nFlags&MF_MENUBREAK))
  3616.           {
  3617.             pMenuData->m_nFlags |= MF_MENUBREAK;
  3618.             CMenu::ModifyMenu(1,MF_BYPOSITION|pMenuData->m_nFlags,pMenuData->m_nID,(LPCTSTR)pMenuData);
  3619.           }
  3620.         }
  3621.         else
  3622.         {
  3623.           if((pMenuData->m_nFlags&MF_MENUBREAK))
  3624.           {
  3625.             pMenuData->m_nFlags &= ~MF_MENUBREAK;
  3626.             CMenu::ModifyMenu(1,MF_BYPOSITION|pMenuData->m_nFlags,pMenuData->m_nID,(LPCTSTR)pMenuData);
  3627.           }
  3628.         }
  3629.         return TRUE;
  3630.       }
  3631.     }
  3632.   }
  3633.   return FALSE;
  3634. }
  3636. BOOL CNewMenu::SetMenuText(UINT id, CString string, UINT nFlags/*= MF_BYPOSITION*/ )
  3637. {
  3638.   BOOL returnflag=FALSE;
  3640.   if(MF_BYPOSITION&nFlags)
  3641.   {
  3642.     int numMenuItems = (int)m_MenuList.GetSize();
  3643.     if(id<UINT(numMenuItems))
  3644.     {
  3645.       m_MenuList[id]->SetString(string);
  3646.       returnflag=TRUE;
  3647.     }
  3648.   }
  3649.   else
  3650.   {
  3651.     int uiLoc;
  3652.     CNewMenu* pMenu = FindMenuOption(id,uiLoc);
  3653.     if(NULL!=pMenu)
  3654.     {
  3655.       returnflag = pMenu->SetMenuText(uiLoc,string);
  3656.     }
  3657.   }
  3658.   return returnflag;
  3659. }
  3661. // courtesy of Warren Stevens
  3662. void CNewMenu::ColorBitmap(CDC* pDC,CBitmap& bmp,CSize size,COLORREF fill,COLORREF border,int hatchstyle)
  3663. {
  3664.   // Create a memory DC
  3665.   CDC MemDC;
  3666.   MemDC.CreateCompatibleDC(pDC);  
  3667.   bmp.CreateCompatibleBitmap(pDC, size.cx, size.cy);  
  3668.   CPen border_pen(PS_SOLID, 1, border);
  3670.   CBrush fill_brush;
  3671.   if(hatchstyle!=-1) 
  3672.   { 
  3673.     fill_brush.CreateHatchBrush(hatchstyle, fill); 
  3674.   }
  3675.   else 
  3676.   {
  3677.     fill_brush.CreateSolidBrush(fill);
  3678.   }
  3680.   CBitmap* pOldBitmap = MemDC.SelectObject(&bmp);
  3681.   CPen*    pOldPen    = MemDC.SelectObject(&border_pen);
  3682.   CBrush*  pOldBrush  = MemDC.SelectObject(&fill_brush);
  3684.   MemDC.Rectangle(0,0, size.cx, size.cy);
  3686.   if(NULL!=pOldBrush)  { MemDC.SelectObject(pOldBrush);  }
  3687.   if(NULL!=pOldPen)    { MemDC.SelectObject(pOldPen);    }
  3688.   if(NULL!=pOldBitmap) { MemDC.SelectObject(pOldBitmap); }
  3689. }
  3691. void CNewMenu::DrawSpecial_OldStyle(CDC* pDC, LPCRECT pRect,UINT nID, DWORD dwStyle)
  3692. {
  3693.   COLORREF oldColor;
  3694.   if( (dwStyle&ODS_GRAYED) || (dwStyle&ODS_INACTIVE))
  3695.   {
  3696.     oldColor = pDC->SetTextColor(::GetSysColor(COLOR_GRAYTEXT));
  3697.   }
  3698.   else if (dwStyle&ODS_SELECTED)
  3699.   { 
  3700.     oldColor = pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
  3701.   }
  3702.   else
  3703.   {
  3704.     oldColor = pDC->SetTextColor(::GetSysColor(COLOR_MENUTEXT));
  3705.   }
  3706.   BOOL bBold = (dwStyle&ODS_DEFAULT) ? TRUE : FALSE;
  3708.   switch(nID&0xfff0)
  3709.   {
  3710.   case SC_MINIMIZE:
  3711.     DrawSpecialChar(pDC,pRect,48,bBold); // Min
  3712.     break;
  3713.   case SC_MAXIMIZE:
  3714.     DrawSpecialChar(pDC,pRect,49,bBold); // Max
  3715.     break;
  3716.   case SC_CLOSE:
  3717.     DrawSpecialChar(pDC,pRect,114,bBold); // Close
  3718.     break;
  3719.   case SC_RESTORE:
  3720.     DrawSpecialChar(pDC,pRect,50,bBold); // restore
  3721.     break;
  3722.   }
  3723.   pDC->SetTextColor(oldColor);
  3724. }
  3726. void CNewMenu::DrawSpecial_WinXP(CDC* pDC, LPCRECT pRect,UINT nID, DWORD dwStyle)
  3727. {
  3728.   TCHAR cSign = 0;
  3729.   switch(nID&0xfff0)
  3730.   {
  3731.   case SC_MINIMIZE:
  3732.     cSign = 48; // Min
  3733.     break;
  3734.   case SC_MAXIMIZE:
  3735.     cSign = 49;// Max
  3736.     break;
  3737.   case SC_CLOSE:
  3738.     cSign = 114;// Close
  3739.     break;
  3740.   case SC_RESTORE:
  3741.     cSign = 50;// Restore
  3742.     break;
  3743.   }
  3744.   if(cSign)
  3745.   {
  3746.     COLORREF oldColor;
  3747.     BOOL bBold = (dwStyle&ODS_DEFAULT) ? TRUE : FALSE;
  3748.     CRect rect(pRect);
  3750.     if( (dwStyle&ODS_GRAYED) || (dwStyle&ODS_INACTIVE))
  3751.     {
  3752.       oldColor = pDC->SetTextColor(::GetSysColor(COLOR_GRAYTEXT));
  3753.     }
  3754.     else if(dwStyle&ODS_SELECTED)
  3755.     { 
  3756.       oldColor = pDC->SetTextColor(::GetSysColor(COLOR_GRAYTEXT));
  3757.       DrawSpecialChar(pDC,rect,cSign,bBold);
  3758.       pDC->SetTextColor(::GetSysColor(COLOR_MENUTEXT));
  3759.       rect.OffsetRect(-2,-2);
  3760.     }
  3761.     else
  3762.     { 
  3763.       oldColor = pDC->SetTextColor(::GetSysColor(COLOR_MENUTEXT));
  3764.     }
  3765.     DrawSpecialChar(pDC,rect,cSign,bBold);
  3767.     pDC->SetTextColor(oldColor);
  3768.   }
  3769. }
  3771. void CNewMenu::SetMBar(CMenuButton *pBar)
  3772. {
  3773. pb=pBar;
  3774. }
  3776. CRect CNewMenu::GetLastActiveMenuRect()
  3777. {
  3778.   return m_LastActiveMenuRect;
  3779. }
  3781. void CNewMenu::DrawSpecialCharStyle(CDC* pDC, LPCRECT pRect, TCHAR Sign, DWORD dwStyle)
  3782. {
  3783.   COLORREF oldColor;
  3784.   if( (dwStyle&ODS_GRAYED) || (dwStyle&ODS_INACTIVE))
  3785.   {
  3786.     oldColor = pDC->SetTextColor(::GetSysColor(COLOR_GRAYTEXT));
  3787.   }
  3788.   else
  3789.   { 
  3790.     oldColor = pDC->SetTextColor(::GetSysColor(COLOR_MENUTEXT));
  3791.   }
  3793.   DrawSpecialChar(pDC,pRect,Sign,(dwStyle&ODS_DEFAULT) ? TRUE : FALSE);
  3795.   pDC->SetTextColor(oldColor);
  3796. }
  3798. void CNewMenu::DrawSpecialChar(CDC* pDC, LPCRECT pRect, TCHAR Sign, BOOL bBold)
  3799. {
  3800.   //  48 Min
  3801.   //  49 Max
  3802.   //  50 Restore
  3803.   //  98 Checkmark 
  3804.   // 105 Bullet
  3805.   // 114 Close
  3807.   CFont MyFont;
  3808.   LOGFONT logfont;
  3810.   CRect rect(pRect) ;
  3811.   rect.DeflateRect(2,2);
  3813.   logfont.lfHeight = -rect.Height();
  3814.   logfont.lfWidth = 0;
  3815.   logfont.lfEscapement = 0;
  3816.   logfont.lfOrientation = 0;
  3817.   logfont.lfWeight = (bBold) ? FW_BOLD:FW_NORMAL;
  3818.   logfont.lfItalic = FALSE;
  3819.   logfont.lfUnderline = FALSE;
  3820.   logfont.lfStrikeOut = FALSE;
  3821.   logfont.lfCharSet = DEFAULT_CHARSET;
  3822.   logfont.lfOutPrecision = OUT_DEFAULT_PRECIS;
  3823.   logfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  3824.   logfont.lfQuality = DEFAULT_QUALITY;
  3825.   logfont.lfPitchAndFamily = DEFAULT_PITCH;
  3827.   _tcscpy(logfont.lfFaceName,_T("Marlett"));
  3829.   MyFont.CreateFontIndirect (&logfont);
  3831.   CFont* pOldFont = pDC->SelectObject (&MyFont); 
  3832.   int OldMode = pDC->SetBkMode(TRANSPARENT);  
  3834.   pDC->DrawText (&Sign,1,rect,DT_CENTER|DT_SINGLELINE);
  3836.   pDC->SetBkMode(OldMode);
  3837.   pDC->SelectObject(pOldFont);
  3838. }
  3840. //////////////////////////////////////////////////////////////////////
  3841. // Construction/Destruction
  3842. //////////////////////////////////////////////////////////////////////
  3844. CMenuTheme::CMenuTheme()
  3845. { 
  3846.   ZeroMemory(this,sizeof(CMenuTheme));
  3847. }
  3849. CMenuTheme::CMenuTheme( DWORD dwThemeId, 
  3850.                         pItemMeasureFkt pMeasureItem,
  3851.                         pItemDrawFkt pDrawItem,
  3852.                         pItemDrawFkt pDrawTitle,
  3853.                         DWORD dwFlags)
  3854.   :m_dwThemeId(dwThemeId),
  3855.     m_dwFlags(dwFlags),
  3856.     m_pMeasureItem(pMeasureItem),
  3857.     m_pDrawItem(pDrawItem),
  3858.     m_pDrawTitle(pDrawTitle)
  3859. {
  3860.   m_BorderTopLeft = CSize(2,2);
  3862.   if(!IsShadowEnabled())
  3863.   {
  3864.     m_BorderBottomRight = CSize(5,6);
  3865.   }
  3866.   else
  3867.   {
  3868.     m_BorderBottomRight = CSize(2,2);
  3869.   }
  3870. }
  3872. CMenuTheme::~CMenuTheme()
  3873. {
  3874. }
  3876. BOOL CMenuTheme::DoDrawBorder()
  3877. {
  3878.   return (m_dwFlags&1)?TRUE:FALSE;
  3879. }
  3881. void CMenuTheme::DrawSmalBorder( HWND hWnd, HDC hDC)
  3882. {
  3883.   CNewMenuHook::CMenuHookData* pData = CNewMenuHook::GetMenuHookData(hWnd);
  3884.   if(pData!=NULL)
  3885.   {
  3887.     if(pData->m_hMenu)
  3888.     {   
  3889.       CNewMenu* pMenu = DYNAMIC_DOWNCAST(CNewMenu,CMenu::FromHandlePermanent(pData->m_hMenu));
  3890.       if(pMenu && pMenu->GetParent())
  3891.       {
  3892.         CNewMenu* pParentMenu = DYNAMIC_DOWNCAST(CNewMenu,CMenu::FromHandlePermanent(pMenu->GetParent()));
  3893.         if(pParentMenu && !pParentMenu->IsPopup())
  3894.         {
  3895.           CRect Rect;
  3896.           // Get the size of the menu... 
  3897.           GetWindowRect(hWnd, Rect );
  3898.           Rect.OffsetRect(pData->m_Point - Rect.TopLeft());
  3899.           Rect &= pParentMenu->GetLastActiveMenuRect();
  3900.           if(!Rect.IsRectEmpty())
  3901.           {
  3902.             if(Rect.Width()>Rect.Height())
  3903.             {
  3904.               Rect.InflateRect(-1,0);
  3905.             }
  3906.             else
  3907.             {
  3908.               Rect.InflateRect(0,-1);
  3909.             }
  3910.             Rect.OffsetRect(-pData->m_Point);
  3911.             CDC* pDC = CDC::FromHandle(hDC);
  3912.             pDC->FillSolidRect(Rect,GetSysColor(CNewMenu::cCOLOR_MENUBAR));
  3913.           }
  3914.         }
  3915.       }
  3916.     }
  3917.   }
  3918. }
  3920. void CMenuTheme::DrawShade( HWND hWnd, HDC hDC,CPoint screen)
  3921. { 
  3922.   if(IsShadowEnabled())
  3923.     return;
  3925.   // Get the size of the menu... 
  3926.   CRect Rect;
  3927.   GetWindowRect(hWnd, Rect );
  3929.   long winW = Rect.Width(); 
  3930.   long winH = Rect.Height(); 
  3931.   long xOrg = screen.x;  
  3932.   long yOrg = screen.y;
  3934.   // Get the desktop hDC... 
  3935.   HDC hDcDsk = GetWindowDC(0) ;
  3936.   
  3937.   int X,Y;
  3938.   // Simulate a shadow on right edge... 
  3939.   for (X=1; X<=4 ;X++)
  3940.   { 
  3941.     for (Y=0; Y<4 ;Y++)
  3942.     {
  3943.       SetPixel(hDC,winW-X,Y, GetPixel(hDcDsk,xOrg+winW-X,yOrg+Y) );
  3944.     }
  3945.     for (Y=4; Y<8 ;Y++)
  3946.     {
  3947.       COLORREF c = GetPixel(hDcDsk, xOrg + winW - X, yOrg + Y) ;
  3948.       SetPixel(hDC,winW-X,Y,DarkenColor(3 * X * (Y - 3), c)) ;
  3949.     }
  3950.     for (Y=8; Y<=(winH-5) ;Y++)
  3951.     {
  3952.       COLORREF c = GetPixel(hDcDsk, xOrg + winW - X, yOrg + Y) ;
  3953.       SetPixel( hDC, winW - X, Y, DarkenColor(15 * X, c) );
  3954.     }
  3955.     for (Y=(winH-4); Y<=(winH-1) ;Y++)
  3956.     {
  3957.       COLORREF c = GetPixel(hDcDsk, xOrg + winW - X, yOrg + Y) ;
  3958.       SetPixel( hDC, winW - X, Y, DarkenColor(3 * X * -(Y - winH), c)) ;
  3959.     }
  3960.   } 
  3962.   // Simulate a shadow on the bottom edge... 
  3963.   for(Y=1; Y<=4 ;Y++)
  3964.   {
  3965.     for(X=0; X<=3 ;X++)
  3966.     {
  3967.       SetPixel(hDC,X,winH-Y, GetPixel(hDcDsk,xOrg+X,yOrg+winH-Y)) ;
  3968.     }
  3969.     for(X=4; X<=7 ;X++)
  3970.     {
  3971.       COLORREF c = GetPixel(hDcDsk, xOrg + X, yOrg + winH - Y) ;
  3972.       SetPixel( hDC, X, winH - Y, DarkenColor(3 * (X - 3) * Y, c)) ;
  3973.     }
  3974.     for(X=8; X<=(winW-5) ;X++)
  3975.     {
  3976.       COLORREF  c = GetPixel(hDcDsk, xOrg + X, yOrg + winH - Y); 
  3977.       SetPixel( hDC, X, winH - Y, DarkenColor(15 * Y, c)) ;
  3978.     }
  3979.   }   
  3980.   // Release the desktop hDC... 
  3981.   ReleaseDC(0,hDcDsk);
  3982. }
  3984. BOOL CMenuTheme::OnInitWnd(HWND hWnd)
  3985. {
  3986.   if(DoDrawBorder())
  3987.   {
  3988.     CNewMenuHook::CMenuHookData* pData = CNewMenuHook::GetMenuHookData(hWnd);
  3989.     ASSERT(pData);
  3990.     // Flag for changing styles
  3991.     pData->m_dwData |= 2;
  3993.     SetWindowLong (hWnd, GWL_STYLE, pData->m_dwStyle & (~WS_BORDER) );
  3994.     SetWindowLong (hWnd, GWL_EXSTYLE,pData->m_dwExStyle & ~(WS_EX_WINDOWEDGE|WS_EX_DLGMODALFRAME));
  3996.     return TRUE;
  3997.   }
  3998.   return FALSE;
  3999. }
  4001. BOOL CMenuTheme::OnUnInitWnd(HWND hWnd)
  4002. {
  4003.   CNewMenuHook::CMenuHookData* pData = CNewMenuHook::GetMenuHookData(hWnd);
  4004.   if(pData)
  4005.   {
  4006.     HMENU hMenu = pData->m_hMenu;
  4007.     CNewMenu* pNewMenu = DYNAMIC_DOWNCAST(CNewMenu,CMenu::FromHandlePermanent(hMenu));
  4008.     if(pNewMenu)
  4009.     {
  4010.       if(pNewMenu->OnUnInitPopupMenu() && (pData->m_dwData&4) )
  4011.       {
  4012.         HWND hParenWnd = GetParent(hWnd);
  4013.         if(hParenWnd)
  4014.           DrawMenuBar(hParenWnd);
  4015.       }
  4016.     }
  4017.     // were windows-style changed?
  4018.     if(pData->m_dwData&2)
  4019.     {
  4020.       SetLastError(0);
  4021.       if(!(pData->m_dwData&1))
  4022.       {
  4023.         SetWindowLong (hWnd, GWL_STYLE,pData->m_dwStyle);
  4024.       }
  4025.       else
  4026.       {
  4027.         // Restore old Styles for special menu!! 
  4028.         // (Menu 0x10012!!!) special VISIBLE flag must be set
  4029.         SetWindowLong (hWnd, GWL_STYLE,pData->m_dwStyle|WS_VISIBLE);
  4030.       }
  4032.       ShowLastError();
  4033.       SetWindowLong (hWnd, GWL_EXSTYLE, pData->m_dwExStyle);
  4034.       ShowLastError();
  4035.       // Normaly when you change the style you shold call next function
  4036.       // but in this case you would lose the focus for the menu!!
  4037.       //SetWindowPos(hWnd,0,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_FRAMECHANGED|SWP_HIDEWINDOW);
  4038.     }
  4039.   }
  4040.   return TRUE;
  4041. }
  4043. BOOL CMenuTheme::OnEraseBkgnd(HWND hWnd, HDC hDC)
  4044. {
  4045.   //  CNewMenuHook::CMenuHookData* pData = CNewMenuHook::GetMenuHookData(hWnd);
  4047.   //  Get the size of the menu... 
  4048.   CDC* pDC = CDC::FromHandle (hDC);
  4049.   CRect Rect;
  4050.   GetClientRect(hWnd, Rect );
  4051.   pDC->FillSolidRect (Rect,GetSysColor(COLOR_MENU));
  4053.   return TRUE;
  4054. }
  4056. BOOL CMenuTheme::OnWindowPosChanging(HWND hWnd, LPWINDOWPOS pPos)
  4057. {
  4058.   UNREFERENCED_PARAMETER(hWnd);
  4060.   if(DoDrawBorder())
  4061.   {
  4062.     if(!IsShadowEnabled())
  4063.     {
  4064.       pPos->cx +=2;
  4065.       pPos->cy +=2;
  4066.     }
  4067.     else
  4068.     {
  4069.       pPos->cx -=2;
  4070.       pPos->cy -=2;
  4071.     }
  4072.     pPos->y -=1;
  4074.     return TRUE;
  4075.   }
  4076.   return FALSE;
  4077. }
  4079. BOOL CMenuTheme::OnNcCalcSize(HWND hWnd, NCCALCSIZE_PARAMS* pCalc)
  4080. {
  4081.   UNREFERENCED_PARAMETER(hWnd);
  4083.   if(DoDrawBorder())
  4084.   {
  4085.     pCalc->rgrc->top  += m_BorderTopLeft.cy;
  4086.     pCalc->rgrc->left += m_BorderTopLeft.cx; 
  4088.     pCalc->rgrc->bottom -= m_BorderBottomRight.cy;
  4089.     pCalc->rgrc->right  -= m_BorderBottomRight.cx;
  4090.   }
  4091.   return FALSE;
  4092. }
  4094. BOOL CMenuTheme::OnDrawBorder(HWND hWnd, HDC hDC)
  4095. {
  4096.   CNewMenuHook::CMenuHookData* pData = CNewMenuHook::GetMenuHookData(hWnd);
  4097.   if(DoDrawBorder() && pData)
  4098.   {
  4099.     CRect Rect;
  4100.     CDC* pDC = CDC::FromHandle (hDC);
  4102.     // Get the size of the menu... 
  4103.     GetWindowRect(hWnd, Rect );
  4105.     long winW = Rect.Width(); 
  4106.     long winH = Rect.Height(); 
  4108.     if(!IsShadowEnabled())
  4109.     {
  4110.       pDC->Draw3dRect(CRect(CPoint(1,1),CSize(winW-6,winH-6)),GetSysColor(CNewMenu::cCOLOR_MENUBAR),GetSysColor(CNewMenu::cCOLOR_MENUBAR));
  4111.       pDC->Draw3dRect(CRect(CPoint(0,0),CSize(winW-4,winH-4)),GetSysColor(COLOR_HIGHLIGHT),GetSysColor(COLOR_HIGHLIGHT));
  4112.       
  4113.       DrawShade(hWnd,hDC,pData->m_Point);
  4114.     }
  4115.     else
  4116.     {
  4117.       pDC->Draw3dRect(CRect(CPoint(1,1),CSize(winW-2,winH-2)),GetSysColor(CNewMenu::cCOLOR_MENUBAR),GetSysColor(CNewMenu::cCOLOR_MENUBAR));
  4118.       pDC->Draw3dRect(CRect(CPoint(0,0),CSize(winW-0,winH-0)),GetSysColor(COLOR_HIGHLIGHT),GetSysColor(COLOR_HIGHLIGHT));
  4119.     }
  4120.     //DrawSmalBorder(hWnd,hDC);
  4121.     return TRUE;
  4122.   }
  4123.   return FALSE;
  4124. }
  4126. CMenuThemeXP::CMenuThemeXP(DWORD dwThemeId, 
  4127.                            pItemMeasureFkt pMeasureItem,
  4128.                            pItemDrawFkt pDrawItem,
  4129.                            pItemDrawFkt pDrawTitle,
  4130.                            DWORD dwFlags)
  4131. :CMenuTheme(dwThemeId,pMeasureItem,pDrawItem,pDrawTitle,dwFlags)
  4132. {
  4133. }
  4135. BOOL CMenuThemeXP::OnDrawBorder(HWND hWnd, HDC hDC)
  4136. {
  4137.   CNewMenuHook::CMenuHookData* pData = CNewMenuHook::GetMenuHookData(hWnd);
  4138.   if(DoDrawBorder() && pData)
  4139.   {
  4140.     CRect Rect;
  4141.     CDC* pDC = CDC::FromHandle (hDC);
  4143.     // Get the size of the menu... 
  4144.     GetWindowRect(hWnd, Rect );
  4146.     long winW = Rect.Width(); 
  4147.     long winH = Rect.Height(); 
  4148. CRect rc=Rect;
  4149.     if(!IsShadowEnabled())
  4150.     {
  4151.       pDC->Draw3dRect(CRect(CPoint(1,1),CSize(winW-6,winH-6)),GetSysColor(COLOR_WINDOW),GetSysColor(COLOR_WINDOW));
  4152.       pDC->Draw3dRect(CRect(CPoint(0,0),CSize(winW-4,winH-4)),GuiDrawLayer::GetRGBMenu(),GuiDrawLayer::GetRGBMenu());
  4154.       DrawShade(hWnd,hDC,pData->m_Point);
  4155.     }
  4156.     else
  4157.     {
  4158.       pDC->Draw3dRect(CRect(CPoint(1,1),CSize(winW-2,winH-2)),GetSysColor(COLOR_WINDOW),GetSysColor(COLOR_WINDOW));
  4159.       pDC->Draw3dRect(CRect(CPoint(0,0),CSize(winW-0,winH-0)),GuiDrawLayer::GetRGBMenu(),GuiDrawLayer::GetRGBMenu());
  4160.     }
  4161. pDC->Draw3dRect(CRect(CPoint(1,1),CSize(1,winH-4)),GuiDrawLayer::GetRGBColorFace(),GuiDrawLayer::GetRGBColorFace());
  4162. if (CNewMenu::m_StyleMenu==GUISTYLE_2003 && GuiDrawLayer::m_Theme)
  4163. {
  4164. COLORREF clrNear=pDC->GetNearestColor(GuiDrawLayer::GetRGBCaptionXP());
  4165. if(clrNear!=13221564)
  4166. pDC->Draw3dRect(0,0,winW,winH,GuiDrawLayer::GetRGBCaptionXP(),GuiDrawLayer::GetRGBCaptionXP());
  4167. }
  4168. CRect rcDeskTop;
  4169. CWnd* pDeskTop=CWnd::FromHandle(GetDesktopWindow());
  4170. pDeskTop->GetWindowRect(rcDeskTop);
  4171. if (gbintHorz!=-1 )
  4172. if (gbintHorz==0 )
  4173. {
  4174. if ( rcDeskTop.bottom  > Rect.bottom)
  4175. pDC->Draw3dRect(1,0,rcMenu.Width()-1,0,GetSysColor(CNewMenu::cCOLOR_MENUBAR),GetSysColor(CNewMenu::cCOLOR_MENUBAR));
  4176. }
  4177. else 
  4178. {
  4179. if ( rcDeskTop.right > Rect.right)
  4180. pDC->Draw3dRect(0,1,0,rcMenu.Height()-1,GetSysColor(CNewMenu::cCOLOR_MENUBAR),GetSysColor(CNewMenu::cCOLOR_MENUBAR));
  4181. }
  4182. gbintHorz=-1;
  4183. rcMenu=CRect(0,0,0,0);
  4184. DrawSmalBorder(hWnd,hDC);
  4185.     
  4186.     return TRUE;
  4187.   }
  4188.   return FALSE;
  4189. }
  4191. BOOL CMenuThemeXP::OnEraseBkgnd(HWND hWnd, HDC hDC)
  4192. {
  4193.   CNewMenuHook::CMenuHookData* pData = CNewMenuHook::GetMenuHookData(hWnd);
  4194.   if(pData->m_hMenu==NULL)
  4195.   {
  4196.     return CMenuTheme::OnEraseBkgnd(hWnd,hDC);
  4197.   }
  4198.  
  4199.   //  Get the size of the menu... 
  4200.   CDC* pDC = CDC::FromHandle (hDC);
  4201.   CRect Rect;
  4202.   GetClientRect(hWnd, Rect );
  4203.   pDC->FillSolidRect (Rect,GetSysColor(CNewMenu::cCOLOR_MENUBAR));
  4205.   return TRUE;
  4206. }
  4208. //////////////////////////////////////////////////////////////////////
  4209. // Construction/Destruction
  4210. //////////////////////////////////////////////////////////////////////
  4212. const TCHAR _OldMenuProc[] = _T("OldMenuProc");
  4214. HHOOK CNewMenuHook::HookOldMenuCbtFilter = NULL;
  4215. HMENU CNewMenuHook::m_hLastMenu = NULL;
  4216. DWORD CNewMenuHook::m_dwMsgPos = 0;
  4218. CTypedPtrList<CPtrList, CMenuTheme*>* CNewMenuHook::m_pRegisteredThemesList = NULL;
  4220. CTypedPtrMap<CMapPtrToPtr,HWND,CNewMenuHook::CMenuHookData*> CNewMenuHook::m_MenuHookData;
  4222. CNewMenuHook::CNewMenuHook()
  4223. { 
  4224.   if(IsShellType()==WinXP)
  4225.   {
  4226.     BOOL bFlatMenu = FALSE;
  4227.     if(SystemParametersInfo(SPI_GETFLATMENU,0,&bFlatMenu,0) && bFlatMenu==TRUE)
  4228.     {
  4229.       CNewMenu::cCOLOR_MENUBAR = COLOR_MENUBAR;
  4230.     }
  4231.   }
  4232.   AddTheme(new CMenuTheme(CNewMenu::STYLE_ORIGINAL,
  4233.                           CNewMenu::MeasureItem_OldStyle,
  4234.                           CNewMenu::DrawItem_OldStyle,
  4235.                           CNewMenu::DrawMenuTitle,TRUE));
  4237.   AddTheme(new CMenuTheme(CNewMenu::STYLE_ORIGINAL_NOBORDER,
  4238.                           CNewMenu::MeasureItem_OldStyle,
  4239.                           CNewMenu::DrawItem_OldStyle,
  4240.                           CNewMenu::DrawMenuTitle));
  4242.   AddTheme(new CMenuThemeXP(CNewMenu::STYLE_XP,
  4243.                             CNewMenu::MeasureItem_WinXP,
  4244.                             CNewMenu::DrawItem_WinXP,
  4245.                             CNewMenu::DrawMenuTitle,TRUE));
  4247.   AddTheme(new CMenuThemeXP(CNewMenu::STYLE_XP_NOBORDER,
  4248.                             CNewMenu::MeasureItem_WinXP,
  4249.                             CNewMenu::DrawItem_WinXP,
  4250.                             CNewMenu::DrawMenuTitle));
  4252.   AddTheme(new CMenuTheme(CNewMenu::STYLE_SPECIAL,
  4253.                           CNewMenu::MeasureItem_OldStyle,
  4254.                           CNewMenu::DrawItem_SpecialStyle,
  4255.                           CNewMenu::DrawMenuTitle,TRUE));
  4257.   AddTheme(new CMenuTheme(CNewMenu::STYLE_SPECIAL_NOBORDER,
  4258.                           CNewMenu::MeasureItem_OldStyle,
  4259.                           CNewMenu::DrawItem_SpecialStyle,
  4260.                           CNewMenu::DrawMenuTitle));
  4262. //  CNewMenu::m_pActMenuDrawing = FindTheme(CNewMenu::STYLE_ORIGINAL);
  4263. //  CNewMenu::m_pActMenuDrawing = FindTheme(CNewMenu::STYLE_ORIGINAL_NOBORDER);
  4264.   CNewMenu::m_pActMenuDrawing = FindTheme(CNewMenu::STYLE_XP);
  4265. //  CNewMenu::m_pActMenuDrawing = FindTheme(CNewMenu::STYLE_XP_NOBORDER);
  4267.   if (HookOldMenuCbtFilter == NULL)
  4268.   {
  4269.     HookOldMenuCbtFilter = ::SetWindowsHookEx(WH_CALLWNDPROC, NewMenuHook, NULL, ::GetCurrentThreadId());
  4270.     if (HookOldMenuCbtFilter == NULL)
  4271.     {
  4272.       ShowLastError();
  4273.       AfxThrowMemoryException();
  4274.     }
  4275.   } 
  4276. }
  4278. CNewMenuHook::~CNewMenuHook()
  4279. {
  4280.   if (HookOldMenuCbtFilter != NULL)
  4281.   {
  4282.     if(!::UnhookWindowsHookEx(HookOldMenuCbtFilter))
  4283.     {
  4284.       ShowLastError();
  4285.     }
  4286.     HookOldMenuCbtFilter = NULL;
  4287.   }
  4288.   // Destroy all registered themes.
  4289.   if( m_pRegisteredThemesList!= NULL)
  4290.   {
  4291.     while(m_pRegisteredThemesList->GetCount())
  4292.     {
  4293.       CMenuTheme* pTheme = m_pRegisteredThemesList->RemoveTail();
  4294.       delete pTheme;
  4295.     }
  4296.     delete m_pRegisteredThemesList;
  4297.     m_pRegisteredThemesList = NULL;
  4298.   }
  4299. }
  4301. BOOL CNewMenuHook::AddTheme(CMenuTheme* pTheme)
  4302. {
  4303.   if( m_pRegisteredThemesList== NULL)
  4304.   {
  4305.     m_pRegisteredThemesList = new CTypedPtrList<CPtrList, CMenuTheme*>;
  4306.   }
  4307.   if(m_pRegisteredThemesList->Find(pTheme))
  4308.   {
  4309.     return FALSE;
  4310.   }
  4311.   m_pRegisteredThemesList->AddTail(pTheme);
  4312.   return TRUE;
  4313. }
  4315. CMenuTheme* CNewMenuHook::RemoveTheme(DWORD dwThemeId)
  4316. {
  4317.   CMenuTheme* pTheme = FindTheme(dwThemeId);
  4318.   if(pTheme==NULL)
  4319.   {
  4320.     return NULL;
  4321.   }
  4322.   POSITION pos = m_pRegisteredThemesList->Find(pTheme);
  4323.   ASSERT(pos);
  4324.   if(pos)
  4325.   {
  4326.     m_pRegisteredThemesList->RemoveAt(pos);
  4327.     if(m_pRegisteredThemesList->GetCount()==NULL)
  4328.     {
  4329.       // Destroy the empty list.
  4330.       delete m_pRegisteredThemesList;
  4331.       m_pRegisteredThemesList = NULL;
  4332.     }
  4333.   }
  4334.   return pTheme; 
  4335. }
  4337. CMenuTheme* CNewMenuHook::FindTheme(DWORD dwThemeId)
  4338. {
  4339.   if(m_pRegisteredThemesList==NULL)
  4340.   {
  4341.     return NULL;
  4342.   }
  4344.   POSITION pos = m_pRegisteredThemesList->GetHeadPosition();
  4345.   while(pos)
  4346.   { 
  4347.     CMenuTheme* pTheme = m_pRegisteredThemesList->GetNext(pos);
  4348.     if(pTheme->m_dwThemeId==dwThemeId)
  4349.     {
  4350.       return pTheme;
  4351.     }    
  4352.   }
  4353.   return NULL;
  4354. }   
  4356. CNewMenuHook::CMenuHookData* CNewMenuHook::GetMenuHookData(HWND hWnd)
  4357. {
  4358.   CMenuHookData* pData=NULL;
  4359.   if(m_MenuHookData.Lookup(hWnd,pData))
  4360.   {
  4361.     return pData;
  4362.   }
  4363.   return NULL;
  4364. }
  4366. void CNewMenuHook::UnsubClassMenu(HWND hWnd)
  4367. {
  4368.   AFX_MANAGE_STATE(AfxGetModuleState());
  4370.   WNDPROC oldWndProc = (WNDPROC)::GetProp(hWnd, _OldMenuProc);
  4371.   ASSERT(oldWndProc != NULL);  
  4373.   SetLastError(0);
  4374.   if(!SetWindowLong(hWnd, GWL_WNDPROC, (DWORD)(DWORD_PTR)oldWndProc))
  4375.   {
  4376.     ShowLastError();
  4377.   }
  4378.   RemoveProp(hWnd, _OldMenuProc);
  4379.   GlobalDeleteAtom(GlobalFindAtom(_OldMenuProc));
  4381.   // now Clean up
  4382.   HMENU hMenu = NULL;
  4383.   // Restore old Styles for special menu!! (Menu 0x10012!!!)
  4384.   CMenuHookData* pData = GetMenuHookData(hWnd);
  4385.   if(pData)
  4386.   {
  4387.     hMenu = pData->m_hMenu;
  4388.     CNewMenu::m_pActMenuDrawing->OnUnInitWnd(hWnd);
  4390.     m_MenuHookData.RemoveKey(hWnd);
  4391.     delete pData;
  4392.   }
  4393.   
  4394. #ifdef _TRACE_MENU_
  4395.   TRACE(_T("Unsubclass Menu=0x%lX, hwnd=0x%lXn"),hMenu,hWnd);
  4396. #endif
  4397. }
  4400. LRESULT CALLBACK CNewMenuHook::SubClassMenu(HWND hWnd,      // handle to window
  4401.                                             UINT uMsg,      // message identifier
  4402.                                             WPARAM wParam,  // first message parameter
  4403.                                             LPARAM lParam   // second message parameter
  4404.                                             )
  4405. {
  4406.   AFX_MANAGE_STATE(AfxGetModuleState());
  4408.   WNDPROC oldWndProc = (WNDPROC)::GetProp(hWnd, _OldMenuProc);
  4409.   LRESULT result = NULL;
  4410.   
  4411.   static long NestedLevel = 0;
  4412.   BOOL bCallDefault = TRUE;
  4414.   NestedLevel++;
  4416. #ifdef _TRACE_MENU_
  4417.   MSG msg = {hWnd,uMsg,wParam,lParam,0,0,0};
  4418.   TCHAR Buffer[30]; 
  4419.   wsprintf(Buffer,_T("Level %02ld"),NestedLevel);
  4420.   MyTraceMsg(Buffer,&msg);
  4421. #endif
  4423.   switch(uMsg)
  4424.   {
  4425.   case WM_NCPAINT:
  4426.     {
  4427.       CMenuHookData* pData = GetMenuHookData(hWnd);
  4428.       if(pData && pData->m_bDrawBorder)
  4429.       {
  4430.         HDC hDC;
  4431.         if(wParam!=1)
  4432.           hDC = GetDCEx(hWnd, (HRGN)wParam, DCX_WINDOW|DCX_INTERSECTRGN);
  4433.         else
  4434.           hDC = GetWindowDC (hWnd);
  4436.         if(hDC)
  4437.         { 
  4438.   
  4439.           if(CNewMenu::m_pActMenuDrawing->OnDrawBorder(hWnd,hDC))
  4440.           {
  4441.             bCallDefault=FALSE;
  4442.           }
  4443.   ReleaseDC(hWnd,hDC);
  4444.         }
  4445.       }
  4446.       pData->m_bDrawBorder = TRUE;
  4447.     }
  4448.     break;
  4450.   case WM_PRINT:
  4451.     {
  4452.       CMenuHookData* pData = GetMenuHookData(hWnd);
  4453.       if(pData && CNewMenu::m_pActMenuDrawing->OnDrawBorder(hWnd,(HDC)wParam) )
  4454.       {
  4455.         pData->m_bDrawBorder = FALSE;
  4456.         // We need to create a bitmap for drawing
  4457.         // We can't clipp or make a offset to the DC because NT2000 (blue-screen!!)
  4458.         CRect rect;
  4459.         GetClientRect(hWnd, rect);
  4461.         CDC dc;
  4462.         CBitmap bitmap;
  4464.         CDC* pDC = CDC::FromHandle((HDC)wParam);
  4465.         dc.CreateCompatibleDC(pDC); 
  4467.         bitmap.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
  4468.         CBitmap* pOldBitmap = dc.SelectObject(&bitmap);
  4469.         // might as well clip to the same rectangle
  4470.         dc.IntersectClipRect(rect);
  4472.         CSize offset = CNewMenu::m_pActMenuDrawing->m_BorderTopLeft;
  4473.         SendMessage(hWnd,WM_ERASEBKGND,(WPARAM)dc.m_hDC,0);
  4474.         SendMessage(hWnd,WM_PRINTCLIENT,(WPARAM)dc.m_hDC,lParam);
  4475.         pDC->BitBlt(offset.cx,offset.cy, rect.Width(), rect.Height(), &dc, 0, 0, SRCCOPY);
  4476.         dc.SelectObject(pOldBitmap);
  4478.         bCallDefault=FALSE;
  4479.       } 
  4480.     }
  4481.     break;
  4483.   case WM_ERASEBKGND:
  4484.     {
  4485.       if(CNewMenu::m_pActMenuDrawing->OnEraseBkgnd(hWnd,(HDC)wParam))
  4486.       {
  4487.         bCallDefault=FALSE; 
  4488.         result = TRUE;
  4489.       }
  4490.     }
  4491.     break;
  4493.   case WM_WINDOWPOSCHANGED:
  4494.   case WM_WINDOWPOSCHANGING:
  4495.     {
  4496.       CMenuHookData* pData=GetMenuHookData(hWnd);
  4497.       ASSERT(pData);
  4499.       LPWINDOWPOS pPos = (LPWINDOWPOS)lParam;
  4500.       // Need for windows 98
  4501.       BOOL bSetPos = pPos->x!=NULL || pPos->y!=NULL;
  4502.       if(uMsg==WM_WINDOWPOSCHANGING)
  4503.       {
  4504.         CNewMenu::m_pActMenuDrawing->OnWindowPosChanging(hWnd,pPos);
  4505.       }
  4506.       if(bSetPos)
  4507.       {
  4508.         pData->m_Point = CPoint(pPos->x,pPos->y);
  4509.       }
  4510.     }
  4511.     break;
  4513.   case WM_KEYDOWN:
  4514.     if(wParam==VK_ESCAPE)
  4515.     {
  4516.       CMenuHookData* pData = GetMenuHookData(hWnd);
  4517.       if(pData)
  4518.       {
  4519.         pData->m_dwData |= 4;
  4520.       }
  4521.     }
  4522.     m_dwMsgPos = GetMessagePos();
  4523.     break;
  4525.   case WM_NCCALCSIZE:
  4526.     {
  4527.       NCCALCSIZE_PARAMS* pCalc = (NCCALCSIZE_PARAMS*)lParam;
  4528.       if(CNewMenu::m_pActMenuDrawing->OnNcCalcSize(hWnd,pCalc))
  4529.       {
  4530.         bCallDefault=FALSE; 
  4531.       }
  4532.     }
  4533.     break;
  4535.   case WM_SHOWWINDOW:
  4536.     // Hide the window ? Test for 98 and 2000
  4537.     if(wParam==NULL)
  4538.     { 
  4539.       // Special handling for NT 2000 and WND 0x10012.
  4540.       UnsubClassMenu(hWnd);
  4541.     }
  4542.     break;
  4544.   case WM_NCDESTROY:
  4545.     UnsubClassMenu (hWnd);
  4546.     break;
  4547.   }
  4549.   if( bCallDefault )
  4550.   {
  4551.     ASSERT(oldWndProc != NULL);
  4552.     // call original wndproc for default handling
  4553.     result = CallWindowProc(oldWndProc, hWnd, uMsg, wParam, lParam);
  4554.   }
  4556.   NestedLevel--;
  4558.   return result;
  4559. } 
  4561. BOOL CNewMenuHook::CheckSubclassing(HWND hWnd, BOOL bSpecialWnd)
  4562. {
  4563.   TCHAR Name[20];
  4564.   int Count = GetClassName (hWnd,Name,ARRAY_SIZE(Name));
  4565.   if(Count!=6 || _tcscmp(Name,_T("#32768"))!=0)
  4566.   {
  4567.     // does not match to menuclass
  4568.     return false;
  4569.   }
  4571.   BOOL bDoNewSubclass = FALSE;
  4572.   CMenuHookData* pData=GetMenuHookData(hWnd);
  4573.   // check if we have allready some data
  4574.   if(pData==NULL)
  4575.   {
  4576.     WNDPROC oldWndProc;
  4577.     // subclass the window with the proc which does gray backgrounds
  4578.     oldWndProc = (WNDPROC)(LONG_PTR)GetWindowLong(hWnd, GWL_WNDPROC);
  4579.     if (oldWndProc != NULL && GetProp(hWnd, _OldMenuProc) == NULL)
  4580.     {
  4581.       ASSERT(oldWndProc!=SubClassMenu);
  4583.       if(!SetProp(hWnd, _OldMenuProc, oldWndProc))
  4584.       {
  4585.         ShowLastError();
  4586.       }
  4587.       if ((WNDPROC)GetProp(hWnd, _OldMenuProc) == oldWndProc)
  4588.       {
  4589.         GlobalAddAtom(_OldMenuProc);
  4591.         CMenuHookData* pData=GetMenuHookData(hWnd);
  4592.         ASSERT(pData==NULL);
  4593.         if(pData==NULL)
  4594.         { 
  4595.           pData = new CMenuHookData(hWnd,bSpecialWnd);
  4596.           m_MenuHookData.SetAt (hWnd,pData);
  4598.           SetLastError(0);
  4599.           if(!SetWindowLong(hWnd, GWL_WNDPROC,(DWORD)(DWORD_PTR)SubClassMenu))
  4600.           {
  4601.             ShowLastError();
  4602.           }
  4603.           bDoNewSubclass = TRUE;
  4605.   #ifdef _TRACE_MENU_
  4606.           TRACE(_T("Subclass Menu=0x%lX, hwnd=0x%lXn"),pData->m_hMenu,hWnd);
  4607.   #endif 
  4608.           CNewMenu::m_pActMenuDrawing->OnInitWnd(hWnd);
  4609.         } 
  4610.       }
  4611.       else
  4612.       {
  4613.         ASSERT(0);
  4614.       }
  4615.     }
  4616.   }
  4618.   // Menu was set also assign it to this menu.
  4619.   if(m_hLastMenu)
  4620.   {
  4621.     CMenuHookData* pData = GetMenuHookData(hWnd);
  4622.     if(pData)
  4623.     {
  4624.       // Safe actual menu
  4625.       pData->m_hMenu = m_hLastMenu;
  4626.       // Reset for the next menu
  4627.       m_hLastMenu = NULL;
  4628.     }
  4629.   }
  4630.   return bDoNewSubclass;
  4631. }
  4633. LRESULT CALLBACK CNewMenuHook::NewMenuHook(int code, WPARAM wParam, LPARAM lParam)
  4634. {
  4635.   AFX_MANAGE_STATE(AfxGetModuleState());
  4637.   CWPSTRUCT* pTemp = (CWPSTRUCT*)lParam;
  4638.   if(code == HC_ACTION )
  4639.   {
  4640.     HWND hWnd = pTemp->hwnd;
  4642.     // Normal and special handling for menu 0x10012
  4643.     if(pTemp->message==WM_CREATE || pTemp->message==0x01E2)
  4644.     {
  4645.       CheckSubclassing(hWnd,pTemp->message==0x01E2);
  4646.     }
  4647.   }
  4648.   return CallNextHookEx(HookOldMenuCbtFilter, code,wParam, lParam);
  4649. }
  4653. //////////////////////////////////////////////////////////////////////
  4654. // Construction/Destruction
  4655. //////////////////////////////////////////////////////////////////////