BCMenu.cpp
上传用户:dtengfei
上传日期:2013-01-16
资源大小:393k
文件大小:86k
源码类别:

医药行业

开发平台:

Visual C++

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