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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 菜单 > 查看源码
BCMenu.cpp
资源名称：bcmenu24.zip　[点击查看]
上传用户：aphuaqiang
上传日期：2007-01-02
资源大小：62k
文件大小：41k
源码类别：

菜单

开发平台：

Visual C++

BCMenu.cpp：源码内容
  1. //*************************************************************************
  2. // BCMenu.cpp : implementation file
  3. // Version : 2.4
  4. // Date : Feb 11, 1999
  5. // Author : Brent Corkum
  6. // 
  7. // Portions of code supplied by:
  8. // Ben Ashley,Girish Bharadwaj,Jean-Edouard Lachand-Robert,
  9. // Robert Edward Caldecott,Kenny Goers,Leonardo Zide,
  10. // Stefan Kuhr
  11. //
  12. // Bug Fixes:
  13. // Stefan Kuhr,Martin Vladic,Kim Yoo Chul
  14. //
  15. // You are free to use/modify this code but leave this header intact.
  16. //
  18. #include "stdafx.h"        // Standard windows header file
  19. #include "BCMenu.h"        // BCMenu class declaration
  20. #include <afxpriv.h>       //SK: makes A2W and other spiffy AFX macros work
  22. #ifdef _DEBUG
  23. #define new DEBUG_NEW
  24. #undef THIS_FILE
  25. static char THIS_FILE[] = __FILE__;
  26. #endif
  28. #define GAP 1
  29. #ifndef OBM_CHECK
  30. #define OBM_CHECK 32760 // from winuser.h
  31. #endif
  33. #if _MFC_VER <0x400
  34. #error This code does not work on Versions of MFC prior to 4.0
  35. #endif
  37. static CPINFO CPInfo;
  39. enum Win32Type{
  40. Win32s,
  41. Windoze95,
  42. WinNT3,
  43. WinNT4orHigher
  44. };
  47. Win32Type IsShellType()
  48. {
  49.   Win32Type  ShellType;
  50.   DWORD winVer;
  51.   OSVERSIONINFO *osvi;
  53.   winVer=GetVersion();
  54.   if(winVer<0x80000000){/*NT */
  55.     ShellType=WinNT3;
  56.     osvi= (OSVERSIONINFO *)malloc(sizeof(OSVERSIONINFO));
  57.     if (osvi!=NULL){
  58.       memset(osvi,0,sizeof(OSVERSIONINFO));
  59.       osvi->dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
  60.       GetVersionEx(osvi);
  61.       if (osvi->dwMajorVersion>=4L)
  62.         ShellType=WinNT4orHigher;//yup, it is NT 4 or higher!
  63.       free(osvi);
  64.     }
  65.   }
  66.   else if  (LOBYTE(LOWORD(winVer))<4)
  67.     ShellType=Win32s;/*Win32s*/
  68.   else
  69.     ShellType=Windoze95;/*Windoze95*/
  70.   return ShellType;
  71. }
  73. static Win32Type g_Shell=IsShellType();
  75. void BCMenuData::SetAnsiString(LPCSTR szAnsiString)
  76. {
  77. ASSERT(szAnsiString);
  78. USES_CONVERSION;
  79. SetWideString(A2W(szAnsiString));  //SK:  see MFC Tech Note 059
  80. }
  82. CString BCMenuData::GetString(void)//returns the menu text in ANSI or UNICODE
  83. //depending on the MFC-Version we are using
  84. {
  85. CString strText;
  86. if (m_szMenuText)
  87.     {
  88. #ifdef UNICODE
  89.     strText = m_szMenuText;
  90. #else
  91. USES_CONVERSION;
  92.     strText=W2A(m_szMenuText);     //SK:  see MFC Tech Note 059
  93. #endif    
  94.     }
  95. return strText;
  96. }
  99. /*
  100.  
  101. ===============================================================================
  102.   BCMenu::BCMenu()
  103.   TCMeny::~BCMenu()
  104.   -----------------
  106.   Constructor and Destructor.
  107.  
  108. ===============================================================================
  109. */
  111. BCMenu::BCMenu()
  112. {
  113.   disable_old_style=FALSE;
  114.   m_iconX = 16;            // Icon sizes default to 16 x 16
  115.   m_iconY = 15;            // ...
  116.   m_selectcheck = -1;
  117.   m_unselectcheck = -1;
  118.   checkmaps=NULL;
  119.   checkmapsshare=FALSE;
  120.   // set the color used for the transparent background in all bitmaps
  121.   m_bitmapBackground=RGB(192,192,192); //gray
  122.   m_bitmapBackgroundFlag=FALSE;
  123.   GetCPInfo(CP_ACP,&CPInfo);
  124. }
  127. BCMenu::~BCMenu()
  128. {
  129.   DestroyMenu();
  130. }
  132. BOOL BCMenu::IsNewShell ()
  133. {
  134. return (Windoze95==g_Shell || WinNT4orHigher==g_Shell);
  135. }
  138. BCMenuData::~BCMenuData()
  139. {
  140.   if(bitmap)
  141.     delete(bitmap);
  143.   delete[] m_szMenuText; //Need not check for NULL because ANSI X3J16 allows "delete NULL"
  144. }
  147. void BCMenuData::SetWideString(const wchar_t *szWideString)
  148. {
  149. delete[] m_szMenuText;//Need not check for NULL because ANSI X3J16 allows "delete NULL"
  151. if (szWideString)
  152.     {
  153.     m_szMenuText = new wchar_t[sizeof(wchar_t)*(wcslen(szWideString)+1)];
  154.     if (m_szMenuText)
  155.         wcscpy(m_szMenuText,szWideString);
  156.     }
  157. else
  158.     m_szMenuText=NULL;//set to NULL so we need not bother about dangling non-NULL Ptrs
  159. }
  161. BOOL BCMenu::IsMenu(CMenu *submenu)
  162. {
  163.   int m;
  165.   int numSubMenus = m_SubMenus.GetUpperBound();
  166.   for(m=0;m<=numSubMenus;++m){
  167.     if(submenu==m_SubMenus[m])return(TRUE);
  168.   }
  169.   return(FALSE);
  170. }
  172. BOOL BCMenu::DestroyMenu()
  173. {
  174.   // Destroy Sub menus:
  175.   int m;
  176.   int numSubMenus = m_SubMenus.GetUpperBound();
  177.   for(m = numSubMenus; m >= 0; m--)delete(m_SubMenus[m]);
  178.   m_SubMenus.RemoveAll();
  179.   // Destroy menu data
  180.   int numItems = m_MenuList.GetUpperBound();
  181.   for(m = 0; m <= numItems; m++)delete(m_MenuList[m]);
  182.   m_MenuList.RemoveAll();
  183.   if(checkmaps&&!checkmapsshare){
  184.     delete checkmaps;
  185.     checkmaps=NULL;
  186.   }
  187.   // Call base-class implementation last:
  188.   return(CMenu::DestroyMenu());
  189. };
  192. ///////////////////////////////////////////////////////////////////////////
  193. //
  194. // BCMenu message handlers
  197. /*
  198. ==========================================================================
  199. void BCMenu::DrawItem(LPDRAWITEMSTRUCT)
  200. ---------------------------------------
  202. Called by the framework when a particular item needs to be drawn.  We
  203. overide this to draw the menu item in a custom-fashion, including icons
  204. and the 3D rectangle bar.
  205. ==========================================================================
  206. */
  209. void BCMenu::DrawItem (LPDRAWITEMSTRUCT lpDIS)
  210. {
  211.   ASSERT(lpDIS != NULL);
  212.   CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  213.   CRect rect;
  214.   UINT state = (((BCMenuData*)(lpDIS->itemData))->nFlags);
  215.   if(state & MF_SEPARATOR){
  216.     rect.CopyRect(&lpDIS->rcItem);
  217.     rect.top+=rect.Height()>>1;
  218.     pDC->DrawEdge(&rect,EDGE_ETCHED,BF_TOP);
  219.   }
  220.   else{
  221.     CRect rect2;
  222.     BOOL standardflag=FALSE,selectedflag=FALSE,disableflag=FALSE;
  223.     BOOL checkflag=FALSE;
  224.     CBitmap bitmapstandard;
  225.     COLORREF crText = GetSysColor(COLOR_MENUTEXT);
  226.     COLORREF m_clrBack=GetSysColor(COLOR_MENU);
  227.     CBrush m_brBackground,m_brSelect;
  228.     CPen m_penBack;
  229.     int x0,y0,dy;
  230.     int nIconNormal=-1,xoffset=-1;
  231.     CImageList *bitmap=NULL;
  232.     CFont m_fontMenu;
  233.     LOGFONT m_lf;
  235.     // set some colors and the font
  236.     m_penBack.CreatePen (PS_SOLID,0,GetSysColor(COLOR_MENU));
  237.     m_brBackground.CreateSolidBrush(GetSysColor(COLOR_MENU));
  238.     m_brSelect.CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
  239.     ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  240.     NONCLIENTMETRICS nm;
  241.     nm.cbSize = sizeof (NONCLIENTMETRICS);
  242.     VERIFY (SystemParametersInfo(SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
  243.     m_lf =  nm.lfMenuFont;
  244.     m_fontMenu.CreateFontIndirect (&m_lf);
  246.     // draw the colored rectangle portion
  247.   
  248.     rect.CopyRect(&lpDIS->rcItem);
  249.     rect2=rect;
  250.  
  251.     // draw the up/down/focused/disabled state
  253.     UINT action = lpDIS->itemAction;
  254.     UINT state = lpDIS->itemState;
  255.     CString strText;
  256.     LOGFONT lf;
  257.     lf = m_lf;
  259.     CFont dispFont;
  260.     CFont *pFont=NULL;
  261.       
  262.     if(lpDIS->itemData != NULL){
  263.       nIconNormal = (((BCMenuData*)(lpDIS->itemData))->menuIconNormal);
  264.       xoffset = (((BCMenuData*)(lpDIS->itemData))->xoffset);
  265.       bitmap = (((BCMenuData*)(lpDIS->itemData))->bitmap);
  266.       strText = ((BCMenuData*) (lpDIS->itemData))->GetString();
  267.     
  268.       if(state&ODS_CHECKED && nIconNormal<0){
  269.         if(state&ODS_SELECTED && m_selectcheck>0)checkflag=TRUE;
  270.         else if(m_unselectcheck>0) checkflag=TRUE;
  271.       }
  272.       else if(nIconNormal != -1){
  273.         standardflag=TRUE;
  274.         if(state&ODS_SELECTED && !(state&ODS_GRAYED))selectedflag=TRUE;
  275.         else if(state&ODS_GRAYED) disableflag=TRUE;
  276.       }
  277.     }
  278.     else{
  279.       strText.Empty();
  280.     }
  282.     if(state&ODS_SELECTED){ // draw the down edges
  284.       CPen *pOldPen = pDC->SelectObject (&m_penBack);
  286.       // You need only Text highlight and thats what you get
  287.      
  288.       if(checkflag||standardflag||selectedflag||disableflag||state&ODS_CHECKED)
  289.         rect2.SetRect(rect.left+m_iconX+4+GAP,rect.top,rect.right,rect.bottom);
  290.       pDC->FillRect (rect2,&m_brSelect);
  292.       pDC->SelectObject (pOldPen);
  293.       if((HFONT)dispFont != NULL)dispFont.DeleteObject ();
  294.       dispFont.CreateFontIndirect (&lf);
  295.       crText = GetSysColor(COLOR_HIGHLIGHTTEXT);
  296.     }
  297.     else {
  298.       CPen *pOldPen = pDC->SelectObject (&m_penBack);
  299.       pDC->FillRect (rect,&m_brBackground);
  300.       pDC->SelectObject (pOldPen);
  302.       // draw the up edges
  304.       pDC->Draw3dRect (rect,m_clrBack,m_clrBack);
  305.       if ((HFONT)dispFont != NULL) dispFont.DeleteObject ();
  306.       dispFont.CreateFontIndirect (&lf); //Normal
  307.     }
  309.     // draw the text if there is any
  310.     //We have to paint the text only if the image is nonexistant
  312.     dy = (rect.Height()-4-m_iconY)/2;
  313.     dy = dy<0 ? 0 : dy;
  315.     if(checkflag||standardflag||selectedflag||disableflag){
  316.       rect2.SetRect(rect.left+1,rect.top+1+dy,rect.left+m_iconX+3,
  317.                     rect.top+m_iconY+3+dy);
  318.       pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  319.       if(checkflag && checkmaps){
  320.         pDC->FillRect (rect2,&m_brBackground);
  321.         rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  322.                       rect.top+m_iconY+4+dy);
  323.         
  324. pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  325.         CPoint ptImage(rect.left+2,rect.top+2+dy);
  326.        
  327.         if(state&ODS_SELECTED)checkmaps->Draw(pDC,1,ptImage,ILD_TRANSPARENT);
  328.         else checkmaps->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
  329.       }
  330.       else if(disableflag){
  331.         if(!selectedflag){
  332.           HBITMAP hbmp=LoadSysColorBitmap(nIconNormal);
  333.           if(hbmp){
  334.             bitmapstandard.Attach(hbmp);
  335.             rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  336.                           rect.top+m_iconY+4+dy);
  337.             pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  338.             if(disable_old_style)
  339.               DitherBlt(lpDIS->hDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
  340.                        (HBITMAP)(bitmapstandard),xoffset*m_iconX,0);
  341.             else
  342.               DitherBlt2(pDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
  343.                          bitmapstandard,xoffset*m_iconX,0);
  344.             bitmapstandard.DeleteObject();
  345.           }
  346.         }
  347.       }
  348.       else if(selectedflag){
  349.         pDC->FillRect (rect2,&m_brBackground);
  350.         rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  351.                       rect.top+m_iconY+4+dy);
  352.         if (IsNewShell()){
  353.           if(state&ODS_CHECKED)
  354.             pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
  355.                             GetSysColor(COLOR_3DHILIGHT));
  356.           else
  357.             pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DHILIGHT),
  358.                             GetSysColor(COLOR_3DSHADOW));
  359.         }
  360.         CPoint ptImage(rect.left+2,rect.top+2+dy);
  361.         if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
  362.       }
  363.       else{
  364.         if(state&ODS_CHECKED){
  365.           CBrush brush;
  366.           COLORREF col =GetSysColor(COLOR_3DLIGHT);
  367.           brush.CreateSolidBrush(col);
  368.           pDC->FillRect(rect2,&brush);
  369.           brush.DeleteObject();
  370.           rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  371.                         rect.top+m_iconY+4+dy);
  372.           if (IsNewShell())
  373.             pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
  374.                             GetSysColor(COLOR_3DHILIGHT));
  375.         }
  376.         else{
  377.           pDC->FillRect (rect2,&m_brBackground);
  378.           rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  379.                         rect.top+m_iconY+4+dy);
  380.           pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  381.         }
  382.         CPoint ptImage(rect.left+2,rect.top+2+dy);
  383.         if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
  384.       }
  385.     }
  386.     if(nIconNormal<0 && state&ODS_CHECKED && !checkflag){
  387.       rect2.SetRect(rect.left+1,rect.top+2+dy,rect.left+m_iconX+1,
  388.                     rect.top+m_iconY+2+dy);
  389.       CMenuItemInfo info;
  390.       info.fMask = MIIM_CHECKMARKS;
  391.       ::GetMenuItemInfo((HMENU)lpDIS->hwndItem,lpDIS->itemID,
  392.                       MF_BYCOMMAND, &info);
  393.       if(state&ODS_CHECKED || info.hbmpUnchecked) {
  394.         Draw3DCheckmark(pDC, rect2, state&ODS_SELECTED,
  395.                         state&ODS_CHECKED ? info.hbmpChecked :
  396.                         info.hbmpUnchecked);
  397.       }
  398.     }
  400.     //This is needed always so that we can have the space for check marks
  402.     x0=rect.left;y0=rect.top;
  403.     rect.left = rect.left + m_iconX + 8 + GAP; 
  405.     if(!strText.IsEmpty()){
  407.       CRect rectt(rect.left,rect.top-1,rect.right,rect.bottom-1);
  409.       //   Find tabs
  411.       CString leftStr,rightStr;
  412.       leftStr.Empty();rightStr.Empty();
  413.       int tablocr=strText.ReverseFind(_T('t'));
  414.       if(tablocr!=-1){
  415.         rightStr=strText.Mid(tablocr+1);
  416.         leftStr=strText.Left(strText.Find(_T('t')));
  417.         rectt.right-=m_iconX;
  418.       }
  419.       else leftStr=strText;
  421.       int iOldMode = pDC->GetBkMode();
  422.       pDC->SetBkMode( TRANSPARENT);
  424.       // Draw the text in the correct colour:
  426.       UINT nFormat  = DT_LEFT|DT_SINGLELINE|DT_VCENTER;
  427.       UINT nFormatr = DT_RIGHT|DT_SINGLELINE|DT_VCENTER;
  428.       if(!(lpDIS->itemState & ODS_GRAYED)){
  429.         pDC->SetTextColor(crText);
  430.         pDC->DrawText (leftStr,rectt,nFormat);
  431.         if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  432.       }
  433.       else{
  435.         // Draw the disabled text
  436.         if(!(state & ODS_SELECTED)){
  437.           RECT offset = *rectt;
  438.           offset.left+=1;
  439.           offset.right+=1;
  440.           offset.top+=1;
  441.           offset.bottom+=1;
  442.           pDC->SetTextColor(GetSysColor(COLOR_BTNHILIGHT));
  443.           pDC->DrawText(leftStr,&offset, nFormat);
  444.           if(tablocr!=-1) pDC->DrawText (rightStr,&offset,nFormatr);
  445.           pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
  446.           pDC->DrawText(leftStr,rectt, nFormat);
  447.           if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  448.         }
  449.         else{
  450.         // And the standard Grey text:
  451.           pDC->SetTextColor(m_clrBack);
  452.           pDC->DrawText(leftStr,rectt, nFormat);
  453.           if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  454.         }
  455.       }
  456.       pFont = pDC->SelectObject (&dispFont);
  457.       pDC->SetBkMode( iOldMode );
  458.       pDC->SelectObject (pFont); //set it to the old font
  459.     }
  461.     m_penBack.DeleteObject();
  462.     m_brBackground.DeleteObject();
  463.     m_fontMenu.DeleteObject();
  464.     m_brSelect.DeleteObject();
  465.     dispFont.DeleteObject ();
  466.   }
  467. }
  470. /*
  471. ==========================================================================
  472. void BCMenu::MeasureItem(LPMEASUREITEMSTRUCT)
  473. ---------------------------------------------
  475. Called by the framework when it wants to know what the width and height
  476. of our item will be.  To accomplish this we provide the width of the
  477. icon plus the width of the menu text, and then the height of the icon.
  478.  
  479. ==========================================================================
  480. */
  482. void BCMenu::MeasureItem( LPMEASUREITEMSTRUCT lpMIS )
  483. {
  484.   UINT state = (((BCMenuData*)(lpMIS->itemData))->nFlags);
  485.   if(state & MF_SEPARATOR){
  486.     lpMIS->itemWidth = 0;
  487.     lpMIS->itemHeight = GetSystemMetrics(SM_CYMENU)>>1;
  488.   }
  489.   else{
  490.     CFont m_fontMenu;
  491.     LOGFONT m_lf;
  492.     ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  493.     NONCLIENTMETRICS nm;
  494.     nm.cbSize = sizeof (NONCLIENTMETRICS);
  495.     VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
  496.            nm.cbSize,&nm,0)); 
  497.     m_lf =  nm.lfMenuFont;
  498.     m_fontMenu.CreateFontIndirect (&m_lf);
  500.     // Obtain the width of the text:
  501.     CWnd *pWnd = AfxGetMainWnd();            // Get main window
  502.     CDC *pDC = pWnd->GetDC();              // Get device context
  503.     CFont* pFont=NULL;    // Select menu font in...
  504.     
  505.     if (IsNewShell())
  506.         pFont = pDC->SelectObject (&m_fontMenu);// Select menu font in...
  507.         
  508.     //Get pointer to text SK
  509.     const wchar_t *lpstrText = ((BCMenuData*)(lpMIS->itemData))->GetWideString();//SK: we use const to prevent misuse
  510.     
  511.         
  512.     SIZE size;
  514.     if (Win32s!=g_Shell)
  515.       VERIFY(::GetTextExtentPoint32W(pDC->m_hDC,lpstrText,
  516.              wcslen(lpstrText),&size)); //SK should also work on 95
  517. #ifndef UNICODE //can't be UNICODE for Win32s
  518.     else{//it's Win32suckx
  519.       RECT rect;
  520.       rect.left=rect.top=0;
  521.       size.cy=DrawText(pDC->m_hDC,(LPCTSTR)lpstrText,
  522.                        wcslen(lpstrText),&rect,
  523.                        DT_SINGLELINE|DT_LEFT|DT_VCENTER|DT_CALCRECT);
  524.       //+3 makes at least three pixels space to the menu border
  525.       size.cx=rect.right-rect.left+3;
  526.       size.cx += 3*(size.cx/wcslen(lpstrText));
  527.     }
  528. #endif    
  530.     CSize t = CSize(size);
  531.     if(IsNewShell())
  532.       pDC->SelectObject (pFont);  // Select old font in
  533.     AfxGetMainWnd()->ReleaseDC(pDC);  // Release the DC
  535.     // Set width and height:
  537.     lpMIS->itemWidth = m_iconX + t.cx + m_iconX + GAP;
  538.     int temp = GetSystemMetrics(SM_CYMENU);
  539.     lpMIS->itemHeight = temp>m_iconY+4 ? temp : m_iconY+4;
  540.     m_fontMenu.DeleteObject();
  541.   }
  542. }
  544. void BCMenu::SetIconSize (int width, int height)
  545. {
  546.   m_iconX = width;
  547.   m_iconY = height;
  548. }
  550. BOOL BCMenu::AppendODMenuA(LPCSTR lpstrText,UINT nFlags,UINT nID,
  551.                            int nIconNormal)
  552. {
  553. ASSERT(lpstrText);
  554. USES_CONVERSION;
  555. return AppendODMenuW(A2W(lpstrText),nFlags,nID,nIconNormal);//SK: See MFC Tech Note 059
  556. }
  559. BOOL BCMenu::AppendODMenuW(wchar_t *lpstrText,UINT nFlags,UINT nID,
  560.                            int nIconNormal)
  561. {
  562.   // Add the MF_OWNERDRAW flag if not specified:
  563.   ASSERT(lpstrText);
  564.   if(!nID)nFlags=MF_SEPARATOR|MF_OWNERDRAW;
  565.   else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
  567.   BCMenuData *mdata = new BCMenuData;
  568.   m_MenuList.Add(mdata);
  569.   mdata->SetWideString(lpstrText);    //SK: modified for dynamic allocation
  570.   
  571.   mdata->menuIconNormal = nIconNormal;
  572.   mdata->xoffset=-1;
  573.   if(nIconNormal>=0){
  574.     mdata->xoffset=0;
  575.     LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
  576.     if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  577.     else mdata->bitmap=new(CImageList);
  578.     mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  579.     AddBitmapToImageList(mdata->bitmap,nIconNormal);
  580.   }
  581.   mdata->nFlags = nFlags;
  582.   mdata->nID = nID;
  583.   return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
  584. }
  587. BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,int nIconNormal)
  588. {
  589. USES_CONVERSION;
  590. return ModifyODMenuW(A2W(lpstrText),nID,nIconNormal);//SK: see MFC Tech Note 059
  591. }
  593. BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,int nIconNormal)
  594. {
  595.   int nLoc;
  596.   BCMenuData *mdata;
  598.   // Find the old BCMenuData structure:
  599.   BCMenu *psubmenu = FindMenuOption(nID,nLoc);
  600.   if(psubmenu && nLoc>=0)mdata = psubmenu->m_MenuList[nLoc];
  601.   else{
  602.   // Create a new BCMenuData structure:
  603.     mdata = new BCMenuData;
  604.     m_MenuList.Add(mdata);
  605.   }
  606.   ASSERT(mdata);
  607.   if(lpstrText)
  608.      mdata->SetWideString(lpstrText);  //SK: modified for dynamic allocation
  609.   mdata->menuIconNormal = nIconNormal;
  610.   mdata->xoffset=-1;
  611.   if(nIconNormal>=0){
  612.     mdata->xoffset=0;
  613.     LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
  614.     if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  615.     else mdata->bitmap=new(CImageList);
  616.     mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  617.     AddBitmapToImageList(mdata->bitmap,nIconNormal);
  618.   }
  619.   mdata->nFlags = MF_BYCOMMAND | MF_OWNERDRAW;
  620.   mdata->nID = nID;
  621.   return (CMenu::ModifyMenu(nID,mdata->nFlags,nID,(LPCTSTR)mdata));
  622. }
  625. BOOL BCMenu::ModifyODMenuA(const char *lpstrText,const char *OptionText,
  626.                            int nIconNormal)
  627. {
  628. USES_CONVERSION;
  629. return ModifyODMenuW(A2W(lpstrText),A2W(OptionText),nIconNormal);//SK: see MFC  Tech Note 059
  630. }
  633. BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,wchar_t *OptionText,
  634.                            int nIconNormal)
  635. {
  636.   BCMenuData *mdata;
  638.   // Find the old BCMenuData structure:
  639.   CString junk=OptionText;
  640.   mdata=FindMenuOption(OptionText);
  641.   if(mdata){
  642.     if(lpstrText)
  643.         mdata->SetWideString(lpstrText);//SK: modified for dynamic allocation
  644.     mdata->menuIconNormal = nIconNormal;
  645.     mdata->xoffset=-1;
  646.     if(nIconNormal>=0){
  647.       mdata->xoffset=0;
  648.       if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  649.       else mdata->bitmap=new(CImageList);
  650.       mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  651.       AddBitmapToImageList(mdata->bitmap,nIconNormal);
  652.     }
  653.     return(TRUE);
  654.   }
  655.   return(FALSE);
  656. }
  658. BCMenuData *BCMenu::NewODMenu(UINT pos,UINT nFlags,UINT nID,CString string)
  659. {
  660.   BCMenuData *mdata;
  662.   mdata = new BCMenuData;
  663.   mdata->menuIconNormal = -1;
  664.   mdata->xoffset=-1;
  665.   #ifdef UNICODE
  666.   mdata->SetWideString((LPCTSTR)string);//SK: modified for dynamic allocation
  667.   #else
  668.   mdata->SetAnsiString(string);
  669.   #endif
  670.   mdata->nFlags = nFlags;
  671.   mdata->nID = nID;
  672.   
  673.   
  674.   if (nFlags&MF_OWNERDRAW){
  675.     ASSERT(!(nFlags&MF_STRING));
  676.     ModifyMenu(pos,nFlags,nID,(LPCTSTR)mdata);
  677.   }
  678.   else if (nFlags&MF_STRING){
  679.     ASSERT(!(nFlags&MF_OWNERDRAW));
  680.     ModifyMenu(pos,nFlags,nID,mdata->GetString());
  681.   }
  682.   else{
  683.     ASSERT(nFlags&MF_SEPARATOR);
  684.     ModifyMenu(pos,nFlags,nID);
  685.   }
  687.   return(mdata);
  688. };
  690. BOOL BCMenu::LoadToolbars(const UINT *arID,int n)
  691. {
  692.   ASSERT(arID);
  693.   BOOL returnflag=TRUE;
  694.   for(int i=0;i<n;++i){
  695.     if(!LoadToolbar(arID[i]))returnflag=FALSE;
  696.   }
  697.   return(returnflag);
  698. }
  700. BOOL BCMenu::LoadToolbar(UINT nToolBar)
  701. {
  702.   UINT nID;
  703.   BOOL returnflag=FALSE;
  704.   CToolBar bar;
  706.   bar.Create(AfxGetMainWnd());
  707.   if(bar.LoadToolBar(nToolBar)){
  708.     for(int i=0;i<bar.GetCount();++i){
  709.       nID = bar.GetItemID(i); 
  710.       if(nID && GetMenuState(nID, MF_BYCOMMAND)
  711.         !=0xFFFFFFFF)ModifyODMenu(NULL,nID,nToolBar);
  712.     }
  713.     returnflag=TRUE;
  714.   }
  715.   return(returnflag);
  716. }
  718. BOOL BCMenu::LoadFromToolBar(UINT nID,UINT nToolBar,int& xoffset)
  719. {
  720.   int xset,offset;
  721.   UINT nStyle;
  722.   BOOL returnflag=FALSE;
  723.   CToolBar bar;
  725.   bar.Create(AfxGetMainWnd());
  726.   if(bar.LoadToolBar(nToolBar)){
  727.     offset=bar.CommandToIndex(nID);
  728.     if(offset>=0){
  729.       bar.GetButtonInfo(offset,nID,nStyle,xset);
  730.       if(xset>0)xoffset=xset;
  731.       returnflag=TRUE;
  732.     }
  733.   }
  734.   return(returnflag);
  735. }
  737. BCMenu *BCMenu::FindMenuOption(int nId,int& nLoc)
  738. {
  739.   int i;
  740.   BCMenu *psubmenu,*pgoodmenu;
  742.   for(i=0;i<(int)(GetMenuItemCount());++i){
  743. #ifdef _CPPRTTI 
  744.     psubmenu=dynamic_cast<BCMenu *>(GetSubMenu(i));
  745. #else
  746.     psubmenu=(BCMenu *)GetSubMenu(i);
  747. #endif
  748.     if(psubmenu){
  749.       pgoodmenu=psubmenu->FindMenuOption(nId,nLoc);
  750.       if(pgoodmenu)return(pgoodmenu);
  751.     }
  752.     else if(nId==(int)GetMenuItemID(i)){
  753.       nLoc=i;
  754.       return(this);
  755.     }
  756.   }
  757.   nLoc = -1;
  758.   return(NULL);
  759. }
  761. BCMenuData *BCMenu::FindMenuOption(wchar_t *lpstrText)
  762. {
  763.   int i,j;
  764.   BCMenu *psubmenu;
  765.   BCMenuData *pmenulist;
  767.   for(i=0;i<(int)(GetMenuItemCount());++i){
  768. #ifdef _CPPRTTI 
  769.     psubmenu=dynamic_cast<BCMenu *>(GetSubMenu(i));
  770. #else
  771.     psubmenu=(BCMenu *)GetSubMenu(i);
  772. #endif
  773.     if(psubmenu){
  774.       pmenulist=psubmenu->FindMenuOption(lpstrText);
  775.       if(pmenulist)return(pmenulist);
  776.     }
  777.     else{
  778.       const wchar_t *szWide;//SK: we use const to prevent misuse of this Ptr
  779.       for(j=0;j<=m_MenuList.GetUpperBound();++j){     
  780.         szWide = m_MenuList[j]->GetWideString ();
  781.         if(szWide && !wcscmp(lpstrText,szWide))//SK: modified for dynamic allocation
  782.           return(m_MenuList[j]);
  783.       }
  784.     }
  785.   }
  786.   return(NULL);
  787. }
  790. BOOL BCMenu::LoadMenu(int nResource)
  791. {
  792.   return(BCMenu::LoadMenu(MAKEINTRESOURCE(nResource)));
  793. };
  795. BOOL BCMenu::LoadMenu(LPCTSTR lpszResourceName)
  796. {
  797.   TRACE(_T(
  798.     "IMPORTANT:Use BCMenu::DestroyMenu to destroy Loaded Menu'sn"));
  799.   ASSERT_VALID(this);
  800.   ASSERT(lpszResourceName != NULL);
  802.   // Find the Menu Resource:
  803.   HINSTANCE m_hInst = AfxFindResourceHandle(lpszResourceName,RT_MENU);
  804.   HRSRC hRsrc = ::FindResource(m_hInst,lpszResourceName,RT_MENU);
  805.   if(hRsrc == NULL)return FALSE;
  807.   // Get size of resource:
  809.   DWORD dwSize = SizeofResource(NULL, hRsrc);
  811.   // Load the Menu Resource:
  813.   HGLOBAL hGlobal = LoadResource(m_hInst, hRsrc);
  814.   if(hGlobal == NULL)return FALSE;
  816.   // Attempt to create us as a menu...
  818.   if(!CMenu::CreateMenu())return FALSE;
  820.   // Get Item template Header, and calculate offset of MENUITEMTEMPLATES
  822.   MENUITEMTEMPLATEHEADER *pTpHdr=
  823.     (MENUITEMTEMPLATEHEADER*)LockResource(hGlobal);
  824.   BYTE* pTp=(BYTE*)pTpHdr + 
  825.     (sizeof(MENUITEMTEMPLATEHEADER) + pTpHdr->offset);
  828.   // Variables needed during processing of Menu Item Templates:
  830.   int j=0;
  831.   BCMenuData*  pData = NULL;              // New OD Menu Item Data
  832.   WORD    dwFlags = 0;              // Flags of the Menu Item
  833.   WORD    dwID  = 0;              // ID of the Menu Item
  834.   UINT    uFlags;                  // Actual Flags.
  835.   wchar_t *szCaption=NULL;
  836.   int      nLen   = 0;                // Length of caption
  837.   CTypedPtrArray<CPtrArray, BCMenu*>  m_Stack;    // Popup menu stack
  838.   CArray<BOOL,BOOL>  m_StackEnd;    // Popup menu stack
  839.   m_Stack.Add(this);                  // Add it to this...
  840.   m_StackEnd.Add(FALSE);
  842.   do{
  843.     // Obtain Flags and (if necessary), the ID...
  844.     memcpy(&dwFlags, pTp, sizeof(WORD));pTp+=sizeof(WORD);// Obtain Flags
  845.     if(!(dwFlags & MF_POPUP)){
  846.       memcpy(&dwID, pTp, sizeof(WORD)); // Obtain ID
  847.       pTp+=sizeof(WORD);
  848.     }
  849.     else dwID = 0;
  851.     uFlags = (UINT)dwFlags; // Remove MF_END from the flags that will
  852.     if(uFlags & MF_END) // be passed to the Append(OD)Menu functions.
  853.       uFlags -= MF_END;
  855.     // Obtain Caption (and length)
  857.     nLen = 0;
  858.     char *ch = (char*)pTp;
  859.     szCaption=new wchar_t[wcslen((wchar_t *)pTp)+1];
  860.     wcscpy(szCaption,(wchar_t *)pTp);
  861.     pTp=&pTp[(wcslen((wchar_t *)pTp)+1)*sizeof(wchar_t)];//modified SK
  862.     
  863.     // Handle popup menus first....
  865.     //WideCharToMultiByte
  866.     if(dwFlags & MF_POPUP){
  867.       if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
  868.       BCMenu* pSubMenu = new BCMenu;
  869.       pSubMenu->m_unselectcheck=m_unselectcheck;
  870.       pSubMenu->m_selectcheck=m_selectcheck;
  871.       pSubMenu->checkmaps=checkmaps;
  872.       pSubMenu->checkmapsshare=TRUE;
  873.       pSubMenu->CreatePopupMenu();
  875.       // Append it to the top of the stack:
  877.       m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption,uFlags,
  878.         (UINT)pSubMenu->m_hMenu, -1);
  879.       m_Stack.Add(pSubMenu);
  880.       m_StackEnd.Add(FALSE);
  881.       m_SubMenus.Add(pSubMenu);
  882.     }
  883.     else {
  884.       m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption, uFlags,
  885.         dwID, -1);
  886.       if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
  887.       j = m_Stack.GetUpperBound();
  888.       while(j>=0 && m_StackEnd.GetAt(j)){
  889.         m_Stack[m_Stack.GetUpperBound()]->InsertSpaces();
  890.         m_Stack.RemoveAt(j);
  891.         m_StackEnd.RemoveAt(j);
  892.         --j;
  893.       }
  894.     }
  896.     delete[] szCaption;
  897.   }while(m_Stack.GetUpperBound() != -1);
  899.   for(int i=0;i<(int)GetMenuItemCount();++i){
  900.     CString str=m_MenuList[i]->GetString();
  902.     if(GetSubMenu(i)){
  903.       m_MenuList[i]->nFlags=MF_POPUP|MF_BYPOSITION;
  904.       ModifyMenu(i,MF_POPUP|MF_BYPOSITION,
  905.         (UINT)GetSubMenu(i)->m_hMenu,str);
  906.     }
  907.     else{
  908.       m_MenuList[i]->nFlags=MF_STRING|MF_BYPOSITION;
  909.       ModifyMenu(i,MF_STRING|MF_BYPOSITION,m_MenuList[i]->nID,str);
  910.     }
  911.   }
  912.   
  913.   return(TRUE);
  914. }
  916. void BCMenu::InsertSpaces(void)
  917. {
  918.   int i,j,numitems,maxlength;
  919.   CString string,newstring;
  920.   CSize t;
  921.   CFont m_fontMenu;
  922.   LOGFONT m_lf;
  924.   ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  925.   NONCLIENTMETRICS nm;
  926.   nm.cbSize = sizeof (NONCLIENTMETRICS);
  927.   VERIFY (SystemParametersInfo (SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
  928.   m_lf =  nm.lfMenuFont;
  929.   m_fontMenu.CreateFontIndirect (&m_lf);
  931.   CWnd *pWnd = AfxGetMainWnd();  
  932.   CDC *pDC = pWnd->GetDC();
  933.   CFont* pFont = pDC->SelectObject (&m_fontMenu);
  934.   
  935.   numitems=GetMenuItemCount();
  936.   maxlength = -1;
  937.   for(i=0;i<numitems;++i){
  938.     string=m_MenuList[i]->GetString();
  939.     j=string.Find((char)9);
  940.     newstring.Empty();
  941.     if(j!=-1)newstring=string.Left(j);
  942.     else newstring=string;
  943.     newstring+=_T(" ");//SK: modified for Unicode correctness. 
  944.     LPCTSTR lpstrText = (LPCTSTR)newstring;
  945.     t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
  946.     if(t.cx>maxlength)maxlength = t.cx;
  947.   }
  948.   for(i=0;i<numitems;++i){
  949.     string=m_MenuList[i]->GetString();
  950.     j=string.Find((char)9);
  951.     if(j!=-1){
  952.       newstring.Empty();
  953.       newstring=string.Left(j);
  954.       LPCTSTR lpstrText = (LPCTSTR)(newstring);
  955.       t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
  956.       while(t.cx<maxlength){
  957.         newstring+=_T(' ');//SK: modified for Unicode correctness
  958.         LPCTSTR lpstrText = (LPCTSTR)(newstring);
  959.         t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
  960.       }
  961.       newstring+=string.Mid(j);
  962. #ifdef UNICODE      
  963.       m_MenuList[i]->SetWideString(newstring);//SK: modified for dynamic allocation
  964. #else
  965.       m_MenuList[i]->SetAnsiString(newstring);
  966. #endif
  967.     }
  968.   }
  969.   pDC->SelectObject (pFont);              // Select old font in
  970.   AfxGetMainWnd()->ReleaseDC(pDC);       // Release the DC
  971.   m_fontMenu.DeleteObject();
  972. }
  974. void BCMenu::LoadCheckmarkBitmap(int unselect, int select)
  975. {
  976.   if(unselect>0 && select>0){
  977.     m_selectcheck=select;
  978.     m_unselectcheck=unselect;
  979.     if(checkmaps)checkmaps->DeleteImageList();
  980.     else checkmaps=new(CImageList);
  981.     checkmaps->Create(m_iconX,m_iconY,ILC_MASK,2,1);
  982.     AddBitmapToImageList(checkmaps,unselect);
  983.     AddBitmapToImageList(checkmaps,select);
  984.   }
  985. }
  987. BOOL BCMenu::GetMenuText(UINT id, CString& string)
  988. {
  989.   BOOL returnflag=FALSE;
  991.   UINT numMenuItems = m_MenuList.GetUpperBound();
  992.   if(id<=numMenuItems){
  993.     string=m_MenuList[id]->GetString();
  994.     returnflag=TRUE;
  995.   }
  996.   return(returnflag);
  997. }
  999. void BCMenu::DrawRadioDot(CDC *pDC,int x,int y,COLORREF color)
  1000. {
  1001.   CRect rcDot(x,y,x+6,y+6);
  1002.   CBrush brush;
  1003.   CPen pen;
  1004.   brush.CreateSolidBrush(color);
  1005.   pen.CreatePen(PS_SOLID,0,color);
  1006.   pDC->SelectObject(&brush);
  1007.   pDC->SelectObject(&pen);
  1008.   pDC->Ellipse(&rcDot);
  1009.   pen.DeleteObject();
  1010.   brush.DeleteObject();
  1011. }
  1013. void BCMenu::DrawCheckMark(CDC* pDC,int x,int y,COLORREF color)
  1014. {
  1015.   pDC->SetPixel(x,y+2,color);
  1016.   pDC->SetPixel(x,y+3,color);
  1017.   pDC->SetPixel(x,y+4,color);
  1019.   pDC->SetPixel(x+1,y+3,color);
  1020.   pDC->SetPixel(x+1,y+4,color);
  1021.   pDC->SetPixel(x+1,y+5,color);
  1023.   pDC->SetPixel(x+2,y+4,color);
  1024.   pDC->SetPixel(x+2,y+5,color);
  1025.   pDC->SetPixel(x+2,y+6,color);
  1027.   pDC->SetPixel(x+3,y+3,color);
  1028.   pDC->SetPixel(x+3,y+4,color);
  1029.   pDC->SetPixel(x+3,y+5,color);
  1031.   pDC->SetPixel(x+4,y+2,color);
  1032.   pDC->SetPixel(x+4,y+3,color);
  1033.   pDC->SetPixel(x+4,y+4,color);
  1035.   pDC->SetPixel(x+5,y+1,color);
  1036.   pDC->SetPixel(x+5,y+2,color);
  1037.   pDC->SetPixel(x+5,y+3,color);
  1039.   pDC->SetPixel(x+6,y,color);
  1040.   pDC->SetPixel(x+6,y+1,color);
  1041.   pDC->SetPixel(x+6,y+2,color);
  1042. }
  1044. BCMenuData *BCMenu::FindMenuList(UINT nID)
  1045. {
  1046.   for(int i=0;i<=m_MenuList.GetUpperBound();++i){
  1047.     if(m_MenuList[i]->nID==nID && !m_MenuList[i]->syncflag){
  1048.       m_MenuList[i]->syncflag=1;
  1049.       return(m_MenuList[i]);
  1050.     }
  1051.   }
  1052.   return(NULL);
  1053. }
  1055. void BCMenu::InitializeMenuList(int value)
  1056. {
  1057.   for(int i=0;i<=m_MenuList.GetUpperBound();++i)
  1058.     m_MenuList[i]->syncflag=value;
  1059. }
  1061. void BCMenu::DeleteMenuList(void)
  1062. {
  1063.   for(int i=0;i<=m_MenuList.GetUpperBound();++i){
  1064.     if(!m_MenuList[i]->syncflag){
  1065.       delete m_MenuList[i];
  1066.     }
  1067.   }
  1068. }
  1070. void BCMenu::SynchronizeMenu(void)
  1071. {
  1072.   CTypedPtrArray<CPtrArray, BCMenuData*> temp;
  1073.   BCMenuData *mdata;
  1074.   CString string;
  1075.   UINT submenu,nID=0,state,j;
  1077.   InitializeMenuList(0);
  1078.   for(j=0;j<GetMenuItemCount();++j){
  1079.     mdata=NULL;
  1080.     state=GetMenuState(j,MF_BYPOSITION);
  1081.     if(state&MF_POPUP){
  1082.       submenu=(UINT)GetSubMenu(j)->m_hMenu;
  1083.       mdata=FindMenuList(submenu);
  1084.       GetMenuString(j,string,MF_BYPOSITION);
  1085.       if(!mdata)mdata=NewODMenu(j,
  1086.         (state&0xFF)|MF_BYPOSITION|MF_POPUP|MF_OWNERDRAW,submenu,string);
  1087.       else if(string.GetLength()>0)
  1088. #ifdef UNICODE
  1089.         mdata->SetWideString(string);  //SK: modified for dynamic allocation
  1090. #else
  1091.         mdata->SetAnsiString(string);
  1092. #endif
  1093.     }
  1094.     else if(state&MF_SEPARATOR){
  1095.       mdata=FindMenuList(0);
  1096.       if(!mdata)mdata=NewODMenu(j,
  1097.         state|MF_BYPOSITION|MF_SEPARATOR|MF_OWNERDRAW,0,_T(""));//SK: modified for Unicode correctness
  1098.       else ModifyMenu(j,mdata->nFlags,nID,(LPCTSTR)mdata);
  1099.     }
  1100.     else{
  1101.       nID=GetMenuItemID(j);
  1102.       mdata=FindMenuList(nID);
  1103.       GetMenuString(j,string,MF_BYPOSITION);
  1104.       if(!mdata)mdata=NewODMenu(j,state|MF_BYPOSITION|MF_OWNERDRAW,
  1105.         nID,string);
  1106.       else{
  1107.         mdata->nFlags=state|MF_BYPOSITION|MF_OWNERDRAW;
  1108.         if(string.GetLength()>0)
  1109. #ifdef UNICODE
  1110.     mdata->SetWideString(string);//SK: modified for dynamic allocation
  1111. #else
  1112.             mdata->SetAnsiString(string);
  1113. #endif
  1114.             
  1115.         ModifyMenu(j,mdata->nFlags,nID,(LPCTSTR)mdata);
  1116.       }
  1117.     }
  1118.     if(mdata)temp.Add(mdata);
  1119.   }
  1120.   DeleteMenuList();
  1121.   m_MenuList.RemoveAll();
  1122.   m_MenuList.Append(temp);
  1123.   temp.RemoveAll(); 
  1124. }
  1126. void BCMenu::UpdateMenu(CMenu *pmenu)
  1127. {
  1128. #ifdef _CPPRTTI 
  1129.   BCMenu *psubmenu = dynamic_cast<BCMenu *>(pmenu);
  1130. #else
  1131.   BCMenu *psubmenu = (BCMenu *)pmenu;
  1132. #endif
  1133.   if(psubmenu)psubmenu->SynchronizeMenu();
  1134. }
  1136. LRESULT BCMenu::FindKeyboardShortcut(UINT nChar, UINT nFlags,
  1137.                                      CMenu *pMenu)
  1138. {
  1139. #ifdef _CPPRTTI 
  1140.   BCMenu *pBCMenu = dynamic_cast<BCMenu *>(pMenu);
  1141. #else
  1142.   BCMenu *pBCMenu = (BCMenu *)pMenu;
  1143. #endif
  1144.   if(pBCMenu && nFlags&MF_POPUP){
  1145.     CString key(_T('&'),2);//SK: modified for Unicode correctness
  1146. key.SetAt(1,(TCHAR)nChar);
  1147. key.MakeLower();
  1148.     CString menutext;
  1149.     int menusize = (int)pBCMenu->GetMenuItemCount();
  1150.     if(menusize!=(pBCMenu->m_MenuList.GetUpperBound()+1))
  1151.       pBCMenu->SynchronizeMenu();
  1152.     for(int i=0;i<menusize;++i){
  1153.       if(pBCMenu->GetMenuText(i,menutext)){
  1154.         menutext.MakeLower();
  1155.         if(menutext.Find(key)>=0)return(MAKELRESULT(i,2));
  1156.       }
  1157.     }
  1158.   }
  1159.   return(0);
  1160. }
  1162. void BCMenu::DitherBlt (HDC hdcDest, int nXDest, int nYDest, int nWidth, 
  1163.                         int nHeight, HBITMAP hbm, int nXSrc, int nYSrc)
  1164. {
  1165.   ASSERT(hdcDest && hbm);
  1166.   ASSERT(nWidth > 0 && nHeight > 0);
  1167.   
  1168.   // Create a generic DC for all BitBlts
  1169.   HDC hDC = CreateCompatibleDC(hdcDest);
  1170.   ASSERT(hDC);
  1171.   
  1172.   if (hDC)
  1173.   {
  1174.     // Create a DC for the monochrome DIB section
  1175.     HDC bwDC = CreateCompatibleDC(hDC);
  1176.     ASSERT(bwDC);
  1177.     
  1178.     if (bwDC)
  1179.     {
  1180.       // Create the monochrome DIB section with a black and white palette
  1181.       struct {
  1182.         BITMAPINFOHEADER bmiHeader; 
  1183.         RGBQUAD      bmiColors[2]; 
  1184.       } RGBBWBITMAPINFO = {
  1185.         
  1186.         {    // a BITMAPINFOHEADER
  1187.           sizeof(BITMAPINFOHEADER),  // biSize 
  1188.             nWidth,         // biWidth; 
  1189.             nHeight,        // biHeight; 
  1190.             1,            // biPlanes; 
  1191.             1,            // biBitCount 
  1192.             BI_RGB,         // biCompression; 
  1193.             0,            // biSizeImage; 
  1194.             0,            // biXPelsPerMeter; 
  1195.             0,            // biYPelsPerMeter; 
  1196.             0,            // biClrUsed; 
  1197.             0            // biClrImportant; 
  1198.         },    
  1199.         {
  1200.           { 0x00, 0x00, 0x00, 0x00 }, { 0xFF, 0xFF, 0xFF, 0x00 }
  1201.         } 
  1202.       };
  1203.       VOID *pbitsBW;
  1204.       HBITMAP hbmBW = CreateDIBSection(bwDC,
  1205.         (LPBITMAPINFO)&RGBBWBITMAPINFO, DIB_RGB_COLORS, &pbitsBW, NULL, 0);
  1206.       ASSERT(hbmBW);
  1207.       
  1208.       if (hbmBW)
  1209.       {
  1210.         // Attach the monochrome DIB section and the bitmap to the DCs
  1211.         HBITMAP olddib = (HBITMAP)SelectObject(bwDC, hbmBW);
  1212.         SelectObject(hDC, hbm);
  1213.         
  1214.         // BitBlt the bitmap into the monochrome DIB section
  1215.         BitBlt(bwDC, 0, 0, nWidth, nHeight, hDC, nXSrc, nYSrc, SRCCOPY);
  1216.         
  1217.         // Paint the destination rectangle in gray
  1218.         FillRect(hdcDest, CRect(nXDest, nYDest, nXDest + nWidth, nYDest +
  1219. nHeight), GetSysColorBrush((IsNewShell())?COLOR_3DFACE:COLOR_MENU));
  1220.             //SK: looks better on the old shell
  1221.         // BitBlt the black bits in the monochrome bitmap into COLOR_3DHILIGHT
  1222.         // bits in the destination DC
  1223.         // The magic ROP comes from the Charles Petzold's book
  1224.         HBRUSH hb = CreateSolidBrush(GetSysColor(COLOR_3DHILIGHT));
  1225.         HBRUSH oldBrush = (HBRUSH)SelectObject(hdcDest, hb);
  1226.         BitBlt(hdcDest,nXDest+1,nYDest+1,nWidth,nHeight,bwDC,0,0,0xB8074A);
  1227.         
  1228.         // BitBlt the black bits in the monochrome bitmap into COLOR_3DSHADOW
  1229.         // bits in the destination DC
  1230.         hb = CreateSolidBrush(GetSysColor(COLOR_3DSHADOW));
  1231.         DeleteObject(SelectObject(hdcDest, hb));
  1232.         BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight,bwDC,0,0,0xB8074A);
  1233.         DeleteObject(SelectObject(hdcDest, oldBrush));
  1234.         VERIFY(DeleteObject(SelectObject(bwDC, olddib)));
  1235.       }
  1236.       
  1237.       VERIFY(DeleteDC(bwDC));
  1238.     }
  1239.     
  1240.     VERIFY(DeleteDC(hDC));
  1241.   }
  1242. }
  1244. int BCMenu::AddBitmapToImageList(CImageList *bmplist,UINT nResourceID)
  1245. {
  1246.   int bReturn;
  1248.   HBITMAP hbmp=LoadSysColorBitmap(nResourceID);
  1249.   if(hbmp){
  1250.     CBitmap bmp;
  1251.     bmp.Attach(hbmp);
  1252.     if(m_bitmapBackgroundFlag) bReturn=bmplist->Add(&bmp,m_bitmapBackground);
  1253.     else bReturn=bmplist->Add(&bmp,GetSysColor(COLOR_3DFACE));
  1254.     bmp.Detach();
  1255.     DeleteObject(hbmp);
  1256.   }
  1257.   else bReturn = -1;
  1258.   return(bReturn);
  1259. }
  1261. void BCMenu::SetBitmapBackground(COLORREF color)
  1262. {
  1263.   m_bitmapBackground=color;
  1264.   m_bitmapBackgroundFlag=TRUE;
  1265. }
  1267. void BCMenu::UnSetBitmapBackground(void)
  1268. {
  1269.   m_bitmapBackgroundFlag=FALSE;
  1270. }
  1272. // Given a toolbar, append all the options from it to this menu
  1273. // Passed a ptr to the toolbar object and the toolbar ID
  1274. // Author : Robert Edward Caldecott
  1275. void BCMenu::AddFromToolBar(CToolBar* pToolBar, int nResourceID)
  1276. {
  1277.   for (int i = 0; i < pToolBar->GetCount(); i++) {
  1278.     UINT nID = pToolBar->GetItemID(i);
  1279.     // See if this toolbar option
  1280.     // appears as a command on this
  1281.     // menu or is a separator
  1282.     if (nID == 0 || GetMenuState(nID, MF_BYCOMMAND) == 0xFFFFFFFF)
  1283.       continue; // Item doesn't exist
  1284.     UINT nStyle;
  1285.     int nImage;
  1286.     // Get the toolbar button info
  1287.     pToolBar->GetButtonInfo(i, nID, nStyle, nImage);
  1288.     // OK, we have the command ID of the toolbar
  1289.     // option, and the tollbar bitmap offset
  1290.     int nLoc;
  1291.     BCMenuData* pData;
  1292.     BCMenu *pSubMenu = FindMenuOption(nID, nLoc);
  1293.     if (pSubMenu && nLoc >= 0)pData = pSubMenu->m_MenuList[nLoc];
  1294.     else {
  1295.       // Create a new BCMenuData structure
  1296.       pData = new BCMenuData;
  1297.       m_MenuList.Add(pData);
  1298.     }
  1299.     // Set some default structure members
  1300.     pData->menuIconNormal = nResourceID;
  1301.     pData->nID = nID;
  1302.     pData->nFlags =  MF_BYCOMMAND | MF_OWNERDRAW;
  1303.     pData->xoffset = nImage;
  1304.     if (pData->bitmap)pData->bitmap->DeleteImageList();
  1305.     else pData->bitmap = new CImageList;
  1306.     pData->bitmap->Create(m_iconX, m_iconY,ILC_COLORDDB|ILC_MASK, 1, 1);
  1307.     AddBitmapToImageList(pData->bitmap, nResourceID);
  1308.     // Modify our menu
  1309.     ModifyMenu(nID,pData->nFlags,nID,(LPCTSTR)pData);
  1310.   }
  1311. }
  1313. BOOL BCMenu::Draw3DCheckmark(CDC *dc, const CRect& rc,
  1314.                              BOOL bSelected, HBITMAP hbmCheck)
  1315. {
  1316.   CRect rcDest = rc;
  1317.   CBrush brush;
  1318.   COLORREF col=GetSysColor((bSelected||!IsNewShell())?COLOR_MENU:COLOR_3DLIGHT);//SK: Looks better on the old shell
  1319.   brush.CreateSolidBrush(col);
  1320.   dc->FillRect(rcDest,&brush);
  1321.   brush.DeleteObject();
  1322.   if (IsNewShell()) //SK: looks better on the old shell
  1323.     dc->DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT);
  1324.   if (!hbmCheck)DrawCheckMark(dc,rc.left+4,rc.top+4,GetSysColor(COLOR_MENUTEXT));
  1325.   else DrawRadioDot(dc,rc.left+5,rc.top+4,GetSysColor(COLOR_MENUTEXT));
  1326.   return TRUE;
  1327. }
  1329. void BCMenu::DitherBlt2(CDC *drawdc, int nXDest, int nYDest, int nWidth, 
  1330.                         int nHeight, CBitmap &bmp, int nXSrc, int nYSrc)
  1331. {
  1332. // create a monochrome memory DC
  1333. CDC ddc;
  1334. ddc.CreateCompatibleDC(0);
  1335.   CBitmap bwbmp;
  1336. bwbmp.CreateCompatibleBitmap(&ddc, nWidth, nHeight);
  1337. CBitmap * pddcOldBmp = ddc.SelectObject(&bwbmp);
  1339.   CDC dc;
  1340. dc.CreateCompatibleDC(0);
  1341.   CBitmap * pdcOldBmp = dc.SelectObject(&bmp);
  1343. // build a mask
  1344. ddc.PatBlt(0, 0, nWidth, nHeight, WHITENESS);
  1345. dc.SetBkColor(GetSysColor(COLOR_BTNFACE));
  1346. ddc.BitBlt(0, 0, nWidth, nHeight, &dc, nXSrc,nYSrc, SRCCOPY);
  1347. dc.SetBkColor(GetSysColor(COLOR_BTNHILIGHT));
  1348. ddc.BitBlt(0, 0, nWidth, nHeight, &dc, nXSrc,nYSrc, SRCPAINT);
  1350. // Copy the image from the toolbar into the memory DC
  1351. // and draw it (grayed) back into the toolbar.
  1352. dc.FillSolidRect(0,0, nWidth, nHeight, GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU));
  1353.         //SK: Looks better on the old shell
  1354. dc.SetBkColor(RGB(0, 0, 0));
  1355. dc.SetTextColor(RGB(255, 255, 255));
  1356. CBrush brShadow, brHilight;
  1357. brHilight.CreateSolidBrush(GetSysColor(COLOR_BTNHILIGHT));
  1358. brShadow.CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
  1359. CBrush * pOldBrush = dc.SelectObject(&brHilight);
  1360. dc.BitBlt(0,0, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
  1361. drawdc->BitBlt(nXDest+1,nYDest+1,nWidth, nHeight, &dc,0,0,SRCCOPY);
  1362. dc.BitBlt(1,1, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
  1363. dc.SelectObject(&brShadow);
  1364. dc.BitBlt(0,0, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
  1365. drawdc->BitBlt(nXDest,nYDest,nWidth, nHeight, &dc,0,0,SRCCOPY);
  1366. // reset DCs
  1367. ddc.SelectObject(pddcOldBmp);
  1368. ddc.DeleteDC();
  1369. dc.SelectObject(pOldBrush);
  1370. dc.SelectObject(pdcOldBmp);
  1371. dc.DeleteDC();
  1373. bwbmp.DeleteObject();
  1374. }
  1376. void BCMenu::SetDisableOldStyle(void)
  1377. {
  1378.   disable_old_style=TRUE;
  1379. }
  1381. void BCMenu::UnSetDisableOldStyle(void)
  1382. {
  1383.   disable_old_style=FALSE;
  1384. }
  1386. BOOL BCMenu::GetDisableOldStyle(void)
  1387. {
  1388.   return(disable_old_style);
  1389. }
  1392. HBITMAP BCMenu::LoadSysColorBitmap(int nResourceId)
  1393. {
  1394.   HINSTANCE hInst = 
  1395.     AfxFindResourceHandle(MAKEINTRESOURCE(nResourceId),RT_BITMAP);
  1396.   HRSRC hRsrc = 
  1397.     ::FindResource(hInst,MAKEINTRESOURCE(nResourceId),RT_BITMAP);
  1398. if (hRsrc == NULL)
  1399. return NULL;
  1400. return AfxLoadSysColorBitmap(hInst, hRsrc, FALSE);
  1401. }
  1404. //*************************************************************************