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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 书籍源码 > 查看源码
BCMenu.cpp
资源名称：c++时尚编程百例__1-20.rar　[点击查看]
上传用户：aokegd
上传日期：2009-12-14
资源大小：1276k
文件大小：73k
源码类别：

书籍源码

开发平台：

Visual C++

BCMenu.cpp：源码内容
  1. //*************************************************************************
  2. // BCMenu.cpp : implementation file
  3. // Version : 3.0
  4. // Date : January 2002
  5. // Author : Brent Corkum
  6. // Email :  corkum@rocscience.com
  7. // Latest Version : http://www.rocscience.com/~corkum/BCMenu.html
  8. // 
  9. // Bug Fixes and portions of code supplied by:
  10. //
  11. // Ben Ashley,Girish Bharadwaj,Jean-Edouard Lachand-Robert,
  12. // Robert Edward Caldecott,Kenny Goers,Leonardo Zide,
  13. // Stefan Kuhr,Reiner Jung,Martin Vladic,Kim Yoo Chul,
  14. // Oz Solomonovich,Tongzhe Cui,Stephane Clog,Warren Stevens,
  15. // Damir Valiulin
  16. //
  17. // You are free to use/modify this code but leave this header intact.
  18. // This class is public domain so you are free to use it any of
  19. // your applications (Freeware,Shareware,Commercial). All I ask is
  20. // that you let me know so that if you have a real winner I can
  21. // brag to my buddies that some of my code is in your app. I also
  22. // wouldn't mind if you sent me a copy of your application since I
  23. // like to play with new stuff.
  24. //*************************************************************************
  26. #include "stdafx.h"        // Standard windows header file
  27. #include "BCMenu.h"        // BCMenu class declaration
  28. #include <afxpriv.h>       //SK: makes A2W and other spiffy AFX macros work
  30. #ifdef _DEBUG
  31. #define new DEBUG_NEW
  32. #undef THIS_FILE
  33. static char THIS_FILE[] = __FILE__;
  34. #endif
  36. #define GAP 1
  37. #ifndef OBM_CHECK
  38. #define OBM_CHECK 32760 // from winuser.h
  39. #endif
  41. #if _MFC_VER <0x400
  42. #error This code does not work on Versions of MFC prior to 4.0
  43. #endif
  45. static CPINFO CPInfo;
  46. // how the menu's are drawn in win9x/NT/2000
  47. UINT BCMenu::original_drawmode=BCMENU_DRAWMODE_ORIGINAL;
  48. BOOL BCMenu::xp_select_disabled=FALSE;
  49. // how the menu's are drawn in winXP
  50. UINT BCMenu::xp_drawmode=BCMENU_DRAWMODE_XP;
  51. BOOL BCMenu::original_select_disabled=TRUE;
  53. enum Win32Type{
  54. Win32s,
  55. Windoze95,
  56. WinNT3,
  57. WinNT4orHigher
  58. };
  61. Win32Type IsShellType()
  62. {
  63. Win32Type  ShellType;
  64. DWORD winVer;
  65. OSVERSIONINFO *osvi;
  67. winVer=GetVersion();
  68. if(winVer<0x80000000){/*NT */
  69. ShellType=WinNT3;
  70. osvi= (OSVERSIONINFO *)malloc(sizeof(OSVERSIONINFO));
  71. if (osvi!=NULL){
  72. memset(osvi,0,sizeof(OSVERSIONINFO));
  73. osvi->dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
  74. GetVersionEx(osvi);
  75. if (osvi->dwMajorVersion>=4L)
  76. ShellType=WinNT4orHigher;//yup, it is NT 4 or higher!
  77. free(osvi);
  78. }
  79. }
  80. else if  (LOBYTE(LOWORD(winVer))<4)
  81. ShellType=Win32s;/*Win32s*/
  82. else
  83. ShellType=Windoze95;/*Windoze95*/
  84. return ShellType;
  85. }
  87. static Win32Type g_Shell=IsShellType();
  89. void BCMenuData::SetAnsiString(LPCSTR szAnsiString)
  90. {
  91. USES_CONVERSION;
  92. SetWideString(A2W(szAnsiString));  //SK:  see MFC Tech Note 059
  93. }
  95. CString BCMenuData::GetString(void)//returns the menu text in ANSI or UNICODE
  96. //depending on the MFC-Version we are using
  97. {
  98. CString strText;
  99. if (m_szMenuText)
  100.     {
  101. #ifdef UNICODE
  102. strText = m_szMenuText;
  103. #else
  104. USES_CONVERSION;
  105. strText=W2A(m_szMenuText);     //SK:  see MFC Tech Note 059
  106. #endif    
  107.     }
  108. return strText;
  109. }
  111. CTypedPtrArray<CPtrArray, HMENU> BCMenu::m_AllSubMenus;  // Stores list of all sub-menus
  113. /*
  114. ===============================================================================
  115. BCMenu::BCMenu()
  116. BCMenu::~BCMenu()
  117. -----------------
  119. Constructor and Destructor.
  121. ===============================================================================
  122. */
  124. BCMenu::BCMenu()
  125. {
  126. m_bDynIcons = FALSE;     // O.S. - no dynamic icons by default
  127. disable_old_style=FALSE;
  128. m_iconX = 16;            // Icon sizes default to 16 x 16
  129. m_iconY = 15;            // ...
  130. m_selectcheck = -1;
  131. m_unselectcheck = -1;
  132. checkmaps=NULL;
  133. checkmapsshare=FALSE;
  134. // set the color used for the transparent background in all bitmaps
  135. m_bitmapBackground=RGB(192,192,192); //gray
  136. m_bitmapBackgroundFlag=FALSE;
  137. GetCPInfo(CP_ACP,&CPInfo);
  138. }
  141. BCMenu::~BCMenu()
  142. {
  143. DestroyMenu();
  144. }
  146. BOOL BCMenu::IsNewShell ()
  147. {
  148. return (Windoze95==g_Shell || WinNT4orHigher==g_Shell);
  149. }
  152. BCMenuData::~BCMenuData()
  153. {
  154. if(bitmap)
  155. delete(bitmap);
  157. delete[] m_szMenuText; //Need not check for NULL because ANSI X3J16 allows "delete NULL"
  158. }
  161. void BCMenuData::SetWideString(const wchar_t *szWideString)
  162. {
  163. delete[] m_szMenuText;//Need not check for NULL because ANSI X3J16 allows "delete NULL"
  165. if (szWideString)
  166.     {
  167. m_szMenuText = new wchar_t[sizeof(wchar_t)*(wcslen(szWideString)+1)];
  168. if (m_szMenuText)
  169. wcscpy(m_szMenuText,szWideString);
  170.     }
  171. else
  172. m_szMenuText=NULL;//set to NULL so we need not bother about dangling non-NULL Ptrs
  173. }
  175. BOOL BCMenu::IsMenu(CMenu *submenu)
  176. {
  177. int m;
  178. int numSubMenus = m_AllSubMenus.GetUpperBound();
  179. for(m=0;m<=numSubMenus;++m){
  180. if(submenu->m_hMenu==m_AllSubMenus[m])return(TRUE);
  181. }
  182. return(FALSE);
  183. }
  185. BOOL BCMenu::IsMenu(HMENU submenu)
  186. {
  187. int m;
  188. int numSubMenus = m_AllSubMenus.GetUpperBound();
  189. for(m=0;m<=numSubMenus;++m){
  190. if(submenu==m_AllSubMenus[m])return(TRUE);
  191. }
  192. return(FALSE);
  193. }
  195. BOOL BCMenu::DestroyMenu()
  196. {
  197. // Destroy Sub menus:
  198. int m,n;
  199. int numAllSubMenus = m_AllSubMenus.GetUpperBound();
  200. for(n = numAllSubMenus; n>= 0; n--){
  201. if(m_AllSubMenus[n]==this->m_hMenu)m_AllSubMenus.RemoveAt(n);
  202. }
  203. int numSubMenus = m_SubMenus.GetUpperBound();
  204. for(m = numSubMenus; m >= 0; m--){
  205. numAllSubMenus = m_AllSubMenus.GetUpperBound();
  206. for(n = numAllSubMenus; n>= 0; n--){
  207. if(m_AllSubMenus[n]==m_SubMenus[m])m_AllSubMenus.RemoveAt(n);
  208. }
  209. delete((BCMenu *)FromHandle(m_SubMenus[m]));
  210. }
  211. m_SubMenus.RemoveAll();
  212. // Destroy menu data
  213. int numItems = m_MenuList.GetUpperBound();
  214. for(m = 0; m <= numItems; m++)delete(m_MenuList[m]);
  215. m_MenuList.RemoveAll();
  216. if(checkmaps&&!checkmapsshare){
  217. delete checkmaps;
  218. checkmaps=NULL;
  219. }
  220. // Call base-class implementation last:
  221. return(CMenu::DestroyMenu());
  222. };
  224. int BCMenu::GetMenuDrawMode(void)
  225. {
  226. COLORREF m_newclrBack=GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU);
  227. COLORREF m_clrBack=GetSysColor(COLOR_MENU);
  228. BOOL XPflag = m_newclrBack==m_clrBack ? FALSE : TRUE;
  229. if(XPflag)return(xp_drawmode);
  230. return(original_drawmode);
  231. }
  234. /*
  235. ==========================================================================
  236. void BCMenu::DrawItem(LPDRAWITEMSTRUCT)
  237. ---------------------------------------
  239.   Called by the framework when a particular item needs to be drawn.  We
  240.   overide this to draw the menu item in a custom-fashion, including icons
  241.   and the 3D rectangle bar.
  242.   ==========================================================================
  243. */
  245. void BCMenu::DrawItem (LPDRAWITEMSTRUCT lpDIS)
  246. {
  247. ASSERT(lpDIS != NULL);
  248. COLORREF m_newclrBack=GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU);
  249. COLORREF m_clrBack=GetSysColor(COLOR_MENU);
  250. BOOL XPflag = m_newclrBack==m_clrBack ? FALSE : TRUE;
  251. CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  252. if(pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)DrawItem_Win9xNT2000(lpDIS);
  253. else{
  254. if(XPflag){
  255. if(xp_drawmode==BCMENU_DRAWMODE_XP) DrawItem_WinXP(lpDIS);
  256. else DrawItem_Win9xNT2000(lpDIS);
  257. }
  258. else{
  259. if(original_drawmode==BCMENU_DRAWMODE_XP) DrawItem_WinXP(lpDIS);
  260. else DrawItem_Win9xNT2000(lpDIS);
  261. }
  262. }
  263. }
  265. void BCMenu::DrawItem_Win9xNT2000 (LPDRAWITEMSTRUCT lpDIS)
  266. {
  267. ASSERT(lpDIS != NULL);
  268. CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  269. CRect rect;
  270. UINT state = (((BCMenuData*)(lpDIS->itemData))->nFlags);
  271. CBrush m_brBackground;
  273. m_brBackground.CreateSolidBrush(GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU));
  275. // remove the selected bit if it's grayed out
  276. if(lpDIS->itemState & ODS_GRAYED&&!original_select_disabled){
  277. if(lpDIS->itemState & ODS_SELECTED)lpDIS->itemState=lpDIS->itemState & ~ODS_SELECTED;
  278. }
  280. if(state & MF_SEPARATOR){
  281. rect.CopyRect(&lpDIS->rcItem);
  282. pDC->FillRect (rect,&m_brBackground);
  283. rect.top += (rect.Height()>>1);
  284. pDC->DrawEdge(&rect,EDGE_ETCHED,BF_TOP);
  285. }
  286. else{
  287. CRect rect2;
  288. BOOL standardflag=FALSE,selectedflag=FALSE,disableflag=FALSE;
  289. BOOL checkflag=FALSE;
  290. COLORREF crText = GetSysColor(COLOR_MENUTEXT);
  291. COLORREF m_clrBack=GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU);
  292. CBrush m_brSelect;
  293. CPen m_penBack;
  294. int x0,y0,dy;
  295. int nIconNormal=-1,xoffset=-1;
  296. CImageList *bitmap=NULL;
  297. CFont m_fontMenu;
  298. LOGFONT m_lf;
  300. // set some colors and the font
  301. m_penBack.CreatePen (PS_SOLID,0,GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU));
  302. m_brSelect.CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
  303. ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  304. NONCLIENTMETRICS nm;
  305. nm.cbSize = sizeof (NONCLIENTMETRICS);
  306. VERIFY (SystemParametersInfo(SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
  307. m_lf =  nm.lfMenuFont;
  308. m_fontMenu.CreateFontIndirect (&m_lf);
  310. // draw the colored rectangle portion
  312. rect.CopyRect(&lpDIS->rcItem);
  313. rect2=rect;
  315. // draw the up/down/focused/disabled state
  317. UINT state = lpDIS->itemState;
  318. CString strText;
  319. LOGFONT lf;
  320. lf = m_lf;
  322. CFont dispFont;
  323. CFont *pFont=NULL;
  325. if(lpDIS->itemData != NULL){
  326. nIconNormal = (((BCMenuData*)(lpDIS->itemData))->menuIconNormal);
  327. xoffset = (((BCMenuData*)(lpDIS->itemData))->xoffset);
  328. bitmap = (((BCMenuData*)(lpDIS->itemData))->bitmap);
  329. strText = ((BCMenuData*) (lpDIS->itemData))->GetString();
  331. if(state&ODS_CHECKED && nIconNormal<0){
  332. if(state&ODS_SELECTED && m_selectcheck>0)checkflag=TRUE;
  333. else if(m_unselectcheck>0) checkflag=TRUE;
  334. }
  335. else if(nIconNormal != -1){
  336. standardflag=TRUE;
  337. if(state&ODS_SELECTED && !(state&ODS_GRAYED))selectedflag=TRUE;
  338. else if(state&ODS_GRAYED) disableflag=TRUE;
  339. }
  340. }
  341. else{
  342. strText.Empty();
  343. }
  345. if(state&ODS_SELECTED){ // draw the down edges
  347. CPen *pOldPen = pDC->SelectObject (&m_penBack);
  349. // You need only Text highlight and thats what you get
  351. if(checkflag||standardflag||selectedflag||disableflag||state&ODS_CHECKED)
  352. rect2.SetRect(rect.left+m_iconX+4+GAP,rect.top,rect.right,rect.bottom);
  353. pDC->FillRect (rect2,&m_brSelect);
  355. pDC->SelectObject (pOldPen);
  356. if((HFONT)dispFont != NULL)dispFont.DeleteObject ();
  357. dispFont.CreateFontIndirect (&lf);
  358. crText = GetSysColor(COLOR_HIGHLIGHTTEXT);
  359. }
  360. else {
  361. CPen *pOldPen = pDC->SelectObject (&m_penBack);
  362. pDC->FillRect (rect,&m_brBackground);
  363. pDC->SelectObject (pOldPen);
  365. // draw the up edges
  367. pDC->Draw3dRect (rect,m_clrBack,m_clrBack);
  368. if ((HFONT)dispFont != NULL) dispFont.DeleteObject ();
  369. dispFont.CreateFontIndirect (&lf); //Normal
  370. }
  372. // draw the text if there is any
  373. //We have to paint the text only if the image is nonexistant
  375. dy = (rect.Height()-4-m_iconY)/2;
  376. dy = dy<0 ? 0 : dy;
  378. if(checkflag||standardflag||selectedflag||disableflag){
  379. rect2.SetRect(rect.left+1,rect.top+1+dy,rect.left+m_iconX+3,
  380. rect.top+m_iconY+3+dy);
  381. pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  382. if(checkflag && checkmaps){
  383. pDC->FillRect (rect2,&m_brBackground);
  384. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  385. rect.top+m_iconY+4+dy);
  387. pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  388. CPoint ptImage(rect.left+2,rect.top+2+dy);
  390. if(state&ODS_SELECTED)checkmaps->Draw(pDC,1,ptImage,ILD_TRANSPARENT);
  391. else checkmaps->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
  392. }
  393. else if(disableflag){
  394. if(!selectedflag){
  395. CBitmap bitmapstandard;
  396. GetBitmapFromImageList(pDC,bitmap,xoffset,bitmapstandard);
  397. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  398.                         rect.top+m_iconY+4+dy);
  399. pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  400. if(disable_old_style)
  401. DitherBlt(lpDIS->hDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
  402. (HBITMAP)(bitmapstandard),0,0,m_clrBack);
  403. else
  404. DitherBlt2(pDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
  405. bitmapstandard,0,0,m_clrBack);
  406. bitmapstandard.DeleteObject();
  407. }
  408. }
  409. else if(selectedflag){
  410. pDC->FillRect (rect2,&m_brBackground);
  411. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  412. rect.top+m_iconY+4+dy);
  413. if (IsNewShell()){
  414. if(state&ODS_CHECKED)
  415. pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
  416. GetSysColor(COLOR_3DHILIGHT));
  417. else
  418. pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DHILIGHT),
  419. GetSysColor(COLOR_3DSHADOW));
  420. }
  421. CPoint ptImage(rect.left+2,rect.top+2+dy);
  422. if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
  423. }
  424. else{
  425. if(state&ODS_CHECKED){
  426. CBrush brush;
  427. COLORREF col =GetSysColor(COLOR_3DLIGHT);
  428. brush.CreateSolidBrush(col);
  429. pDC->FillRect(rect2,&brush);
  430. brush.DeleteObject();
  431. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  432.                         rect.top+m_iconY+4+dy);
  433. if (IsNewShell())
  434. pDC->Draw3dRect(rect2,GetSysColor(COLOR_3DSHADOW),
  435. GetSysColor(COLOR_3DHILIGHT));
  436. }
  437. else{
  438. pDC->FillRect (rect2,&m_brBackground);
  439. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  440.                         rect.top+m_iconY+4+dy);
  441. pDC->Draw3dRect (rect2,m_clrBack,m_clrBack);
  442. }
  443. CPoint ptImage(rect.left+2,rect.top+2+dy);
  444. if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
  445. }
  446. }
  447. if(nIconNormal<0 && state&ODS_CHECKED && !checkflag){
  448. rect2.SetRect(rect.left+1,rect.top+2+dy,rect.left+m_iconX+1,
  449. rect.top+m_iconY+2+dy);
  450. CMenuItemInfo info;
  451. info.fMask = MIIM_CHECKMARKS;
  452. ::GetMenuItemInfo((HMENU)lpDIS->hwndItem,lpDIS->itemID,
  453. MF_BYCOMMAND, &info);
  454. if(state&ODS_CHECKED || info.hbmpUnchecked) {
  455. Draw3DCheckmark(pDC, rect2, state&ODS_SELECTED,
  456. state&ODS_CHECKED ? info.hbmpChecked :
  457. info.hbmpUnchecked);
  458. }
  459. }
  461. //This is needed always so that we can have the space for check marks
  463. x0=rect.left;y0=rect.top;
  464. rect.left = rect.left + m_iconX + 8 + GAP; 
  466. if(!strText.IsEmpty()){
  468. CRect rectt(rect.left,rect.top-1,rect.right,rect.bottom-1);
  470. //   Find tabs
  472. CString leftStr,rightStr;
  473. leftStr.Empty();rightStr.Empty();
  474. int tablocr=strText.ReverseFind(_T('t'));
  475. if(tablocr!=-1){
  476. rightStr=strText.Mid(tablocr+1);
  477. leftStr=strText.Left(strText.Find(_T('t')));
  478. rectt.right-=m_iconX;
  479. }
  480. else leftStr=strText;
  482. int iOldMode = pDC->GetBkMode();
  483. pDC->SetBkMode( TRANSPARENT);
  485. // Draw the text in the correct colour:
  487. UINT nFormat  = DT_LEFT|DT_SINGLELINE|DT_VCENTER;
  488. UINT nFormatr = DT_RIGHT|DT_SINGLELINE|DT_VCENTER;
  489. if(!(lpDIS->itemState & ODS_GRAYED)){
  490. pDC->SetTextColor(crText);
  491. pDC->DrawText (leftStr,rectt,nFormat);
  492. if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  493. }
  494. else{
  496. // Draw the disabled text
  497. if(!(state & ODS_SELECTED)){
  498. RECT offset = *rectt;
  499. offset.left+=1;
  500. offset.right+=1;
  501. offset.top+=1;
  502. offset.bottom+=1;
  503. pDC->SetTextColor(GetSysColor(COLOR_BTNHILIGHT));
  504. pDC->DrawText(leftStr,&offset, nFormat);
  505. if(tablocr!=-1) pDC->DrawText (rightStr,&offset,nFormatr);
  506. pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
  507. pDC->DrawText(leftStr,rectt, nFormat);
  508. if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  509. }
  510. else{
  511. // And the standard Grey text:
  512. pDC->SetTextColor(m_clrBack);
  513. pDC->DrawText(leftStr,rectt, nFormat);
  514. if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  515. }
  516. }
  517. pFont = pDC->SelectObject (&dispFont);
  518. pDC->SetBkMode( iOldMode );
  519. pDC->SelectObject (pFont); //set it to the old font
  520. }
  522. m_penBack.DeleteObject();
  523. m_fontMenu.DeleteObject();
  524. m_brSelect.DeleteObject();
  525. dispFont.DeleteObject ();
  526. }
  527. m_brBackground.DeleteObject();
  528. }
  530. COLORREF BCMenu::LightenColor(COLORREF col,double factor)
  531. {
  532. if(factor>0.0&&factor<=1.0){
  533. BYTE red,green,blue,lightred,lightgreen,lightblue;
  534. red = GetRValue(col);
  535. green = GetGValue(col);
  536. blue = GetBValue(col);
  537. lightred = (BYTE)((factor*(255-red)) + red);
  538. lightgreen = (BYTE)((factor*(255-green)) + green);
  539. lightblue = (BYTE)((factor*(255-blue)) + blue);
  540. col = RGB(lightred,lightgreen,lightblue);
  541. }
  542. return(col);
  543. }
  545. void BCMenu::DrawItem_WinXP (LPDRAWITEMSTRUCT lpDIS)
  546. {
  547. ASSERT(lpDIS != NULL);
  548. CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  549. #ifdef BCMENU_USE_MEMDC
  550. BCMenuMemDC *pMemDC=NULL;
  551. #endif
  552. CRect rect,rect2;
  553. UINT state = (((BCMenuData*)(lpDIS->itemData))->nFlags);
  554. COLORREF m_newclrBack=GetSysColor((IsNewShell())?COLOR_3DFACE:COLOR_MENU);
  555. COLORREF m_clrBack=GetSysColor(COLOR_MENU);
  556. BOOL XPflag = m_newclrBack==m_clrBack ? FALSE : TRUE;
  557. if(!XPflag){
  558. m_newclrBack=LightenColor(m_newclrBack,0.35);
  559. m_clrBack=RGB(255,255,255);
  560. }
  561. CBrush m_newbrBackground,m_brBackground;
  562. m_brBackground.CreateSolidBrush(m_clrBack);
  563. m_newbrBackground.CreateSolidBrush(m_newclrBack);
  565. // remove the selected bit if it's grayed out
  566. if(lpDIS->itemState & ODS_GRAYED&&!xp_select_disabled){
  567. if(lpDIS->itemState & ODS_SELECTED)lpDIS->itemState=lpDIS->itemState & ~ODS_SELECTED;
  568. #ifdef BCMENU_USE_MEMDC
  569. pMemDC=new BCMenuMemDC(pDC,&lpDIS->rcItem);
  570. pDC = pMemDC;
  571. #endif
  573. }
  575. if(state & MF_SEPARATOR){
  576. rect.CopyRect(&lpDIS->rcItem);
  577. pDC->FillRect (rect,&m_brBackground);
  578. rect2.SetRect(rect.left,rect.top,rect.left+m_iconX+4+GAP,rect.bottom);
  579. rect.top+=rect.Height()>>1;
  580. rect.left = rect2.right+4;
  581. pDC->DrawEdge(&rect,EDGE_ETCHED,BF_TOP);
  582. pDC->FillRect (rect2,&m_newbrBackground);
  583. pDC->Draw3dRect (rect2,m_newclrBack,m_newclrBack);
  584. }
  585. else{
  586. BOOL standardflag=FALSE,selectedflag=FALSE,disableflag=FALSE;
  587. BOOL checkflag=FALSE;
  588. COLORREF crText = GetSysColor(COLOR_MENUTEXT);
  589. COLORREF crSelect = GetSysColor(COLOR_HIGHLIGHT);
  590. COLORREF crSelectFill;
  591. if(!XPflag)crSelectFill=LightenColor(crSelect,0.85);
  592. else crSelectFill=LightenColor(crSelect,0.7);
  593. CBrush m_brSelect;
  594. CPen m_penBack;
  595. int x0,y0,dy;
  596. int nIconNormal=-1,xoffset=-1;
  597. CImageList *bitmap=NULL;
  598. CFont m_fontMenu;
  599. LOGFONT m_lf;
  601. // set some colors and the font
  602. m_penBack.CreatePen (PS_SOLID,0,m_clrBack);
  603. m_brSelect.CreateSolidBrush(crSelectFill);
  604. ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  605. NONCLIENTMETRICS nm;
  606. nm.cbSize = sizeof (NONCLIENTMETRICS);
  607. VERIFY (SystemParametersInfo(SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
  608. m_lf =  nm.lfMenuFont;
  609. m_fontMenu.CreateFontIndirect (&m_lf);
  611. // draw the colored rectangle portion
  613. rect.CopyRect(&lpDIS->rcItem);
  614. rect2=rect;
  616. // draw the up/down/focused/disabled state
  618. UINT state = lpDIS->itemState;
  619. CString strText;
  620. LOGFONT lf;
  621. lf = m_lf;
  623. CFont dispFont;
  624. CFont *pFont=NULL;
  626. if(lpDIS->itemData != NULL){
  627. nIconNormal = (((BCMenuData*)(lpDIS->itemData))->menuIconNormal);
  628. xoffset = (((BCMenuData*)(lpDIS->itemData))->xoffset);
  629. bitmap = (((BCMenuData*)(lpDIS->itemData))->bitmap);
  630. strText = ((BCMenuData*) (lpDIS->itemData))->GetString();
  632. if(state&ODS_CHECKED && nIconNormal<0){
  633. if(state&ODS_SELECTED && m_selectcheck>0)checkflag=TRUE;
  634. else if(m_unselectcheck>0) checkflag=TRUE;
  635. }
  636. else if(nIconNormal != -1){
  637. standardflag=TRUE;
  638. if(state&ODS_SELECTED && !(state&ODS_GRAYED))selectedflag=TRUE;
  639. else if(state&ODS_GRAYED) disableflag=TRUE;
  640. }
  641. }
  642. else{
  643. strText.Empty();
  644. }
  646. if(state&ODS_SELECTED){ // draw the down edges
  648. CPen *pOldPen = pDC->SelectObject (&m_penBack);
  650. pDC->FillRect (rect,&m_brSelect);
  651. pDC->Draw3dRect (rect,crSelect,crSelect);
  653. pDC->SelectObject (pOldPen);
  654. if((HFONT)dispFont != NULL)dispFont.DeleteObject ();
  655. dispFont.CreateFontIndirect (&lf);
  656. }
  657. else {
  658. rect2.SetRect(rect.left,rect.top,rect.left+m_iconX+4+GAP,rect.bottom);
  659. CPen *pOldPen = pDC->SelectObject (&m_penBack);
  660. pDC->FillRect (rect,&m_brBackground);
  661. pDC->FillRect (rect2,&m_newbrBackground);
  662. pDC->SelectObject (pOldPen);
  664. // draw the up edges
  666. pDC->Draw3dRect (rect,m_clrBack,m_clrBack);
  667. pDC->Draw3dRect (rect2,m_newclrBack,m_newclrBack);
  668. if ((HFONT)dispFont != NULL) dispFont.DeleteObject ();
  669. dispFont.CreateFontIndirect (&lf); //Normal
  670. }
  672. // draw the text if there is any
  673. //We have to paint the text only if the image is nonexistant
  675. dy = (rect.Height()-4-m_iconY)/2;
  676. dy = dy<0 ? 0 : dy;
  678. if(checkflag||standardflag||selectedflag||disableflag){
  679. rect2.SetRect(rect.left+1,rect.top+1+dy,rect.left+m_iconX+3,
  680. rect.top+m_iconY+3+dy);
  681. pDC->Draw3dRect (rect2,m_newclrBack,m_newclrBack);
  682. if(checkflag && checkmaps){
  683. pDC->FillRect (rect2,&m_newbrBackground);
  684. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  685. rect.top+m_iconY+4+dy);
  687. pDC->Draw3dRect (rect2,m_newclrBack,m_newclrBack);
  688. CPoint ptImage(rect.left+3,rect.top+2+dy);
  690. if(state&ODS_SELECTED)checkmaps->Draw(pDC,1,ptImage,ILD_TRANSPARENT);
  691. else checkmaps->Draw(pDC,0,ptImage,ILD_TRANSPARENT);
  692. }
  693. else if(disableflag){
  694. if(!selectedflag){
  695. CBitmap bitmapstandard;
  696. GetBitmapFromImageList(pDC,bitmap,xoffset,bitmapstandard);
  697. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  698.                         rect.top+m_iconY+4+dy);
  699. pDC->Draw3dRect (rect2,m_newclrBack,m_newclrBack);
  700. COLORREF transparentcol=m_newclrBack;
  701. if(state&ODS_SELECTED)transparentcol=crSelectFill;
  702. if(disable_old_style)
  703. DitherBlt(lpDIS->hDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
  704. (HBITMAP)(bitmapstandard),0,0,transparentcol);
  705. else
  706. DitherBlt2(pDC,rect.left+2,rect.top+2+dy,m_iconX,m_iconY,
  707. bitmapstandard,0,0,transparentcol);
  708. if(state&ODS_SELECTED)pDC->Draw3dRect (rect,crSelect,crSelect);
  709. bitmapstandard.DeleteObject();
  710. }
  711. }
  712. else if(selectedflag){
  713. pDC->FillRect (rect2,&m_brSelect);
  714. if (IsNewShell() && state&ODS_CHECKED){
  715. rect2.SetRect(rect.left,rect.top,rect.left+m_iconX+GAP+3,rect.bottom);
  716. pDC->Draw3dRect(rect2,crSelect,crSelect);
  717. }
  718. CPoint ptImage(rect.left+3,rect.top+2+dy);
  719. if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
  720. }
  721. else{
  722. if(state&ODS_CHECKED){
  723. if(!XPflag)rect2.SetRect(rect.left+1,rect.top,rect.left+m_iconX+GAP+3,rect.bottom);
  724. else rect2.SetRect(rect.left+1,rect.top,rect.left+m_iconX+GAP+3,rect.bottom-1);
  725. CBrush brushin;
  726. brushin.CreateSolidBrush(LightenColor(crSelect,0.85));
  727. pDC->FillRect(rect2,&brushin);
  728. brushin.DeleteObject();
  729. pDC->Draw3dRect(rect2,crSelect,crSelect);
  730. }
  731. else{
  732. pDC->FillRect (rect2,&m_newbrBackground);
  733. rect2.SetRect(rect.left,rect.top+dy,rect.left+m_iconX+4,
  734.                         rect.top+m_iconY+4+dy);
  735. pDC->Draw3dRect (rect2,m_newclrBack,m_newclrBack);
  736. }
  737. CPoint ptImage(rect.left+3,rect.top+2+dy);
  738. if(bitmap)bitmap->Draw(pDC,xoffset,ptImage,ILD_TRANSPARENT);
  739. }
  740. }
  741. if(nIconNormal<0 && state&ODS_CHECKED && !checkflag){
  742. CMenuItemInfo info;
  743. info.fMask = MIIM_CHECKMARKS;
  744. ::GetMenuItemInfo((HMENU)lpDIS->hwndItem,lpDIS->itemID,
  745. MF_BYCOMMAND, &info);
  746. if(state&ODS_CHECKED || info.hbmpUnchecked) {
  747. if(XPflag)rect2.SetRect(rect.left+2,rect.top+2+dy,rect.left+m_iconX+2,rect.top+m_iconY+3+dy);
  748. else rect2.SetRect(rect.left+2,rect.top+2+dy,rect.left+m_iconX+2,rect.top+m_iconY+2+dy);
  749. DrawXPCheckmark(pDC, rect2,state&ODS_CHECKED ? info.hbmpChecked :
  750. info.hbmpUnchecked,crSelect);
  751. }
  752. }
  754. //This is needed always so that we can have the space for check marks
  756. x0=rect.left;y0=rect.top;
  757. rect.left = rect.left + m_iconX + 8 + GAP; 
  759. if(!strText.IsEmpty()){
  761. CRect rectt(rect.left,rect.top-1,rect.right,rect.bottom-1);
  763. //   Find tabs
  765. CString leftStr,rightStr;
  766. leftStr.Empty();rightStr.Empty();
  767. int tablocr=strText.ReverseFind(_T('t'));
  768. if(tablocr!=-1){
  769. rightStr=strText.Mid(tablocr+1);
  770. leftStr=strText.Left(strText.Find(_T('t')));
  771. rectt.right-=m_iconX;
  772. }
  773. else leftStr=strText;
  775. int iOldMode = pDC->GetBkMode();
  776. pDC->SetBkMode( TRANSPARENT);
  778. // Draw the text in the correct colour:
  780. pFont = pDC->SelectObject (&dispFont);
  781. UINT nFormat  = DT_LEFT|DT_SINGLELINE|DT_VCENTER;
  782. UINT nFormatr = DT_RIGHT|DT_SINGLELINE|DT_VCENTER;
  783. if(!(lpDIS->itemState & ODS_GRAYED)){
  784. pDC->SetTextColor(crText);
  785. pDC->DrawText (leftStr,rectt,nFormat);
  786. if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  787. }
  788. else{
  789. RECT offset = *rectt;
  790. offset.left+=1;
  791. offset.right+=1;
  792. offset.top+=1;
  793. offset.bottom+=1;
  794. if(!XPflag){
  795. COLORREF graycol=GetSysColor(COLOR_GRAYTEXT);
  796. graycol = LightenColor(graycol,0.55);
  797. pDC->SetTextColor(graycol);
  798. }
  799. else pDC->SetTextColor(GetSysColor(COLOR_GRAYTEXT));
  800. pDC->DrawText(leftStr,rectt, nFormat);
  801. if(tablocr!=-1) pDC->DrawText (rightStr,rectt,nFormatr);
  802. }
  803. pDC->SetBkMode( iOldMode );
  804. pDC->SelectObject (pFont); //set it to the old font
  805. }
  807. m_penBack.DeleteObject();
  808. m_fontMenu.DeleteObject();
  809. m_brSelect.DeleteObject();
  810. dispFont.DeleteObject ();
  811. }
  812. m_brBackground.DeleteObject();
  813. m_newbrBackground.DeleteObject();
  814. #ifdef BCMENU_USE_MEMDC
  815. if(pMemDC)delete pMemDC;
  816. #endif
  817. }
  819. BOOL BCMenu::GetBitmapFromImageList(CDC* pDC,CImageList *imglist,int nIndex,CBitmap &bmp)
  820. {
  821. HICON hIcon = imglist->ExtractIcon(nIndex);
  822. CDC dc;
  823. dc.CreateCompatibleDC(pDC);
  824. bmp.CreateCompatibleBitmap(pDC,m_iconX,m_iconY);
  825. CBitmap* pOldBmp = dc.SelectObject(&bmp);
  826. CBrush brush ;
  827. brush.CreateSolidBrush(GetSysColor(COLOR_MENU));
  828. ::DrawIconEx(
  829. dc.GetSafeHdc(),
  830. 0,
  831. 0,
  832. hIcon,
  833. m_iconX,
  834. m_iconY,
  835. 0,
  836. (HBRUSH)brush,
  837. DI_NORMAL
  838. );
  839. dc.SelectObject( pOldBmp );
  840. dc.DeleteDC();
  841. // the icon is not longer needed
  842. DestroyIcon(hIcon);
  843. return(TRUE);
  844. }
  846. /*
  847. ==========================================================================
  848. void BCMenu::MeasureItem(LPMEASUREITEMSTRUCT)
  849. ---------------------------------------------
  851.   Called by the framework when it wants to know what the width and height
  852.   of our item will be.  To accomplish this we provide the width of the
  853.   icon plus the width of the menu text, and then the height of the icon.
  854.   
  855. ==========================================================================
  856. */
  858. void BCMenu::MeasureItem( LPMEASUREITEMSTRUCT lpMIS )
  859. {
  860. UINT state = (((BCMenuData*)(lpMIS->itemData))->nFlags);
  861. if(state & MF_SEPARATOR){
  862. lpMIS->itemWidth = 0;
  863. lpMIS->itemHeight = GetSystemMetrics(SM_CYMENU)>>1;
  864. }
  865. else{
  866. CFont m_fontMenu;
  867. LOGFONT m_lf;
  868. ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  869. NONCLIENTMETRICS nm;
  870. nm.cbSize = sizeof (NONCLIENTMETRICS);
  871. VERIFY(SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
  872. nm.cbSize,&nm,0)); 
  873. m_lf =  nm.lfMenuFont;
  874. m_fontMenu.CreateFontIndirect (&m_lf);
  876. // Obtain the width of the text:
  877. CWnd *pWnd = AfxGetMainWnd();            // Get main window
  878. CDC *pDC = pWnd->GetDC();              // Get device context
  879. CFont* pFont=NULL;    // Select menu font in...
  881. if (IsNewShell())
  882. pFont = pDC->SelectObject (&m_fontMenu);// Select menu font in...
  883.         
  884. //Get pointer to text SK
  885. const wchar_t *lpstrText = ((BCMenuData*)(lpMIS->itemData))->GetWideString();//SK: we use const to prevent misuse
  887.         
  888. SIZE size;
  890. if (Win32s!=g_Shell)
  891. VERIFY(::GetTextExtentPoint32W(pDC->m_hDC,lpstrText,
  892. wcslen(lpstrText),&size)); //SK should also work on 95
  893. #ifndef UNICODE //can't be UNICODE for Win32s
  894. else{//it's Win32suckx
  895. RECT rect;
  896. rect.left=rect.top=0;
  897. size.cy=DrawText(pDC->m_hDC,(LPCTSTR)lpstrText,
  898. wcslen(lpstrText),&rect,
  899. DT_SINGLELINE|DT_LEFT|DT_VCENTER|DT_CALCRECT);
  900. //+3 makes at least three pixels space to the menu border
  901. size.cx=rect.right-rect.left+3;
  902. size.cx += 3*(size.cx/wcslen(lpstrText));
  903. }
  904. #endif    
  906. CSize t = CSize(size);
  907. if(IsNewShell())
  908. pDC->SelectObject (pFont);  // Select old font in
  909. AfxGetMainWnd()->ReleaseDC(pDC);  // Release the DC
  911. // Set width and height:
  913. lpMIS->itemWidth = m_iconX + t.cx + m_iconX + GAP;
  914. int temp = GetSystemMetrics(SM_CYMENU);
  915. lpMIS->itemHeight = temp>m_iconY+4 ? temp : m_iconY+4;
  916. m_fontMenu.DeleteObject();
  917. }
  918. }
  920. void BCMenu::SetIconSize (int width, int height)
  921. {
  922. m_iconX = width;
  923. m_iconY = height;
  924. }
  926. BOOL BCMenu::AppendODMenuA(LPCSTR lpstrText,UINT nFlags,UINT nID,
  927.                            int nIconNormal)
  928. {
  929. USES_CONVERSION;
  930. return AppendODMenuW(A2W(lpstrText),nFlags,nID,nIconNormal);//SK: See MFC Tech Note 059
  931. }
  934. BOOL BCMenu::AppendODMenuW(wchar_t *lpstrText,UINT nFlags,UINT nID,
  935.                            int nIconNormal)
  936. {
  937. // Add the MF_OWNERDRAW flag if not specified:
  938. if(!nID){
  939. if(nFlags&MF_BYPOSITION)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  940. else nFlags=MF_SEPARATOR|MF_OWNERDRAW;
  941. }
  942. else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
  944. if(nFlags & MF_POPUP){
  945. m_AllSubMenus.Add((HMENU)nID);
  946. m_SubMenus.Add((HMENU)nID);
  947. }
  949. BCMenuData *mdata = new BCMenuData;
  950. m_MenuList.Add(mdata);
  951. mdata->SetWideString(lpstrText);    //SK: modified for dynamic allocation
  953. mdata->menuIconNormal = nIconNormal;
  954. mdata->xoffset=-1;
  955. if(nIconNormal>=0){
  956. mdata->xoffset=0;
  957. LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
  958. if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  959. else mdata->bitmap=new(CImageList);
  960. mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  961. if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
  962. mdata->bitmap->DeleteImageList();
  963. delete mdata->bitmap;
  964. mdata->bitmap=NULL;
  965. mdata->menuIconNormal = nIconNormal = -1;
  966. mdata->xoffset = -1;
  967. }
  968. }
  969. mdata->nFlags = nFlags;
  970. mdata->nID = nID;
  971. return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
  972. }
  974. BOOL BCMenu::AppendODMenuA(LPCSTR lpstrText,UINT nFlags,UINT nID,
  975.                            CImageList *il,int xoffset)
  976. {
  977. USES_CONVERSION;
  978. return AppendODMenuW(A2W(lpstrText),nFlags,nID,il,xoffset);
  979. }
  981. BOOL BCMenu::AppendODMenuW(wchar_t *lpstrText,UINT nFlags,UINT nID,
  982.                            CImageList *il,int xoffset)
  983. {
  984. // Add the MF_OWNERDRAW flag if not specified:
  985. if(!nID){
  986. if(nFlags&MF_BYPOSITION)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  987. else nFlags=MF_SEPARATOR|MF_OWNERDRAW;
  988. }
  989. else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
  991. if(nFlags & MF_POPUP){
  992. m_AllSubMenus.Add((HMENU)nID);
  993. m_SubMenus.Add((HMENU)nID);
  994. }
  996. BCMenuData *mdata = new BCMenuData;
  997. m_MenuList.Add(mdata);
  998. mdata->SetWideString(lpstrText);    //SK: modified for dynamic allocation
  1000. if(il){
  1001. mdata->menuIconNormal = 0;
  1002. mdata->xoffset=0;
  1003. if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  1004. else mdata->bitmap=new(CImageList);
  1005. ImageListDuplicate(il,xoffset,mdata->bitmap);
  1006. }
  1007. else{
  1008. mdata->menuIconNormal = -1;
  1009. mdata->xoffset = -1;
  1010. }
  1011. mdata->nFlags = nFlags;
  1012. mdata->nID = nID;
  1013. return(CMenu::AppendMenu(nFlags, nID, (LPCTSTR)mdata));
  1014. }
  1016. BOOL BCMenu::InsertODMenuA(UINT nPosition,LPCSTR lpstrText,UINT nFlags,UINT nID,
  1017.                            int nIconNormal)
  1018. {
  1019. USES_CONVERSION;
  1020. return InsertODMenuW(nPosition,A2W(lpstrText),nFlags,nID,nIconNormal);
  1021. }
  1024. BOOL BCMenu::InsertODMenuW(UINT nPosition,wchar_t *lpstrText,UINT nFlags,UINT nID,
  1025.                            int nIconNormal)
  1026. {
  1027. if(!(nFlags & MF_BYPOSITION)){
  1028. int iPosition =0;
  1029. BCMenu* pMenu = FindMenuOption(nPosition,iPosition);
  1030. if(pMenu){
  1031. return(pMenu->InsertODMenuW(iPosition,lpstrText,nFlags|MF_BYPOSITION,nID,nIconNormal));
  1032. }
  1033. else return(FALSE);
  1034. }
  1036. if(!nID)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  1037. else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
  1039. if(nFlags & MF_POPUP){
  1040. m_AllSubMenus.Add((HMENU)nID);
  1041. m_SubMenus.InsertAt(nPosition,(HMENU)nID);
  1042. }
  1044. //Stephane Clog suggested adding this, believe it or not it's in the help 
  1045. if(nPosition==(UINT)-1)nPosition=GetMenuItemCount();
  1047. BCMenuData *mdata = new BCMenuData;
  1048. m_MenuList.InsertAt(nPosition,mdata);
  1049. mdata->SetWideString(lpstrText);    //SK: modified for dynamic allocation
  1051. mdata->menuIconNormal = nIconNormal;
  1052. mdata->xoffset=-1;
  1053. if(nIconNormal>=0){
  1054. mdata->xoffset=0;
  1055. LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
  1056. if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  1057. else mdata->bitmap=new(CImageList);
  1058. mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  1059. if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
  1060. mdata->bitmap->DeleteImageList();
  1061. delete mdata->bitmap;
  1062. mdata->bitmap=NULL;
  1063. mdata->menuIconNormal = nIconNormal = -1;
  1064. mdata->xoffset = -1;
  1065. }
  1066. }
  1067. mdata->nFlags = nFlags;
  1068. mdata->nID = nID;
  1069. return(CMenu::InsertMenu(nPosition,nFlags,nID,(LPCTSTR)mdata));
  1070. }
  1072. BOOL BCMenu::InsertODMenuA(UINT nPosition,LPCSTR lpstrText,UINT nFlags,UINT nID,
  1073.                            CImageList *il,int xoffset)
  1074. {
  1075. USES_CONVERSION;
  1076. return InsertODMenuW(nPosition,A2W(lpstrText),nFlags,nID,il,xoffset);
  1077. }
  1079. BOOL BCMenu::InsertODMenuW(UINT nPosition,wchar_t *lpstrText,UINT nFlags,UINT nID,
  1080.                            CImageList *il,int xoffset)
  1081. {
  1082. if(!(nFlags & MF_BYPOSITION)){
  1083. int iPosition =0;
  1084. BCMenu* pMenu = FindMenuOption(nPosition,iPosition);
  1085. if(pMenu){
  1086. return(pMenu->InsertODMenuW(iPosition,lpstrText,nFlags|MF_BYPOSITION,nID,il,xoffset));
  1087. }
  1088. else return(FALSE);
  1089. }
  1091. if(!nID)nFlags=MF_SEPARATOR|MF_OWNERDRAW|MF_BYPOSITION;
  1092. else if(!(nFlags & MF_OWNERDRAW))nFlags |= MF_OWNERDRAW;
  1094. if(nFlags & MF_POPUP){
  1095. m_AllSubMenus.Add((HMENU)nID);
  1096. m_SubMenus.InsertAt(nPosition,(HMENU)nID);
  1097. }
  1099. //Stephane Clog suggested adding this, believe it or not it's in the help 
  1100. if(nPosition==(UINT)-1)nPosition=GetMenuItemCount();
  1102. BCMenuData *mdata = new BCMenuData;
  1103. m_MenuList.InsertAt(nPosition,mdata);
  1104. mdata->SetWideString(lpstrText);    //SK: modified for dynamic allocation
  1106. if(il){
  1107. mdata->menuIconNormal = 0;
  1108. mdata->xoffset=0;
  1109. if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  1110. else mdata->bitmap=new(CImageList);
  1111. ImageListDuplicate(il,xoffset,mdata->bitmap);
  1112. }
  1113. else{
  1114. mdata->menuIconNormal = -1;
  1115. mdata->xoffset = -1;
  1116. }
  1117. mdata->nFlags = nFlags;
  1118. mdata->nID = nID;
  1119. return(CMenu::InsertMenu(nPosition,nFlags,nID,(LPCTSTR)mdata));
  1120. }
  1122. BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,int nIconNormal)
  1123. {
  1124. USES_CONVERSION;
  1125. return ModifyODMenuW(A2W(lpstrText),nID,nIconNormal);//SK: see MFC Tech Note 059
  1126. }
  1128. BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,int nIconNormal)
  1129. {
  1130. int nLoc;
  1131. BCMenuData *mdata;
  1132. CArray<BCMenu*,BCMenu*>bcsubs;
  1133. CArray<int,int&>bclocs;
  1135. // Find the old BCMenuData structure:
  1136. BCMenu *psubmenu = FindMenuOption(nID,nLoc);
  1137. do{
  1138. if(psubmenu && nLoc>=0)mdata = psubmenu->m_MenuList[nLoc];
  1139. else{
  1140. // Create a new BCMenuData structure:
  1141. mdata = new BCMenuData;
  1142. m_MenuList.Add(mdata);
  1143. }
  1145. ASSERT(mdata);
  1146. if(lpstrText)
  1147. mdata->SetWideString(lpstrText);  //SK: modified for dynamic allocation
  1148. mdata->menuIconNormal = nIconNormal;
  1149. mdata->xoffset=-1;
  1150. if(nIconNormal>=0){
  1151. mdata->xoffset=0;
  1152. LoadFromToolBar(nID,nIconNormal,mdata->xoffset);
  1153. if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  1154. else mdata->bitmap=new CImageList;
  1155. mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  1156. if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
  1157. mdata->bitmap->DeleteImageList();
  1158. delete mdata->bitmap;
  1159. mdata->bitmap=NULL;
  1160. mdata->menuIconNormal = nIconNormal = -1;
  1161. mdata->xoffset = -1;
  1162. }
  1163. }
  1164. mdata->nFlags &= ~(MF_BYPOSITION);
  1165. mdata->nFlags |= MF_OWNERDRAW;
  1166. mdata->nID = nID;
  1167. bcsubs.Add(psubmenu);
  1168. bclocs.Add(nLoc);
  1169. if(psubmenu && nLoc>=0)psubmenu = FindAnotherMenuOption(nID,nLoc,bcsubs,bclocs);
  1170. else psubmenu=NULL;
  1171. }while(psubmenu);
  1172. return (CMenu::ModifyMenu(nID,mdata->nFlags,nID,(LPCTSTR)mdata));
  1173. }
  1175. BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,CImageList *il,int xoffset)
  1176. {
  1177. USES_CONVERSION;
  1178. return ModifyODMenuW(A2W(lpstrText),nID,il,xoffset);
  1179. }
  1181. BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,CImageList *il,int xoffset)
  1182. {
  1183. int nLoc;
  1184. BCMenuData *mdata;
  1185. CArray<BCMenu*,BCMenu*>bcsubs;
  1186. CArray<int,int&>bclocs;
  1188. // Find the old BCMenuData structure:
  1189. BCMenu *psubmenu = FindMenuOption(nID,nLoc);
  1190. do{
  1191. if(psubmenu && nLoc>=0)mdata = psubmenu->m_MenuList[nLoc];
  1192. else{
  1193. // Create a new BCMenuData structure:
  1194. mdata = new BCMenuData;
  1195. m_MenuList.Add(mdata);
  1196. }
  1198. ASSERT(mdata);
  1199. if(lpstrText)
  1200. mdata->SetWideString(lpstrText);  //SK: modified for dynamic allocation
  1201. if(il){
  1202. mdata->menuIconNormal = 0;
  1203. mdata->xoffset=0;
  1204. if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  1205. else mdata->bitmap=new(CImageList);
  1206. ImageListDuplicate(il,xoffset,mdata->bitmap);
  1207. }
  1208. else{
  1209. mdata->menuIconNormal = -1;
  1210. mdata->xoffset = -1;
  1211. }
  1212. mdata->nFlags &= ~(MF_BYPOSITION);
  1213. mdata->nFlags |= MF_OWNERDRAW;
  1214. mdata->nID = nID;
  1215. bcsubs.Add(psubmenu);
  1216. bclocs.Add(nLoc);
  1217. if(psubmenu && nLoc>=0)psubmenu = FindAnotherMenuOption(nID,nLoc,bcsubs,bclocs);
  1218. else psubmenu=NULL;
  1219. }while(psubmenu);
  1220. return (CMenu::ModifyMenu(nID,mdata->nFlags,nID,(LPCTSTR)mdata));
  1221. }
  1223. BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,CBitmap *bmp)
  1224. {
  1225. USES_CONVERSION;
  1226. return ModifyODMenuW(A2W(lpstrText),nID,bmp);
  1227. }
  1229. BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,CBitmap *bmp)
  1230. {
  1231. if(bmp){
  1232. CImageList temp;
  1233. temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  1234. if(m_bitmapBackgroundFlag)temp.Add(bmp,m_bitmapBackground);
  1235. else temp.Add(bmp,GetSysColor(COLOR_3DFACE));
  1236. return ModifyODMenuW(lpstrText,nID,&temp,0);
  1237. }
  1238. return ModifyODMenuW(lpstrText,nID,NULL,0);
  1239. }
  1241. // courtesy of Warren Stevens
  1242. BOOL BCMenu::ModifyODMenuA(const char * lpstrText,UINT nID,COLORREF fill,COLORREF border,int hatchstyle)
  1243. {
  1244. USES_CONVERSION;
  1245. return ModifyODMenuW(A2W(lpstrText),nID,fill,border,hatchstyle);
  1246. }
  1248. BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,UINT nID,COLORREF fill,COLORREF border,int hatchstyle)
  1249. {
  1250. CWnd *pWnd = AfxGetMainWnd();            // Get main window
  1251. CDC *pDC = pWnd->GetDC();              // Get device context
  1252. CSize bitmap_size(m_iconX,m_iconY);
  1253. CBitmap bmp;
  1254. ColorBitmap(pDC,bmp,bitmap_size,fill,border,hatchstyle);
  1255. return ModifyODMenuW(lpstrText,nID,&bmp);
  1256. }
  1259. BOOL BCMenu::ModifyODMenuA(const char *lpstrText,const char *OptionText,
  1260.                            int nIconNormal)
  1261. {
  1262. USES_CONVERSION;
  1263. return ModifyODMenuW(A2W(lpstrText),A2W(OptionText),nIconNormal);//SK: see MFC  Tech Note 059
  1264. }
  1266. BOOL BCMenu::ModifyODMenuW(wchar_t *lpstrText,wchar_t *OptionText,
  1267.                            int nIconNormal)
  1268. {
  1269. BCMenuData *mdata;
  1271. // Find the old BCMenuData structure:
  1272. CString junk=OptionText;
  1273. mdata=FindMenuOption(OptionText);
  1274. if(mdata){
  1275. if(lpstrText)
  1276. mdata->SetWideString(lpstrText);//SK: modified for dynamic allocation
  1277. mdata->menuIconNormal = nIconNormal;
  1278. mdata->xoffset=-1;
  1279. if(nIconNormal>=0){
  1280. mdata->xoffset=0;
  1281. if(mdata->bitmap)mdata->bitmap->DeleteImageList();
  1282. else mdata->bitmap=new(CImageList);
  1283. mdata->bitmap->Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  1284. if(!AddBitmapToImageList(mdata->bitmap,nIconNormal)){
  1285. mdata->bitmap->DeleteImageList();
  1286. delete mdata->bitmap;
  1287. mdata->bitmap=NULL;
  1288. mdata->menuIconNormal = nIconNormal = -1;
  1289. mdata->xoffset = -1;
  1290. }
  1291. }
  1292. return(TRUE);
  1293. }
  1294. return(FALSE);
  1295. }
  1297. BCMenuData *BCMenu::NewODMenu(UINT pos,UINT nFlags,UINT nID,CString string)
  1298. {
  1299. BCMenuData *mdata;
  1301. mdata = new BCMenuData;
  1302. mdata->menuIconNormal = -1;
  1303. mdata->xoffset=-1;
  1304. #ifdef UNICODE
  1305. mdata->SetWideString((LPCTSTR)string);//SK: modified for dynamic allocation
  1306. #else
  1307. mdata->SetAnsiString(string);
  1308. #endif
  1309. mdata->nFlags = nFlags;
  1310. mdata->nID = nID;
  1312. // if(nFlags & MF_POPUP)m_AllSubMenus.Add((HMENU)nID);
  1314. if (nFlags&MF_OWNERDRAW){
  1315. ASSERT(!(nFlags&MF_STRING));
  1316. ModifyMenu(pos,nFlags,nID,(LPCTSTR)mdata);
  1317. }
  1318. else if (nFlags&MF_STRING){
  1319. ASSERT(!(nFlags&MF_OWNERDRAW));
  1320. ModifyMenu(pos,nFlags,nID,mdata->GetString());
  1321. }
  1322. else{
  1323. ASSERT(nFlags&MF_SEPARATOR);
  1324. ModifyMenu(pos,nFlags,nID);
  1325. }
  1327. return(mdata);
  1328. };
  1330. BOOL BCMenu::LoadToolbars(const UINT *arID,int n)
  1331. {
  1332. ASSERT(arID);
  1333. BOOL returnflag=TRUE;
  1334. for(int i=0;i<n;++i){
  1335. if(!LoadToolbar(arID[i]))returnflag=FALSE;
  1336. }
  1337. return(returnflag);
  1338. }
  1340. BOOL BCMenu::LoadToolbar(UINT nToolBar)
  1341. {
  1342. UINT nID,nStyle;
  1343. BOOL returnflag=FALSE;
  1344. CToolBar bar;
  1345. int xoffset=-1,xset;
  1347. bar.Create(AfxGetMainWnd());
  1348. if(bar.LoadToolBar(nToolBar)){
  1349. CImageList imglist;
  1350. imglist.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  1351. if(AddBitmapToImageList(&imglist,nToolBar)){
  1352. returnflag=TRUE;
  1353. for(int i=0;i<bar.GetCount();++i){
  1354. nID = bar.GetItemID(i); 
  1355. if(nID && GetMenuState(nID, MF_BYCOMMAND)
  1356. !=0xFFFFFFFF){
  1357. xoffset=bar.CommandToIndex(nID);
  1358. if(xoffset>=0){
  1359. bar.GetButtonInfo(xoffset,nID,nStyle,xset);
  1360. if(xset>0)xoffset=xset;
  1361. }
  1362. ModifyODMenu(NULL,nID,&imglist,xoffset);
  1363. }
  1364. }
  1365. }
  1366. }
  1367. return(returnflag);
  1368. }
  1370. BOOL BCMenu::LoadFromToolBar(UINT nID,UINT nToolBar,int& xoffset)
  1371. {
  1372. int xset,offset;
  1373. UINT nStyle;
  1374. BOOL returnflag=FALSE;
  1375. CToolBar bar;
  1377. bar.Create(AfxGetMainWnd());
  1378. if(bar.LoadToolBar(nToolBar)){
  1379. offset=bar.CommandToIndex(nID);
  1380. if(offset>=0){
  1381. bar.GetButtonInfo(offset,nID,nStyle,xset);
  1382. if(xset>0)xoffset=xset;
  1383. returnflag=TRUE;
  1384. }
  1385. }
  1386. return(returnflag);
  1387. }
  1389. // O.S.
  1390. BCMenuData *BCMenu::FindMenuItem(UINT nID)
  1391. {
  1392. BCMenuData *pData = NULL;
  1393. int i;
  1395. for(i = 0; i <= m_MenuList.GetUpperBound(); i++){
  1396. if (m_MenuList[i]->nID == nID){
  1397. pData = m_MenuList[i];
  1398. break;
  1399. }
  1400. }
  1401. if (!pData){
  1402. int loc;
  1403. BCMenu *pMenu = FindMenuOption(nID, loc);
  1404. ASSERT(pMenu != this);
  1405. if (loc >= 0){
  1406. return pMenu->FindMenuItem(nID);
  1407. }
  1408. }
  1409. return pData;
  1410. }
  1413. BCMenu *BCMenu::FindAnotherMenuOption(int nId,int& nLoc,CArray<BCMenu*,BCMenu*>&bcsubs,
  1414.   CArray<int,int&>&bclocs)
  1415. {
  1416. int i,numsubs,j;
  1417. BCMenu *psubmenu,*pgoodmenu;
  1418. BOOL foundflag;
  1420. for(i=0;i<(int)(GetMenuItemCount());++i){
  1421. #ifdef _CPPRTTI 
  1422. psubmenu=dynamic_cast<BCMenu *>(GetSubMenu(i));
  1423. #else
  1424. psubmenu=(BCMenu *)GetSubMenu(i);
  1425. #endif
  1426. if(psubmenu){
  1427. pgoodmenu=psubmenu->FindAnotherMenuOption(nId,nLoc,bcsubs,bclocs);
  1428. if(pgoodmenu)return(pgoodmenu);
  1429. }
  1430. else if(nId==(int)GetMenuItemID(i)){
  1431. numsubs=bcsubs.GetSize();
  1432. foundflag=TRUE;
  1433. for(j=0;j<numsubs;++j){
  1434. if(bcsubs[j]==this&&bclocs[j]==i){
  1435. foundflag=FALSE;
  1436. break;
  1437. }
  1438. }
  1439. if(foundflag){
  1440. nLoc=i;
  1441. return(this);
  1442. }
  1443. }
  1444. }
  1445. nLoc = -1;
  1446. return(NULL);
  1447. }
  1449. BCMenu *BCMenu::FindMenuOption(int nId,int& nLoc)
  1450. {
  1451. int i;
  1452. BCMenu *psubmenu,*pgoodmenu;
  1454. for(i=0;i<(int)(GetMenuItemCount());++i){
  1455. #ifdef _CPPRTTI 
  1456. psubmenu=dynamic_cast<BCMenu *>(GetSubMenu(i));
  1457. #else
  1458. psubmenu=(BCMenu *)GetSubMenu(i);
  1459. #endif
  1460. if(psubmenu){
  1461. pgoodmenu=psubmenu->FindMenuOption(nId,nLoc);
  1462. if(pgoodmenu)return(pgoodmenu);
  1463. }
  1464. else if(nId==(int)GetMenuItemID(i)){
  1465. nLoc=i;
  1466. return(this);
  1467. }
  1468. }
  1469. nLoc = -1;
  1470. return(NULL);
  1471. }
  1473. BCMenuData *BCMenu::FindMenuOption(wchar_t *lpstrText)
  1474. {
  1475. int i,j;
  1476. BCMenu *psubmenu;
  1477. BCMenuData *pmenulist;
  1479. for(i=0;i<(int)(GetMenuItemCount());++i){
  1480. #ifdef _CPPRTTI 
  1481. psubmenu=dynamic_cast<BCMenu *>(GetSubMenu(i));
  1482. #else
  1483. psubmenu=(BCMenu *)GetSubMenu(i);
  1484. #endif
  1485. if(psubmenu){
  1486. pmenulist=psubmenu->FindMenuOption(lpstrText);
  1487. if(pmenulist)return(pmenulist);
  1488. }
  1489. else{
  1490. const wchar_t *szWide;//SK: we use const to prevent misuse of this Ptr
  1491. for(j=0;j<=m_MenuList.GetUpperBound();++j){     
  1492. szWide = m_MenuList[j]->GetWideString ();
  1493. if(szWide && !wcscmp(lpstrText,szWide))//SK: modified for dynamic allocation
  1494. return(m_MenuList[j]);
  1495. }
  1496. }
  1497. }
  1498. return(NULL);
  1499. }
  1502. BOOL BCMenu::LoadMenu(int nResource)
  1503. {
  1504. return(BCMenu::LoadMenu(MAKEINTRESOURCE(nResource)));
  1505. };
  1507. BOOL BCMenu::LoadMenu(LPCTSTR lpszResourceName)
  1508. {
  1509. TRACE(_T(
  1510. "IMPORTANT:Use BCMenu::DestroyMenu to destroy Loaded Menu'sn"));
  1511. ASSERT_VALID(this);
  1512. ASSERT(lpszResourceName != NULL);
  1514. // Find the Menu Resource:
  1515. HINSTANCE m_hInst = AfxFindResourceHandle(lpszResourceName,RT_MENU);
  1516. HRSRC hRsrc = ::FindResource(m_hInst,lpszResourceName,RT_MENU);
  1517. if(hRsrc == NULL)return FALSE;
  1519. // Load the Menu Resource:
  1521. HGLOBAL hGlobal = LoadResource(m_hInst, hRsrc);
  1522. if(hGlobal == NULL)return FALSE;
  1524. // Attempt to create us as a menu...
  1526. if(!CMenu::CreateMenu())return FALSE;
  1528. // Get Item template Header, and calculate offset of MENUITEMTEMPLATES
  1530. MENUITEMTEMPLATEHEADER *pTpHdr=
  1531. (MENUITEMTEMPLATEHEADER*)LockResource(hGlobal);
  1532. BYTE* pTp=(BYTE*)pTpHdr + 
  1533. (sizeof(MENUITEMTEMPLATEHEADER) + pTpHdr->offset);
  1536. // Variables needed during processing of Menu Item Templates:
  1538. int j=0;
  1539. WORD    dwFlags = 0;              // Flags of the Menu Item
  1540. WORD    dwID  = 0;              // ID of the Menu Item
  1541. UINT    uFlags;                  // Actual Flags.
  1542. wchar_t *szCaption=NULL;
  1543. int      nLen   = 0;                // Length of caption
  1544. CTypedPtrArray<CPtrArray, BCMenu*>  m_Stack;    // Popup menu stack
  1545. CArray<BOOL,BOOL>  m_StackEnd;    // Popup menu stack
  1546. m_Stack.Add(this);                  // Add it to this...
  1547. m_StackEnd.Add(FALSE);
  1549. do{
  1550. // Obtain Flags and (if necessary), the ID...
  1551. memcpy(&dwFlags, pTp, sizeof(WORD));pTp+=sizeof(WORD);// Obtain Flags
  1552. if(!(dwFlags & MF_POPUP)){
  1553. memcpy(&dwID, pTp, sizeof(WORD)); // Obtain ID
  1554. pTp+=sizeof(WORD);
  1555. }
  1556. else dwID = 0;
  1558. uFlags = (UINT)dwFlags; // Remove MF_END from the flags that will
  1559. if(uFlags & MF_END) // be passed to the Append(OD)Menu functions.
  1560. uFlags -= MF_END;
  1562. // Obtain Caption (and length)
  1564. nLen = 0;
  1565. szCaption=new wchar_t[wcslen((wchar_t *)pTp)+1];
  1566. wcscpy(szCaption,(wchar_t *)pTp);
  1567. pTp=&pTp[(wcslen((wchar_t *)pTp)+1)*sizeof(wchar_t)];//modified SK
  1569. // Handle popup menus first....
  1571. //WideCharToMultiByte
  1572. if(dwFlags & MF_POPUP){
  1573. if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
  1574. BCMenu* pSubMenu = new BCMenu;
  1575. pSubMenu->m_unselectcheck=m_unselectcheck;
  1576. pSubMenu->m_selectcheck=m_selectcheck;
  1577. pSubMenu->checkmaps=checkmaps;
  1578. pSubMenu->checkmapsshare=TRUE;
  1579. pSubMenu->CreatePopupMenu();
  1581. // Append it to the top of the stack:
  1583. m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption,uFlags,
  1584. (UINT)pSubMenu->m_hMenu, -1);
  1585. m_Stack.Add(pSubMenu);
  1586. m_StackEnd.Add(FALSE);
  1587. }
  1588. else {
  1589. m_Stack[m_Stack.GetUpperBound()]->AppendODMenuW(szCaption, uFlags,
  1590. dwID, -1);
  1591. if(dwFlags & MF_END)m_StackEnd.SetAt(m_Stack.GetUpperBound(),TRUE);
  1592. j = m_Stack.GetUpperBound();
  1593. while(j>=0 && m_StackEnd.GetAt(j)){
  1594. m_Stack[m_Stack.GetUpperBound()]->InsertSpaces();
  1595. m_Stack.RemoveAt(j);
  1596. m_StackEnd.RemoveAt(j);
  1597. --j;
  1598. }
  1599. }
  1601. delete[] szCaption;
  1602. }while(m_Stack.GetUpperBound() != -1);
  1604. for(int i=0;i<(int)GetMenuItemCount();++i){
  1605. CString str=m_MenuList[i]->GetString();
  1607. if(GetSubMenu(i)){
  1608. m_MenuList[i]->nFlags=MF_POPUP|MF_BYPOSITION;
  1609. ModifyMenu(i,MF_POPUP|MF_BYPOSITION,
  1610. (UINT)GetSubMenu(i)->m_hMenu,str);
  1611. }
  1612. else{
  1613. m_MenuList[i]->nFlags=MF_STRING|MF_BYPOSITION;
  1614. ModifyMenu(i,MF_STRING|MF_BYPOSITION,m_MenuList[i]->nID,str);
  1615. }
  1616. }
  1618. return(TRUE);
  1619. }
  1621. void BCMenu::InsertSpaces(void)
  1622. {
  1623. int i,j,numitems,maxlength;
  1624. CString string,newstring;
  1625. CSize t;
  1626. CFont m_fontMenu;
  1627. LOGFONT m_lf;
  1629. ZeroMemory ((PVOID) &m_lf,sizeof (LOGFONT));
  1630. NONCLIENTMETRICS nm;
  1631. nm.cbSize = sizeof (NONCLIENTMETRICS);
  1632. VERIFY (SystemParametersInfo (SPI_GETNONCLIENTMETRICS,nm.cbSize,&nm,0)); 
  1633. m_lf =  nm.lfMenuFont;
  1634. m_fontMenu.CreateFontIndirect (&m_lf);
  1636. CWnd *pWnd = AfxGetMainWnd();  
  1637. CDC *pDC = pWnd->GetDC();
  1638. CFont* pFont = pDC->SelectObject (&m_fontMenu);
  1640. numitems=GetMenuItemCount();
  1641. maxlength = -1;
  1642. for(i=0;i<numitems;++i){
  1643. string=m_MenuList[i]->GetString();
  1644. j=string.Find((char)9);
  1645. newstring.Empty();
  1646. if(j!=-1)newstring=string.Left(j);
  1647. else newstring=string;
  1648. newstring+=_T(" ");//SK: modified for Unicode correctness. 
  1649. LPCTSTR lpstrText = (LPCTSTR)newstring;
  1650. t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
  1651. if(t.cx>maxlength)maxlength = t.cx;
  1652. }
  1653. for(i=0;i<numitems;++i){
  1654. string=m_MenuList[i]->GetString();
  1655. j=string.Find((char)9);
  1656. if(j!=-1){
  1657. newstring.Empty();
  1658. newstring=string.Left(j);
  1659. LPCTSTR lpstrText = (LPCTSTR)(newstring);
  1660. t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
  1661. while(t.cx<maxlength){
  1662. newstring+=_T(' ');//SK: modified for Unicode correctness
  1663. LPCTSTR lpstrText = (LPCTSTR)(newstring);
  1664. t=pDC->GetTextExtent(lpstrText,_tcslen(lpstrText));
  1665. }
  1666. newstring+=string.Mid(j);
  1667. #ifdef UNICODE      
  1668. m_MenuList[i]->SetWideString(newstring);//SK: modified for dynamic allocation
  1669. #else
  1670. m_MenuList[i]->SetAnsiString(newstring);
  1671. #endif
  1672. }
  1673. }
  1674. pDC->SelectObject (pFont);              // Select old font in
  1675. AfxGetMainWnd()->ReleaseDC(pDC);       // Release the DC
  1676. m_fontMenu.DeleteObject();
  1677. }
  1679. void BCMenu::LoadCheckmarkBitmap(int unselect, int select)
  1680. {
  1681. if(unselect>0 && select>0){
  1682. m_selectcheck=select;
  1683. m_unselectcheck=unselect;
  1684. if(checkmaps)checkmaps->DeleteImageList();
  1685. else checkmaps=new(CImageList);
  1686. checkmaps->Create(m_iconX,m_iconY,ILC_MASK,2,1);
  1687. BOOL flag1=AddBitmapToImageList(checkmaps,unselect);
  1688. BOOL flag2=AddBitmapToImageList(checkmaps,select);
  1689. if(!flag1||!flag2){
  1690. checkmaps->DeleteImageList();
  1691. delete checkmaps;
  1692. checkmaps=NULL;
  1693. }
  1694. }
  1695. }
  1697. //--------------------------------------------------------------------------
  1698. //[18.06.99 rj]
  1699. BOOL BCMenu::GetMenuText(UINT id, CString& string, UINT nFlags/*= MF_BYPOSITION*/)
  1700. {
  1701. BOOL returnflag=FALSE;
  1703. if(MF_BYPOSITION&nFlags){
  1704. UINT numMenuItems = m_MenuList.GetUpperBound();
  1705. if(id<=numMenuItems){
  1706. string=m_MenuList[id]->GetString();
  1707. returnflag=TRUE;
  1708. }
  1709. }
  1710. else{
  1711. int uiLoc;
  1712. BCMenu* pMenu = FindMenuOption(id,uiLoc);
  1713. if(NULL!=pMenu) returnflag = pMenu->GetMenuText(uiLoc,string);
  1714. }
  1715. return(returnflag);
  1716. }
  1719. void BCMenu::DrawRadioDot(CDC *pDC,int x,int y,COLORREF color)
  1720. {
  1721. CRect rcDot(x,y,x+6,y+6);
  1722. CBrush brush;
  1723. CPen pen;
  1724. brush.CreateSolidBrush(color);
  1725. pen.CreatePen(PS_SOLID,0,color);
  1726. CBrush *pOldBrush=pDC->SelectObject(&brush);
  1727. CPen *pOldPen=pDC->SelectObject(&pen);
  1728. pDC->Ellipse(&rcDot);
  1729. pDC->SelectObject(pOldBrush);
  1730. pDC->SelectObject(pOldPen);
  1731. pen.DeleteObject();
  1732. brush.DeleteObject();
  1733. }
  1735. void BCMenu::DrawCheckMark(CDC* pDC,int x,int y,COLORREF color)
  1736. {
  1737. CPen m_penBack;
  1738. m_penBack.CreatePen (PS_SOLID,0,color);
  1739. CPen *pOldPen = pDC->SelectObject (&m_penBack);
  1740. pDC->MoveTo(x,y+2);
  1741. pDC->LineTo(x,y+5);
  1743. pDC->MoveTo(x+1,y+3);
  1744. pDC->LineTo(x+1,y+6);
  1746. pDC->MoveTo(x+2,y+4);
  1747. pDC->LineTo(x+2,y+7);
  1749. pDC->MoveTo(x+3,y+3);
  1750. pDC->LineTo(x+3,y+6);
  1752. pDC->MoveTo(x+4,y+2);
  1753. pDC->LineTo(x+4,y+5);
  1755. pDC->MoveTo(x+5,y+1);
  1756. pDC->LineTo(x+5,y+4);
  1758. pDC->MoveTo(x+6,y);
  1759. pDC->LineTo(x+6,y+3);
  1761. pDC->SelectObject (pOldPen);
  1762. m_penBack.DeleteObject();
  1763. }
  1765. BCMenuData *BCMenu::FindMenuList(UINT nID)
  1766. {
  1767. for(int i=0;i<=m_MenuList.GetUpperBound();++i){
  1768. if(m_MenuList[i]->nID==nID && !m_MenuList[i]->syncflag){
  1769. m_MenuList[i]->syncflag=1;
  1770. return(m_MenuList[i]);
  1771. }
  1772. }
  1773. return(NULL);
  1774. }
  1776. void BCMenu::InitializeMenuList(int value)
  1777. {
  1778. for(int i=0;i<=m_MenuList.GetUpperBound();++i)
  1779. m_MenuList[i]->syncflag=value;
  1780. }
  1782. void BCMenu::DeleteMenuList(void)
  1783. {
  1784. for(int i=0;i<=m_MenuList.GetUpperBound();++i){
  1785. if(!m_MenuList[i]->syncflag){
  1786. delete m_MenuList[i];
  1787. }
  1788. }
  1789. }
  1791. void BCMenu::SynchronizeMenu(void)
  1792. {
  1793. CTypedPtrArray<CPtrArray, BCMenuData*> temp;
  1794. BCMenuData *mdata;
  1795. CString string;
  1796. UINT submenu,nID=0,state,j;
  1798. InitializeMenuList(0);
  1799. for(j=0;j<GetMenuItemCount();++j){
  1800. mdata=NULL;
  1801. state=GetMenuState(j,MF_BYPOSITION);
  1802. if(state&MF_POPUP){
  1803. submenu=(UINT)GetSubMenu(j)->m_hMenu;
  1804. mdata=FindMenuList(submenu);
  1805. GetMenuString(j,string,MF_BYPOSITION);
  1806. if(!mdata)mdata=NewODMenu(j,
  1807. (state&0xFF)|MF_BYPOSITION|MF_POPUP|MF_OWNERDRAW,submenu,string);
  1808. else if(string.GetLength()>0)
  1809. #ifdef UNICODE
  1810. mdata->SetWideString(string);  //SK: modified for dynamic allocation
  1811. #else
  1812. mdata->SetAnsiString(string);
  1813. #endif
  1814. }
  1815. else if(state&MF_SEPARATOR){
  1816. mdata=FindMenuList(0);
  1817. if(!mdata)mdata=NewODMenu(j,
  1818. state|MF_BYPOSITION|MF_SEPARATOR|MF_OWNERDRAW,0,_T(""));//SK: modified for Unicode correctness
  1819. else ModifyMenu(j,mdata->nFlags,nID,(LPCTSTR)mdata);
  1820. }
  1821. else{
  1822. nID=GetMenuItemID(j);
  1823. mdata=FindMenuList(nID);
  1824. GetMenuString(j,string,MF_BYPOSITION);
  1825. if(!mdata)mdata=NewODMenu(j,state|MF_BYPOSITION|MF_OWNERDRAW,
  1826. nID,string);
  1827. else{
  1828. mdata->nFlags=state|MF_BYPOSITION|MF_OWNERDRAW;
  1829. if(string.GetLength()>0)
  1830. #ifdef UNICODE
  1831. mdata->SetWideString(string);//SK: modified for dynamic allocation
  1832. #else
  1833. mdata->SetAnsiString(string);
  1834. #endif
  1836. ModifyMenu(j,mdata->nFlags,nID,(LPCTSTR)mdata);
  1837. }
  1838. }
  1839. if(mdata)temp.Add(mdata);
  1840. }
  1841. DeleteMenuList();
  1842. m_MenuList.RemoveAll();
  1843. m_MenuList.Append(temp);
  1844. temp.RemoveAll(); 
  1845. }
  1847. void BCMenu::UpdateMenu(CMenu *pmenu)
  1848. {
  1849. #ifdef _CPPRTTI 
  1850. BCMenu *psubmenu = dynamic_cast<BCMenu *>(pmenu);
  1851. #else
  1852. BCMenu *psubmenu = (BCMenu *)pmenu;
  1853. #endif
  1854. if(psubmenu)psubmenu->SynchronizeMenu();
  1855. }
  1857. LRESULT BCMenu::FindKeyboardShortcut(UINT nChar, UINT nFlags,
  1858.                                      CMenu *pMenu)
  1859. {
  1860. #ifdef _CPPRTTI 
  1861. BCMenu *pBCMenu = dynamic_cast<BCMenu *>(pMenu);
  1862. #else
  1863. BCMenu *pBCMenu = (BCMenu *)pMenu;
  1864. #endif
  1865. if(pBCMenu && nFlags&MF_POPUP){
  1866. CString key(_T('&'),2);//SK: modified for Unicode correctness
  1867. key.SetAt(1,(TCHAR)nChar);
  1868. key.MakeLower();
  1869. CString menutext;
  1870. int menusize = (int)pBCMenu->GetMenuItemCount();
  1871. if(menusize!=(pBCMenu->m_MenuList.GetUpperBound()+1))
  1872. pBCMenu->SynchronizeMenu();
  1873. for(int i=0;i<menusize;++i){
  1874. if(pBCMenu->GetMenuText(i,menutext)){
  1875. menutext.MakeLower();
  1876. if(menutext.Find(key)>=0)return(MAKELRESULT(i,2));
  1877. }
  1878. }
  1879. }
  1880. return(0);
  1881. }
  1883. void BCMenu::DitherBlt (HDC hdcDest, int nXDest, int nYDest, int nWidth, 
  1884.                         int nHeight, HBITMAP hbm, int nXSrc, int nYSrc,
  1885. COLORREF bgcolor)
  1886. {
  1887. ASSERT(hdcDest && hbm);
  1888. ASSERT(nWidth > 0 && nHeight > 0);
  1890. // Create a generic DC for all BitBlts
  1891. HDC hDC = CreateCompatibleDC(hdcDest);
  1892. ASSERT(hDC);
  1894. if (hDC)
  1895. {
  1896. // Create a DC for the monochrome DIB section
  1897. HDC bwDC = CreateCompatibleDC(hDC);
  1898. ASSERT(bwDC);
  1900. if (bwDC)
  1901. {
  1902. // Create the monochrome DIB section with a black and white palette
  1903. struct {
  1904. BITMAPINFOHEADER bmiHeader; 
  1905. RGBQUAD      bmiColors[2]; 
  1906. } RGBBWBITMAPINFO = {
  1908. {    // a BITMAPINFOHEADER
  1909. sizeof(BITMAPINFOHEADER),  // biSize 
  1910. nWidth,         // biWidth; 
  1911. nHeight,        // biHeight; 
  1912. 1,            // biPlanes; 
  1913. 1,            // biBitCount 
  1914. BI_RGB,         // biCompression; 
  1915. 0,            // biSizeImage; 
  1916. 0,            // biXPelsPerMeter; 
  1917. 0,            // biYPelsPerMeter; 
  1918. 0,            // biClrUsed; 
  1919. 0            // biClrImportant; 
  1920. },    
  1921. {
  1922. { 0x00, 0x00, 0x00, 0x00 }, { 0xFF, 0xFF, 0xFF, 0x00 }
  1923. } 
  1924. };
  1925. VOID *pbitsBW;
  1926. HBITMAP hbmBW = CreateDIBSection(bwDC,
  1927. (LPBITMAPINFO)&RGBBWBITMAPINFO, DIB_RGB_COLORS, &pbitsBW, NULL, 0);
  1928. ASSERT(hbmBW);
  1930. if (hbmBW)
  1931. {
  1932. // Attach the monochrome DIB section and the bitmap to the DCs
  1933. HBITMAP olddib = (HBITMAP)SelectObject(bwDC, hbmBW);
  1934. HBITMAP hdcolddib = (HBITMAP)SelectObject(hDC, hbm);
  1936. // BitBlt the bitmap into the monochrome DIB section
  1937. BitBlt(bwDC, 0, 0, nWidth, nHeight, hDC, nXSrc, nYSrc, SRCCOPY);
  1939. // Paint the destination rectangle in gray
  1940. FillRect(hdcDest, CRect(nXDest, nYDest, nXDest + nWidth, nYDest +
  1941. nHeight), GetSysColorBrush(bgcolor));
  1942. //SK: looks better on the old shell
  1943. // BitBlt the black bits in the monochrome bitmap into COLOR_3DHILIGHT
  1944. // bits in the destination DC
  1945. // The magic ROP comes from the Charles Petzold's book
  1946. HBRUSH hb = CreateSolidBrush(GetSysColor(COLOR_3DHILIGHT));
  1947. HBRUSH oldBrush = (HBRUSH)SelectObject(hdcDest, hb);
  1948. BitBlt(hdcDest,nXDest+1,nYDest+1,nWidth,nHeight,bwDC,0,0,0xB8074A);
  1950. // BitBlt the black bits in the monochrome bitmap into COLOR_3DSHADOW
  1951. // bits in the destination DC
  1952. hb = CreateSolidBrush(GetSysColor(COLOR_3DSHADOW));
  1953. DeleteObject(SelectObject(hdcDest, hb));
  1954. BitBlt(hdcDest, nXDest, nYDest, nWidth, nHeight,bwDC,0,0,0xB8074A);
  1955. DeleteObject(SelectObject(hdcDest, oldBrush));
  1956. VERIFY(DeleteObject(SelectObject(bwDC, olddib)));
  1957. SelectObject(hDC, hdcolddib);
  1958. }
  1960. VERIFY(DeleteDC(bwDC));
  1961. }
  1963. VERIFY(DeleteDC(hDC));
  1964. }
  1965. }
  1967. BOOL BCMenu::AddBitmapToImageList(CImageList *bmplist,UINT nResourceID)
  1968. {
  1969. // O.S.
  1970. if (m_bDynIcons){
  1971. bmplist->Add((HICON)nResourceID);
  1972. return TRUE;
  1973. }
  1975. BOOL bReturn=FALSE;
  1977. HBITMAP hbmp=LoadSysColorBitmap(nResourceID);
  1978. if(hbmp){
  1979. CBitmap bmp;
  1980. bmp.Attach(hbmp);
  1981. if(m_bitmapBackgroundFlag){
  1982. if(bmplist->Add(&bmp,m_bitmapBackground)>=0)bReturn=TRUE;
  1983. }
  1984. else{
  1985. if(bmplist->Add(&bmp,GetSysColor(COLOR_3DFACE))>=0)bReturn=TRUE;
  1986. }
  1987. bmp.Detach();
  1988. DeleteObject(hbmp);
  1989. }
  1990. else{
  1991. CBitmap mybmp;
  1992. if(mybmp.LoadBitmap(nResourceID)){
  1993. if(m_bitmapBackgroundFlag){
  1994. if(bmplist->Add(&mybmp,m_bitmapBackground)>=0)bReturn=TRUE;
  1995. }
  1996. else{
  1997. if(bmplist->Add(&mybmp,GetSysColor(COLOR_3DFACE))>=0)bReturn=TRUE;
  1998. }
  1999. }
  2000. }
  2001. return(bReturn);
  2002. }
  2004. void BCMenu::SetBitmapBackground(COLORREF color)
  2005. {
  2006. m_bitmapBackground=color;
  2007. m_bitmapBackgroundFlag=TRUE;
  2008. }
  2010. void BCMenu::UnSetBitmapBackground(void)
  2011. {
  2012. m_bitmapBackgroundFlag=FALSE;
  2013. }
  2015. // Given a toolbar, append all the options from it to this menu
  2016. // Passed a ptr to the toolbar object and the toolbar ID
  2017. // Author : Robert Edward Caldecott
  2018. void BCMenu::AddFromToolBar(CToolBar* pToolBar, int nResourceID)
  2019. {
  2020. for (int i = 0; i < pToolBar->GetCount(); i++) {
  2021. UINT nID = pToolBar->GetItemID(i);
  2022. // See if this toolbar option
  2023. // appears as a command on this
  2024. // menu or is a separator
  2025. if (nID == 0 || GetMenuState(nID, MF_BYCOMMAND) == 0xFFFFFFFF)
  2026. continue; // Item doesn't exist
  2027. UINT nStyle;
  2028. int nImage;
  2029. // Get the toolbar button info
  2030. pToolBar->GetButtonInfo(i, nID, nStyle, nImage);
  2031. // OK, we have the command ID of the toolbar
  2032. // option, and the tollbar bitmap offset
  2033. int nLoc;
  2034. BCMenuData* pData;
  2035. BCMenu *pSubMenu = FindMenuOption(nID, nLoc);
  2036. if (pSubMenu && nLoc >= 0)pData = pSubMenu->m_MenuList[nLoc];
  2037. else {
  2038. // Create a new BCMenuData structure
  2039. pData = new BCMenuData;
  2040. m_MenuList.Add(pData);
  2041. }
  2042. // Set some default structure members
  2043. pData->menuIconNormal = nResourceID;
  2044. pData->nID = nID;
  2045. pData->nFlags =  MF_BYCOMMAND | MF_OWNERDRAW;
  2046. pData->xoffset = nImage;
  2047. if (pData->bitmap)pData->bitmap->DeleteImageList();
  2048. else pData->bitmap = new CImageList;
  2049. pData->bitmap->Create(m_iconX, m_iconY,ILC_COLORDDB|ILC_MASK, 1, 1);
  2051. if(!AddBitmapToImageList(pData->bitmap, nResourceID)){
  2052. pData->bitmap->DeleteImageList();
  2053. delete pData->bitmap;
  2054. pData->bitmap=NULL;
  2055. pData->menuIconNormal = -1;
  2056. pData->xoffset = -1;
  2057. }
  2059. // Modify our menu
  2060. ModifyMenu(nID,pData->nFlags,nID,(LPCTSTR)pData);
  2061. }
  2062. }
  2064. BOOL BCMenu::Draw3DCheckmark(CDC *dc, const CRect& rc,
  2065.                              BOOL bSelected, HBITMAP hbmCheck)
  2066. {
  2067. CRect rcDest = rc;
  2068. CBrush brush;
  2069. COLORREF col=GetSysColor((bSelected||!IsNewShell())?COLOR_MENU:COLOR_3DLIGHT);//SK: Looks better on the old shell
  2070. brush.CreateSolidBrush(col);
  2071. dc->FillRect(rcDest,&brush);
  2072. brush.DeleteObject();
  2073. if (IsNewShell()) //SK: looks better on the old shell
  2074. dc->DrawEdge(&rcDest, BDR_SUNKENOUTER, BF_RECT);
  2075. if (!hbmCheck)DrawCheckMark(dc,rc.left+4,rc.top+4,GetSysColor(COLOR_MENUTEXT));
  2076. else DrawRadioDot(dc,rc.left+5,rc.top+4,GetSysColor(COLOR_MENUTEXT));
  2077. return TRUE;
  2078. }
  2080. BOOL BCMenu::DrawXPCheckmark(CDC *dc, const CRect& rc, HBITMAP hbmCheck,COLORREF &colorout)
  2081. {
  2082. CBrush brushin;
  2083. brushin.CreateSolidBrush(LightenColor(colorout,0.85));
  2084. dc->FillRect(rc,&brushin);
  2085. brushin.DeleteObject();
  2086. dc->Draw3dRect (rc,colorout,colorout);
  2087. if (!hbmCheck)DrawCheckMark(dc,rc.left+5,rc.top+4,GetSysColor(COLOR_MENUTEXT));
  2088. else DrawRadioDot(dc,rc.left+5,rc.top+4,GetSysColor(COLOR_MENUTEXT));
  2089. return TRUE;
  2090. }
  2092. void BCMenu::DitherBlt2(CDC *drawdc, int nXDest, int nYDest, int nWidth, 
  2093.                         int nHeight, CBitmap &bmp, int nXSrc, int nYSrc,
  2094. COLORREF bgcolor)
  2095. {
  2096. // create a monochrome memory DC
  2097. CDC ddc;
  2098. ddc.CreateCompatibleDC(0);
  2099. CBitmap bwbmp;
  2100. bwbmp.CreateCompatibleBitmap(&ddc, nWidth, nHeight);
  2101. CBitmap * pddcOldBmp = ddc.SelectObject(&bwbmp);
  2103. CDC dc;
  2104. dc.CreateCompatibleDC(0);
  2105. CBitmap * pdcOldBmp = dc.SelectObject(&bmp);
  2107. // build a mask
  2108. ddc.PatBlt(0, 0, nWidth, nHeight, WHITENESS);
  2109. dc.SetBkColor(GetSysColor(COLOR_BTNFACE));
  2110. ddc.BitBlt(0, 0, nWidth, nHeight, &dc, nXSrc,nYSrc, SRCCOPY);
  2111. dc.SetBkColor(GetSysColor(COLOR_BTNHILIGHT));
  2112. ddc.BitBlt(0, 0, nWidth, nHeight, &dc, nXSrc,nYSrc, SRCPAINT);
  2114. // Copy the image from the toolbar into the memory DC
  2115. // and draw it (grayed) back into the toolbar.
  2116. dc.FillSolidRect(0,0, nWidth, nHeight, bgcolor);
  2117. //SK: Looks better on the old shell
  2118. dc.SetBkColor(RGB(0, 0, 0));
  2119. dc.SetTextColor(RGB(255, 255, 255));
  2120. CBrush brShadow, brHilight;
  2121. brHilight.CreateSolidBrush(GetSysColor(COLOR_BTNHILIGHT));
  2122. brShadow.CreateSolidBrush(GetSysColor(COLOR_BTNSHADOW));
  2123. CBrush * pOldBrush = dc.SelectObject(&brHilight);
  2124. dc.BitBlt(0,0, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
  2125. drawdc->BitBlt(nXDest+1,nYDest+1,nWidth, nHeight, &dc,0,0,SRCCOPY);
  2126. dc.BitBlt(1,1, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
  2127. dc.SelectObject(&brShadow);
  2128. dc.BitBlt(0,0, nWidth, nHeight, &ddc, 0, 0, 0x00E20746L);
  2129. drawdc->BitBlt(nXDest,nYDest,nWidth, nHeight, &dc,0,0,SRCCOPY);
  2130. // reset DCs
  2131. ddc.SelectObject(pddcOldBmp);
  2132. ddc.DeleteDC();
  2133. dc.SelectObject(pOldBrush);
  2134. dc.SelectObject(pdcOldBmp);
  2135. dc.DeleteDC();
  2137. brShadow.DeleteObject();
  2138. brHilight.DeleteObject();
  2139. bwbmp.DeleteObject();
  2140. }
  2142. void BCMenu::SetDisableOldStyle(void)
  2143. {
  2144. disable_old_style=TRUE;
  2145. }
  2147. void BCMenu::UnSetDisableOldStyle(void)
  2148. {
  2149. disable_old_style=FALSE;
  2150. }
  2152. BOOL BCMenu::GetDisableOldStyle(void)
  2153. {
  2154. return(disable_old_style);
  2155. }
  2158. WORD BCMenu::NumBitmapColors(LPBITMAPINFOHEADER lpBitmap)
  2159. {
  2160. if ( lpBitmap->biClrUsed != 0)
  2161. return (WORD)lpBitmap->biClrUsed;
  2163. switch (lpBitmap->biBitCount){
  2164. case 1:
  2165. return 2;
  2166. case 4:
  2167. return 16;
  2168. case 8:
  2169. return 256;
  2170. default:
  2171. return 0;
  2172. }
  2173. return 0;
  2174. }
  2176. HBITMAP BCMenu::LoadSysColorBitmap(int nResourceId)
  2177. {
  2178. HINSTANCE hInst = 
  2179. AfxFindResourceHandle(MAKEINTRESOURCE(nResourceId),RT_BITMAP);
  2180. HRSRC hRsrc = 
  2181. ::FindResource(hInst,MAKEINTRESOURCE(nResourceId),RT_BITMAP);
  2182. if (hRsrc == NULL)return NULL;
  2184. // determine how many colors in the bitmap
  2185. HGLOBAL hglb;
  2186. if ((hglb = LoadResource(hInst, hRsrc)) == NULL)
  2187. return NULL;
  2188. LPBITMAPINFOHEADER lpBitmap = (LPBITMAPINFOHEADER)LockResource(hglb);
  2189. if (lpBitmap == NULL)return NULL;
  2190. WORD numcol = NumBitmapColors(lpBitmap);
  2191. ::FreeResource(hglb);
  2193. if(numcol!=16)return(NULL);
  2195. return AfxLoadSysColorBitmap(hInst, hRsrc, FALSE);
  2196. }
  2198. BOOL BCMenu::RemoveMenu(UINT uiId,UINT nFlags)
  2199. {
  2200. if(MF_BYPOSITION&nFlags){
  2201. UINT uint = GetMenuState(uiId,MF_BYPOSITION);
  2202. if(uint&MF_SEPARATOR && !(uint&MF_POPUP)){
  2203. delete m_MenuList.GetAt(uiId);
  2204. m_MenuList.RemoveAt(uiId);
  2205. }
  2206. else{
  2207. BCMenu* pSubMenu = (BCMenu*) GetSubMenu(uiId);
  2208. if(NULL==pSubMenu){
  2209. UINT uiCommandId = GetMenuItemID(uiId);
  2210. for(int i=0;i<m_MenuList.GetSize(); i++){
  2211. if(m_MenuList[i]->nID==uiCommandId){
  2212. delete m_MenuList.GetAt(i);
  2213. m_MenuList.RemoveAt(i);
  2214. break;
  2215. }
  2216. }
  2217. }
  2218. else{
  2219. int numSubMenus = m_SubMenus.GetUpperBound();
  2220. for(int m = numSubMenus; m >= 0; m--){
  2221. if(m_SubMenus[m]==pSubMenu->m_hMenu){
  2222. int numAllSubMenus = m_AllSubMenus.GetUpperBound();
  2223. for(int n = numAllSubMenus; n>= 0; n--){
  2224. if(m_AllSubMenus[n]==m_SubMenus[m])m_AllSubMenus.RemoveAt(n);
  2225. }
  2226. m_SubMenus.RemoveAt(m);
  2227. }
  2228. }
  2229. int num = pSubMenu->GetMenuItemCount();
  2230. for(int i=num-1;i>=0;--i)pSubMenu->RemoveMenu(i,MF_BYPOSITION);
  2231. for(i=m_MenuList.GetUpperBound();i>=0;i--){
  2232. if(m_MenuList[i]->nID==(UINT)pSubMenu->m_hMenu){
  2233. delete m_MenuList.GetAt(i);
  2234. m_MenuList.RemoveAt(i);
  2235. break;
  2236. }
  2237. }
  2238. delete pSubMenu;
  2239. }
  2240. }
  2241. }
  2242. else{
  2243. int iPosition =0;
  2244. BCMenu* pMenu = FindMenuOption(uiId,iPosition);
  2245. // bug fix RIA 14th September 2000 
  2246. // failed to return correct value on call to remove menu as the item was 
  2247. // removed twice. The second time its not found 
  2248. // so a value of 0 was being returned 
  2249. if(pMenu) return pMenu->RemoveMenu(iPosition,MF_BYPOSITION); // added return 
  2250. }
  2251. return CMenu::RemoveMenu(uiId,nFlags);
  2252. }
  2254. BOOL BCMenu::DeleteMenu(UINT uiId,UINT nFlags)
  2255. {
  2256. if(MF_BYPOSITION&nFlags){
  2257. UINT uint = GetMenuState(uiId,MF_BYPOSITION);
  2258. if(uint&MF_SEPARATOR && !(uint&MF_POPUP)){
  2259. delete m_MenuList.GetAt(uiId);
  2260. m_MenuList.RemoveAt(uiId);
  2261. }
  2262. else{
  2263. BCMenu* pSubMenu = (BCMenu*) GetSubMenu(uiId);
  2264. if(NULL==pSubMenu){
  2265. UINT uiCommandId = GetMenuItemID(uiId);
  2266. for(int i=0;i<m_MenuList.GetSize(); i++){
  2267. if(m_MenuList[i]->nID==uiCommandId){
  2268. delete m_MenuList.GetAt(i);
  2269. m_MenuList.RemoveAt(i);
  2270. break;
  2271. }
  2272. }
  2273. }
  2274. else{
  2275. int numSubMenus = m_SubMenus.GetUpperBound();
  2276. for(int m = numSubMenus; m >= 0; m--){
  2277. if(m_SubMenus[m]==pSubMenu->m_hMenu){
  2278. int numAllSubMenus = m_AllSubMenus.GetUpperBound();
  2279. for(int n = numAllSubMenus; n>= 0; n--){
  2280. if(m_AllSubMenus[n]==m_SubMenus[m])m_AllSubMenus.RemoveAt(n);
  2281. }
  2282. m_SubMenus.RemoveAt(m);
  2283. }
  2284. }
  2285. int num = pSubMenu->GetMenuItemCount();
  2286. for(int i=num-1;i>=0;--i)pSubMenu->DeleteMenu(i,MF_BYPOSITION);
  2287. for(i=m_MenuList.GetUpperBound();i>=0;i--){
  2288. if(m_MenuList[i]->nID==(UINT)pSubMenu->m_hMenu){
  2289. delete m_MenuList.GetAt(i);
  2290. m_MenuList.RemoveAt(i);
  2291. break;
  2292. }
  2293. }
  2294. delete pSubMenu;
  2295. }
  2296. }
  2297. }
  2298. else{
  2299. int iPosition =0;
  2300. BCMenu* pMenu = FindMenuOption(uiId,iPosition);
  2301. if(pMenu)pMenu->DeleteMenu(iPosition,MF_BYPOSITION);
  2302. }
  2303. return CMenu::DeleteMenu(uiId,nFlags);
  2304. }
  2307. BOOL BCMenu::AppendMenuA(UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,int nIconNormal)
  2308. {
  2309. USES_CONVERSION;
  2310. return AppendMenuW(nFlags,nIDNewItem,A2W(lpszNewItem),nIconNormal);
  2311. }
  2313. BOOL BCMenu::AppendMenuW(UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,int nIconNormal)
  2314. {
  2315. return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,nIconNormal);
  2316. }
  2318. BOOL BCMenu::AppendMenuA(UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CImageList *il,int xoffset)
  2319. {
  2320. USES_CONVERSION;
  2321. return AppendMenuW(nFlags,nIDNewItem,A2W(lpszNewItem),il,xoffset);
  2322. }
  2324. BOOL BCMenu::AppendMenuW(UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CImageList *il,int xoffset)
  2325. {
  2326. return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,il,xoffset);
  2327. }
  2329. BOOL BCMenu::AppendMenuA(UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CBitmap *bmp)
  2330. {
  2331. USES_CONVERSION;
  2332. return AppendMenuW(nFlags,nIDNewItem,A2W(lpszNewItem),bmp);
  2333. }
  2335. BOOL BCMenu::AppendMenuW(UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CBitmap *bmp)
  2336. {
  2337. if(bmp){
  2338. CImageList temp;
  2339. temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  2340. if(m_bitmapBackgroundFlag)temp.Add(bmp,m_bitmapBackground);
  2341. else temp.Add(bmp,GetSysColor(COLOR_3DFACE));
  2342. return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,&temp,0);
  2343. }
  2344. return AppendODMenuW(lpszNewItem,nFlags,nIDNewItem,NULL,0);
  2345. }
  2347. BOOL BCMenu::InsertMenuA(UINT nPosition,UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,int nIconNormal)
  2348. {
  2349. USES_CONVERSION;
  2350. return InsertMenuW(nPosition,nFlags,nIDNewItem,A2W(lpszNewItem),nIconNormal);
  2351. }
  2353. BOOL BCMenu::InsertMenuW(UINT nPosition,UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,int nIconNormal)
  2354. {
  2355. return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,nIconNormal);
  2356. }
  2358. BOOL BCMenu::InsertMenuA(UINT nPosition,UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CImageList *il,int xoffset)
  2359. {
  2360. USES_CONVERSION;
  2361. return InsertMenuW(nPosition,nFlags,nIDNewItem,A2W(lpszNewItem),il,xoffset);
  2362. }
  2364. BOOL BCMenu::InsertMenuW(UINT nPosition,UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CImageList *il,int xoffset)
  2365. {
  2366. return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,il,xoffset);
  2367. }
  2369. BOOL BCMenu::InsertMenuA(UINT nPosition,UINT nFlags,UINT nIDNewItem,const char *lpszNewItem,CBitmap *bmp)
  2370. {
  2371. USES_CONVERSION;
  2372. return InsertMenuW(nPosition,nFlags,nIDNewItem,A2W(lpszNewItem),bmp);
  2373. }
  2375. BOOL BCMenu::InsertMenuW(UINT nPosition,UINT nFlags,UINT nIDNewItem,wchar_t *lpszNewItem,CBitmap *bmp)
  2376. {
  2377. if(bmp){
  2378. CImageList temp;
  2379. temp.Create(m_iconX,m_iconY,ILC_COLORDDB|ILC_MASK,1,1);
  2380. if(m_bitmapBackgroundFlag)temp.Add(bmp,m_bitmapBackground);
  2381. else temp.Add(bmp,GetSysColor(COLOR_3DFACE));
  2382. return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,&temp,0);
  2383. }
  2384. return InsertODMenuW(nPosition,lpszNewItem,nFlags,nIDNewItem,NULL,0);
  2385. }
  2387. //--------------------------------------------------------------------------
  2388. //[21.06.99 rj]
  2389. BCMenu* BCMenu::AppendODPopupMenuW(wchar_t *lpstrText)
  2390. {
  2391. BCMenu* pSubMenu = new BCMenu;
  2392. pSubMenu->m_unselectcheck=m_unselectcheck;
  2393. pSubMenu->m_selectcheck=m_selectcheck;
  2394. pSubMenu->checkmaps=checkmaps;
  2395. pSubMenu->checkmapsshare=TRUE;
  2396. pSubMenu->CreatePopupMenu();
  2397. AppendODMenuW(lpstrText,MF_POPUP,(UINT)pSubMenu->m_hMenu, -1);
  2398. return pSubMenu;
  2399. }
  2401. //--------------------------------------------------------------------------
  2402. //[21.06.99 rj]
  2403. BCMenu* BCMenu::AppendODPopupMenuA(LPCSTR lpstrText)
  2404. {
  2405. USES_CONVERSION;
  2406. return AppendODPopupMenuW(A2W(lpstrText));
  2407. }
  2409. BOOL BCMenu::ImageListDuplicate(CImageList *il,int xoffset,CImageList *newlist)
  2410. {
  2411. if (il == NULL||newlist==NULL||xoffset<0) return FALSE;
  2412. HICON hIcon = il->ExtractIcon(xoffset);
  2413. int cx, cy;
  2414. ImageList_GetIconSize(il->m_hImageList, &cx, &cy);
  2415. newlist->Create(cx,cy,ILC_COLORDDB|ILC_MASK,1,1);
  2416. newlist->Add(hIcon);
  2417. ::DestroyIcon(hIcon);
  2418. return TRUE;
  2419. }
  2421. // 2001-07-12, Damir Valiulin:
  2422. //          Added GetSubMenu (LPCTSTR lpszSubMenuName) function
  2423. //
  2425. CMenu* BCMenu::GetSubMenu(int nPos)
  2426. {
  2427. return CMenu::GetSubMenu (nPos);
  2428. }
  2430. CMenu* BCMenu::GetSubMenu(LPCTSTR lpszSubMenuName)
  2431. {
  2432. int num = GetMenuItemCount ();
  2433. CString name;
  2435. for (int i=0; i<num; i++)
  2436. {
  2437. GetMenuString (i, name, MF_BYPOSITION);
  2438. if (name.Compare (lpszSubMenuName) == 0)
  2439. {
  2440. return CMenu::GetSubMenu (i);
  2441. }
  2442. }
  2444. return NULL;
  2445. }
  2447. // Tongzhe Cui, Functions to remove a popup menu based on its name. Seperators
  2448. // before and after the popup menu can also be removed if they exist.
  2449. int BCMenu::GetMenuPosition(char* pText)
  2450. {
  2451. USES_CONVERSION;
  2452. return GetMenuPosition(A2W(pText));
  2453. }
  2455. int BCMenu::GetMenuPosition(wchar_t* pText)
  2456. {
  2457. int i,j;
  2458. BCMenu* psubmenu;
  2459. for(i=0;i<(int)(GetMenuItemCount());++i)
  2460. {
  2461. psubmenu=(BCMenu *)GetSubMenu(i);
  2462. if(!psubmenu)
  2463. {
  2464. const wchar_t *szWide;//SK: we use const to prevent misuse of this Ptr
  2465. for(j=0;j<=m_MenuList.GetUpperBound();++j)
  2466. {     
  2467. szWide = m_MenuList[j]->GetWideString ();
  2468. if(szWide && !wcscmp(pText,szWide))//SK: modified for dynamic allocation
  2469. return j;
  2470. }
  2471. }
  2472. }
  2473. // means no found;
  2474. return -1;
  2475. }
  2477. int BCMenu::RemoveMenu(char* pText, BC_Seperator sPos)
  2478. {
  2479. USES_CONVERSION;
  2480. return RemoveMenu(A2W(pText), sPos);
  2481. }
  2483. int BCMenu::RemoveMenu(wchar_t* pText, BC_Seperator sPos)
  2484. {
  2485. int nPos = GetMenuPosition(pText);
  2486. if(nPos != -1)
  2487. {
  2488. RemoveMenu(nPos, MF_BYPOSITION);
  2489. }
  2490. if(sPos == BCMENU_HEAD)
  2491. {
  2492. ASSERT(nPos - 1 >= 0);
  2493. RemoveMenu(nPos-1, MF_BYPOSITION);
  2494. }
  2495. else if(sPos == BCMENU_TAIL)
  2496. {
  2497. RemoveMenu(nPos-1, MF_BYPOSITION);
  2498. }
  2499. else if(sPos == BCMENU_BOTH)
  2500. {
  2501. // remove the end first;
  2502. RemoveMenu(nPos-1, MF_BYPOSITION);
  2503. // remove the head;
  2504. ASSERT(nPos - 1 >= 0);
  2505. RemoveMenu(nPos-1, MF_BYPOSITION);
  2506. }
  2507. return nPos;
  2508. }
  2510. // Larry Antram
  2511. BOOL BCMenu::SetMenuText(UINT id, CString string, UINT nFlags/*= MF_BYPOSITION*/ )
  2512. {
  2513. BOOL returnflag=FALSE;
  2515. if(MF_BYPOSITION&nFlags)
  2516. {
  2517. UINT numMenuItems = m_MenuList.GetUpperBound();
  2518. if(id<=numMenuItems){
  2519. #ifdef UNICODE
  2520. m_MenuList[id]->SetWideString((LPCTSTR)string);
  2521. #else
  2522. m_MenuList[id]->SetAnsiString(string);
  2523. #endif
  2524. returnflag=TRUE;
  2525. }
  2526. }
  2527. else{
  2528. int uiLoc;
  2529. BCMenu* pMenu = FindMenuOption(id,uiLoc);
  2530. if(NULL!=pMenu) returnflag = pMenu->SetMenuText(uiLoc,string);
  2531. }
  2532. return(returnflag);
  2533. }
  2535. // courtesy of Warren Stevens
  2536. void BCMenu::ColorBitmap(CDC* pDC,CBitmap& bmp,CSize size,COLORREF fill,COLORREF border,int hatchstyle)
  2537. {
  2538. CDC bmpdc;
  2539. bmpdc.CreateCompatibleDC(pDC);
  2541. bmp.CreateCompatibleBitmap(pDC, size.cx, size.cy);
  2542. CPen border_pen(PS_SOLID, 1, border);
  2544. CBrush fill_brush;
  2545. if(hatchstyle!=-1) { fill_brush.CreateHatchBrush(hatchstyle, fill); }
  2546. else      { fill_brush.CreateSolidBrush(fill);             }
  2548. CBitmap* pOldBitmap = bmpdc.SelectObject(&bmp);
  2549. CPen*    pOldPen    = bmpdc.SelectObject(&border_pen);
  2550. CBrush*  pOldBrush  = bmpdc.SelectObject(&fill_brush);
  2552. bmpdc.Rectangle(0,0, size.cx, size.cy);
  2554. if(NULL!=pOldBrush)  { bmpdc.SelectObject(pOldBrush);  }
  2555. if(NULL!=pOldPen)    { bmpdc.SelectObject(pOldPen);    }
  2556. if(NULL!=pOldBitmap) { bmpdc.SelectObject(pOldBitmap); }
  2557. }
  2559. //*************************************************************************