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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
MenuSpawn.cpp
资源名称：GGBT.rar　[点击查看]
上传用户：lds876
上传日期：2013-05-25
资源大小：567k
文件大小：23k
源码类别：

P2P编程

开发平台：

Visual C++

MenuSpawn.cpp：源码内容
  1. // MenuSpawn.cpp: implementation of the CMenuSpawn class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. // #include "ToolbarMenuDemoMDI.h"
  7. #include "MenuSpawn.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  15. #define COLOR_MENUBAR 30
  16. #define SPI_GETFLATMENU 0x1022
  18. //////////////////////////////////////////////////////////////////////
  19. // Construction/Destruction
  20. //////////////////////////////////////////////////////////////////////
  23. HFONT CMenuSpawn::hMenuFont = NULL;
  24. HFONT CMenuSpawn::hGuiFont = NULL;
  25. COLORREF CMenuSpawn::crMenuText = 0;
  26. COLORREF CMenuSpawn::crMenuTextSel = 0;
  27. COLORREF CMenuSpawn::cr3dFace = 0;
  28. COLORREF CMenuSpawn::crMenu = 0;
  29. COLORREF CMenuSpawn::crHighlight = 0;
  30. COLORREF CMenuSpawn::cr3dHilight = 0;
  31. COLORREF CMenuSpawn::cr3dShadow = 0;
  32. COLORREF CMenuSpawn::crGrayText = 0;
  33. COLORREF CMenuSpawn::crMenuTitle = 0;
  34. COLORREF CMenuSpawn::m_clrBtnFace = 0;
  35. COLORREF CMenuSpawn::m_clrBtnHilight = 0;
  36. COLORREF CMenuSpawn::m_clrBtnShadow = 0;
  37. vector<CImageList*> CMenuSpawn::m_vImageList;
  39. void CMenuSpawn::OnSystemColorChange()
  40. {
  41. if (hMenuFont)
  42. ::DeleteObject((HGDIOBJ)hMenuFont);
  43. if (hGuiFont)
  44. ::DeleteObject((HGDIOBJ)hGuiFont);
  46. //
  47. // decide whether it is flat menu.
  48. //
  49. BOOL bFlat = false;
  50. BOOL bRet = SystemParametersInfo(SPI_GETFLATMENU, 0, &bFlat, 0);
  51. if (!bRet) bFlat = false;
  53. if (bFlat)
  54. crMenuTitle = GetSysColor(COLOR_MENUBAR);
  55. else
  56. crMenuTitle = GetSysColor(COLOR_MENU);
  58. crMenuText = GetSysColor(COLOR_MENUTEXT);
  59. crMenuTextSel = GetSysColor(COLOR_HIGHLIGHTTEXT);
  61. cr3dFace = GetSysColor(COLOR_3DFACE);
  62. crMenu = GetSysColor(COLOR_MENU);
  63. crHighlight = GetSysColor(COLOR_HIGHLIGHT);
  64. cr3dHilight = GetSysColor(COLOR_3DHILIGHT);
  65. cr3dShadow = GetSysColor(COLOR_3DSHADOW);
  66. crGrayText = GetSysColor(COLOR_GRAYTEXT);
  68. m_clrBtnFace = GetSysColor(COLOR_BTNFACE);
  69. m_clrBtnHilight = GetSysColor(COLOR_BTNHILIGHT);
  70. m_clrBtnShadow = GetSysColor(COLOR_BTNSHADOW);
  72. NONCLIENTMETRICS ncm;
  73. memset(&ncm, 0, sizeof(ncm));
  74. ncm.cbSize = sizeof(ncm);
  75. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, (PVOID) &ncm, 0);
  77. hGuiFont = ::CreateFontIndirect(&ncm.lfMenuFont);
  78. hMenuFont = NULL;
  80. /*
  81. for (int i=0; i<m_vImageList.size();i++)
  82. {
  83. if (m_vImageList[i]->GetSafeHandle())
  84. {
  85. m_vImageList[i]->SetBkColor(crMenu);
  86. }
  87. }
  88. //*/
  89. }
  92. CMenuSpawn::CMenuSpawn()
  93. {
  94. Init();
  95. m_iNormalImgInx = -1;
  96. }
  98. CMenuSpawn::CMenuSpawn(const bool _IsPopup)
  99. {
  100. Init();
  101. bIsPopup = _IsPopup;
  103. m_vImageList.push_back(&ilList);
  104. m_vImageList.push_back(&ilDisabledList);
  105. }
  107. CMenuSpawn::~CMenuSpawn()
  108. {
  109. vector<CImageList*>::iterator iter = find(m_vImageList.begin(), m_vImageList.end(), &ilList);
  110. if (iter != m_vImageList.end())
  111. m_vImageList.erase(iter);
  113. iter = find(m_vImageList.begin(), m_vImageList.end(), &ilDisabledList);
  114. if (iter != m_vImageList.end())
  115. m_vImageList.erase(iter);
  117. Clear();
  118. // if (hGuiFont) ::DeleteObject((HGDIOBJ)hGuiFont);
  119. }
  121. void CMenuSpawn::Clear()
  122. {
  123. if (iSpawnItem > 0)
  124. {
  125. for (int t = 0; t < iSpawnItem; t++)
  126. if (pSpawnItem[t]) delete pSpawnItem[t];
  128. GlobalFree((HGLOBAL) pSpawnItem);
  129. }
  131. iSpawnItem = 0;
  132. pSpawnItem = NULL;
  135. if (iImageItem > 0)
  136. {
  137. GlobalFree((HGLOBAL) pImageItem);
  138. }
  140. iImageItem = 0;
  141. pImageItem = NULL;
  143. if (hMenuFont)
  144. ::DeleteObject((HGDIOBJ)hMenuFont);
  146. if (ilList)
  147. {
  148. BOOL bRet = ilList.DeleteImageList();
  149. ASSERT(bRet);
  150. }
  151. if (ilDisabledList)
  152. {
  153. BOOL bRet = ilDisabledList.DeleteImageList();
  154. ASSERT(bRet);
  155. }
  156. }
  158. void CMenuSpawn::Init()
  159. {
  160. ASSERT(hGuiFont);
  161. //
  162. // decide whether it is flat menu.
  163. //
  164. /*
  165. BOOL bFlat = false;
  166. BOOL bRet = SystemParametersInfo(SPI_GETFLATMENU, 0, &bFlat, 0);
  167. if (!bRet) bFlat = false;
  169. if (bFlat)
  170. crMenuTitle = GetSysColor(COLOR_MENUBAR);
  171. else
  172. crMenuTitle = GetSysColor(COLOR_MENU);
  175. crMenuText = GetSysColor(COLOR_MENUTEXT);
  176. crMenuTextSel = GetSysColor(COLOR_HIGHLIGHTTEXT);
  178. cr3dFace = GetSysColor(COLOR_3DFACE);
  179. crMenu = GetSysColor(COLOR_MENU);
  180. crHighlight = GetSysColor(COLOR_HIGHLIGHT);
  181. cr3dHilight = GetSysColor(COLOR_3DHILIGHT);
  182. cr3dShadow = GetSysColor(COLOR_3DSHADOW);
  183. crGrayText = GetSysColor(COLOR_GRAYTEXT);
  185. m_clrBtnFace = GetSysColor(COLOR_BTNFACE);
  186. m_clrBtnHilight = GetSysColor(COLOR_BTNHILIGHT);
  187. m_clrBtnShadow = GetSysColor(COLOR_BTNSHADOW);
  188. //*/
  190. iSpawnItem = 0;
  191. pSpawnItem = NULL;
  193. iImageItem = 0;
  194. pImageItem = NULL;
  196. szImage = CSize(20,20);
  198. COLORMAP cMap[3] = { 
  199. { RGB(128,128,128), cr3dShadow }, 
  200. { RGB(192,192,192), cr3dFace }, 
  201. { RGB(255,255,255), cr3dHilight }
  202. };
  203. /*
  204. CBitmap bmp;
  205. bmp.LoadMappedBitmap(IDB_MENUCHK, 0, cMap, 3);
  206. ilOther.Create(19, 19, ILC_COLOR4|ILC_MASK, 1, 0);
  207. ilOther.Add(&bmp, cr3dFace);
  208. bmp.DeleteObject();
  209. //*/
  211. /*
  212. NONCLIENTMETRICS ncm;
  213. memset(&ncm, 0, sizeof(ncm));
  214. ncm.cbSize = sizeof(ncm);
  216. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, (PVOID) &ncm, 0);
  218. hGuiFont = ::CreateFontIndirect(&ncm.lfMenuFont);
  219. //*/
  221. bIsPopup = false;
  222. bBackBitmap = false;
  223. m_iNormalImgInx = -1;
  224. }
  228. bool CMenuSpawn::Create(unsigned int bmpId, unsigned int bmpDisabledId, int iCount, ULONG lMenuCmdID[])
  229. {
  230. Clear();
  232. HBITMAP hbm = (HBITMAP)::LoadImage(AfxGetInstanceHandle(),
  233. MAKEINTRESOURCE(bmpId),
  234. IMAGE_BITMAP,
  235. 0,0, 
  236. LR_CREATEDIBSECTION);
  237. CBitmap bm;
  238. bm.Attach(hbm);
  240. szImage = CSize(16, 16);
  241. ilList.Create(16, 16, ILC_COLOR8|ILC_MASK, iCount, 4);
  242. // ilList.SetBkColor(RGB(255, 255,255)); 
  243. ilList.SetBkColor(crMenu);
  244. ilList.Add(&bm, (COLORREF)RGB(255,0,255));
  246. HBITMAP hbmDisabled = (HBITMAP)::LoadImage(AfxGetInstanceHandle(),
  247. MAKEINTRESOURCE(bmpDisabledId),
  248. IMAGE_BITMAP,
  249. 0,0, 
  250. LR_CREATEDIBSECTION);
  251. CBitmap bmDisabled;
  252. bmDisabled.Attach(hbmDisabled);
  254. ilDisabledList.Create(16, 16, ILC_COLOR8|ILC_MASK, iCount, 4);
  255. ilDisabledList.SetBkColor(crMenu);
  256. ilDisabledList.Add(&bmDisabled, (COLORREF)RGB(255,0,255));
  258. int nBmpItems = 0;
  259. for(int i=0; i<iCount; i++)
  260. {
  261. if(lMenuCmdID[i] == ID_SEPARATOR)
  262. {
  263. ASSERT(FALSE);
  264. return false;
  265. }
  267. if(lMenuCmdID[i] == eUnusedImgCmdID)
  268. {
  269. nBmpItems++;
  270. continue;
  271. }
  273. if(lMenuCmdID[i] == eNormalImgCmdID)
  274. {
  275. m_iNormalImgInx = i;
  276. nBmpItems++;
  277. continue;
  278. }
  280. AddImageItem(nBmpItems++, (WORD)lMenuCmdID[i]);
  281. }
  283. return true;
  284. }
  285. bool CMenuSpawn::AddToolBarResource(unsigned int resId)
  286. {
  287. ASSERT(FALSE);
  288. HRSRC hRsrc = ::FindResource(AfxGetResourceHandle(), MAKEINTRESOURCE(resId), RT_TOOLBAR);
  289. if (hRsrc == NULL) return false;
  291. HGLOBAL hGlb = ::LoadResource(AfxGetResourceHandle(), hRsrc);
  292. if (hGlb == NULL) return false;
  294. ToolBarData* pTBData = (ToolBarData*) ::LockResource(hGlb);
  295. if (pTBData == NULL) return false;
  297. ASSERT(pTBData->wVersion == 1);
  299. CBitmap bmp;
  300. bmp.LoadBitmap(resId);
  301. int nBmpItems = ilList.Add(&bmp, RGB(192,192,192));
  302. bmp.DeleteObject();
  304. WORD* pItem = (WORD*)(pTBData+1);
  306. for(int i=0; i<pTBData->wItemCount; i++, pItem++)
  307. {
  308. if(*pItem != ID_SEPARATOR)
  309. AddImageItem(nBmpItems++, (WORD) *pItem);
  310. }
  311. // ** it seem that Windows doesn't free these resource (from Heitor Tome)
  312.     ::UnlockResource(hGlb);
  313.     ::FreeResource(hGlb);
  314. // **
  315. return true;
  316. }
  319. bool CMenuSpawn::LoadToolBarResource(unsigned int resId)
  320. {
  321. ASSERT(FALSE);
  323. HRSRC hRsrc = ::FindResource(AfxGetResourceHandle(), MAKEINTRESOURCE(resId), RT_TOOLBAR);
  324. if (hRsrc == NULL) return false;
  326. HGLOBAL hGlb = ::LoadResource(AfxGetResourceHandle(), hRsrc);
  327. if (hGlb == NULL) return false;
  329. ToolBarData* pTBData = (ToolBarData*) ::LockResource(hGlb);
  330. if (pTBData == NULL) return false;
  332. ASSERT(pTBData->wVersion == 1);
  334. szImage.cx = (int) pTBData->wWidth;
  335. szImage.cy = (int) pTBData->wHeight;
  337. if (ilList.Create(szImage.cx, szImage.cy, ILC_COLOR4|ILC_MASK, pTBData->wItemCount, 0) == false)
  338. return false;
  340. ilList.SetBkColor(cr3dFace);
  342. CBitmap bmp;
  343. bmp.LoadBitmap(resId);
  344. ilList.Add(&bmp, RGB(192,192,192));
  345. bmp.DeleteObject();
  347. WORD* pItem = (WORD*)(pTBData+1);
  348. int nBmpItems = 0;
  349. for(int i=0; i<pTBData->wItemCount; i++, pItem++)
  350. {
  351. if(*pItem != ID_SEPARATOR)
  352. AddImageItem(nBmpItems++, (WORD) *pItem);
  353. }
  354. // ** it seem that Windows doesn't free these resource (from Heitor Tome)
  355.     ::UnlockResource(hGlb);
  356.     ::FreeResource(hGlb);
  357. // **
  358. return true;
  359. }
  361. void CMenuSpawn::AddImageItem(const int idx, WORD cmd)
  362. {
  363. if (iImageItem == 0)
  364. pImageItem = (ImageItem *) GlobalAlloc(GPTR, sizeof(ImageItem));
  365. else
  366. pImageItem = (ImageItem *) GlobalReAlloc((HGLOBAL) pImageItem, sizeof(ImageItem) * (iImageItem + 1), GMEM_MOVEABLE|GMEM_ZEROINIT);
  368. ASSERT(pImageItem);
  369. pImageItem[iImageItem].iCmd = (int) cmd;
  370. pImageItem[iImageItem].iImageIdx = idx;
  371. iImageItem ++;
  372. }
  374. void CMenuSpawn::RemapMenuEx(CMenu * pMenu)
  375. {
  376. //
  377. // release spawn items.
  378. //
  379. /*
  380. if (iSpawnItem > 0)
  381. {
  382. for (int t = 0; t < iSpawnItem; t++)
  383. if (pSpawnItem[t]) delete pSpawnItem[t];
  385. GlobalFree((HGLOBAL) pSpawnItem);
  386. }
  388. iSpawnItem = 0;
  389. pSpawnItem = NULL;
  390. //*/
  391. RemapMenu(pMenu);
  393. }
  394. void CMenuSpawn::RemapMenu(CMenu * pMenu)
  395. {
  397. // regen mapitems.
  398. static int iRecurse = 0;
  399. iRecurse ++;
  401. ASSERT(pMenu);
  402. int nItem = pMenu->GetMenuItemCount();
  403. while ((--nItem)>=0)
  404. {
  405. UINT itemId = pMenu->GetMenuItemID(nItem);
  406. if (itemId == (UINT) -1)
  407. {
  408. CMenu *pops = pMenu->GetSubMenu(nItem);
  409. if (pops) RemapMenu(pops);
  410. if (bIsPopup || iRecurse > 0)
  411. {
  412. CString cs;
  413. pMenu->GetMenuString(nItem, cs, MF_BYPOSITION);
  414. if (cs != "")
  415. {
  416. if (bIsPopup)
  417. {
  418. SpawnItem * sp = AddSpawnItem(cs, (!bIsPopup && iRecurse == 1) ? -4 : -2);
  419. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW, (UINT) -1, (LPCTSTR)sp);
  420. }
  421. }
  422. }
  423. }
  424. else
  425. {
  426. if (itemId != 0)
  427. {
  428. UINT oldState = pMenu->GetMenuState(nItem,MF_BYPOSITION);
  429. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  430. {
  431. ASSERT(oldState != (UINT)-1);
  432. CString cs;
  433. pMenu->GetMenuString(nItem, cs, MF_BYPOSITION);
  434. SpawnItem * sp = AddSpawnItem(cs, itemId);
  435. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  436. }
  437. }
  438. else
  439. {
  440. UINT oldState = pMenu->GetMenuState(nItem,MF_BYPOSITION);
  441. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  442. {
  443. ASSERT(oldState != (UINT)-1);
  444. SpawnItem * sp = AddSpawnItem("--", -3);
  445. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  446. }
  447. }
  448. }
  449. }
  450. iRecurse --;
  451. }
  453. CMenuSpawn::SpawnItem * CMenuSpawn::AddSpawnItem(const char * txt, const int cmd)
  454. {
  455. if (iSpawnItem == 0)
  456. pSpawnItem = (SpawnItem **) GlobalAlloc(GPTR, sizeof(SpawnItem));
  457. else
  458. pSpawnItem = (SpawnItem **) GlobalReAlloc((HGLOBAL) pSpawnItem, sizeof(SpawnItem) * (iSpawnItem + 1), GMEM_MOVEABLE|GMEM_ZEROINIT);
  460. ASSERT(pSpawnItem);
  462. SpawnItem * p = new SpawnItem;
  463. ASSERT(p);
  464. pSpawnItem[iSpawnItem] = p;
  465. lstrcpy(p->cText, txt);
  466. p->iCmd = cmd;
  468. if (cmd >= 0) p->iImageIdx = FindImageItem(cmd);
  469. else p->iImageIdx = cmd;
  471. iSpawnItem ++;
  472. return p;
  473. }
  475. int CMenuSpawn::FindImageItem(const int cmd)
  476. {
  477. for (int t = 0; t < iImageItem; t++)
  478. if (pImageItem[t].iCmd == cmd) return pImageItem[t].iImageIdx;
  480. return -1;
  481. }
  483. bool CMenuSpawn::DrawItem(LPDRAWITEMSTRUCT lp)
  484. {
  485. bool res = false;
  486. if (lp->CtlType == ODT_MENU)
  487. {
  488. UINT id = lp->itemID;
  489. UINT state = lp->itemState;
  490. bool bEnab = !(state & ODS_DISABLED);
  491. bool bSelect = (state & ODS_SELECTED) ? true : false;
  492. bool bChecked = (state & ODS_CHECKED) ? true : false;
  494. SpawnItem * pItem = (SpawnItem *) lp->itemData;
  495. if (pItem)
  496. {
  497. CDC * pDC = CDC::FromHandle(lp->hDC);
  498. CFont * pft = CFont::FromHandle((HFONT) hMenuFont ? hMenuFont : hGuiFont);
  499. CFont * of = pDC->SelectObject(pft);
  500. CRect rc(lp->rcItem);
  501. CRect rcImage(rc), rcText(rc);
  502. rcImage.right = rcImage.left + rc.Height();
  503. rcImage.bottom = rc.bottom;
  505. if (bBackBitmap) 
  506. {
  507. CDC tempDC;
  508. tempDC.CreateCompatibleDC(pDC);
  509. tempDC.FillSolidRect(rc, crMenu);
  510. CBitmap * ob = tempDC.SelectObject(&bmpBack);
  511. pDC->FillSolidRect(rc, crMenu);
  512. pDC->BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &tempDC, rc.left, rc.top, SRCCOPY );
  513. }
  515. if (pItem->iCmd == -3) // is a separator
  516. {
  517. CPen pnDk(PS_SOLID,1,cr3dShadow);
  518. CPen pnLt(PS_SOLID,1,cr3dHilight);
  519. CPen * opn = pDC->SelectObject(&pnDk);
  520. pDC->MoveTo(rc.left + 2, rc.top + 2);
  521. pDC->LineTo(rc.right - 2, rc.top + 2);
  522. pDC->SelectObject(&pnLt);
  523. pDC->MoveTo(rc.left + 2, rc.top + 3);
  524. pDC->LineTo(rc.right - 2, rc.top + 3);
  525. pDC->SelectObject(opn);
  526. }
  527. else if (pItem->iCmd == -4) // is a title item
  528. {
  529. CString cs(pItem->cText), cs1;
  530. CRect rcBdr(rcText);
  532. if (bSelect && bEnab)
  533. {
  534. rcText.top ++;
  535. rcText.left += 2;
  536. }
  537. pDC->FillSolidRect(rcText, crMenuTitle);
  538. pDC->DrawText(cs, rcText, DT_VCENTER|DT_CENTER|DT_SINGLELINE);
  539. if (bSelect && bEnab) pDC->Draw3dRect(rcBdr,cr3dShadow,cr3dHilight);
  540. }
  541. else
  542. {
  543. rcText.left += rcImage.right + 1;
  545. int obk = pDC->SetBkMode(TRANSPARENT);
  547. COLORREF ocr;
  548. if (bSelect)
  549. {
  550. //*
  551. if (pItem->iImageIdx >= 0 || (state & ODS_CHECKED))
  552. pDC->FillSolidRect(rcText, crHighlight);
  553. else
  554. pDC->FillSolidRect(rc, crHighlight);
  556. ocr = pDC->SetTextColor(crMenuTextSel);
  557. //*/
  558. }
  559. else
  560. {
  561. if (!bBackBitmap) 
  562. {
  563. if (pItem->iImageIdx >= 0 || (state & ODS_CHECKED))
  564. pDC->FillSolidRect(rcText, crMenu);
  565. else
  566. pDC->FillSolidRect(rc/*rcText*/, crMenu);
  567. }
  568. ocr = pDC->SetTextColor(crMenuText);
  569. }
  571. if (pItem->iImageIdx >= 0)
  572. {
  573. int ay = (rcImage.Height() - szImage.cy) / 2;
  574. int ax = (rcImage.Width()  - szImage.cx) / 2;
  576. /*
  577. if (bSelect && bEnab)
  578. pDC->Draw3dRect(rcImage,cr3dHilight,cr3dShadow);
  579. else
  580. {
  581. if (!bBackBitmap)
  582. pDC->Draw3dRect(rcImage,crMenu,crMenu);
  583. }
  584. //*/
  587. if (bEnab)
  588. {
  589. if (bSelect)
  590. ilList.Draw(pDC, pItem->iImageIdx, CPoint(rcImage.left + ax, rcImage.top +ay), ILD_BLEND25);
  591. else
  592. ilList.Draw(pDC, pItem->iImageIdx, CPoint(rcImage.left + ax, rcImage.top +ay), ILD_NORMAL);
  593. }
  594. else
  595. {
  596. ilDisabledList.Draw(pDC, pItem->iImageIdx, CPoint(rcImage.left + ax, rcImage.top +ay), ILD_NORMAL);
  597. /*
  598. HICON hIcon = ilList.ExtractIcon( pItem->iImageIdx );
  599. pDC->DrawState( CPoint(rcImage.left + ax, rcImage.top + ay ), szImage, (HICON)hIcon, DST_ICON | DSS_DISABLED, (CBrush *)NULL );
  600. //*/
  601. }
  602. }
  603. else
  604. {
  605. if (bChecked)
  606. {
  607. int ay = (rcImage.Height() - szImage.cy) / 2;
  608. int ax = (rcImage.Width()  - szImage.cx) / 2;
  610. if (m_iNormalImgInx >= 0)
  611. {
  612. if (bSelect)
  613. ilList.Draw(pDC, m_iNormalImgInx, CPoint(rcImage.left + ax, rcImage.top +ay), ILD_BLEND25);
  614. else
  615. ilList.Draw(pDC, m_iNormalImgInx, CPoint(rcImage.left + ax, rcImage.top +ay), ILD_NORMAL);
  616. }
  618. // ilOther.Draw(pDC, 0, CPoint(rcImage.left + ax, rcImage.top + ay - 2), ILD_NORMAL);
  619. }
  620. }
  622. CString cs(pItem->cText), cs1;
  623. CSize sz;
  624. sz = pDC->GetTextExtent(cs);
  625. int ay1 = (rcText.Height() - sz.cy) / 2;
  626. rcText.top += ay1;
  627. rcText.left += 2;
  628. rcText.right -= 15;
  630. int tf = cs.Find('t');
  631. if (tf >= 0)
  632. {
  633. cs1 = cs.Right(cs.GetLength() - tf - 1);
  634. cs = cs.Left(tf);
  635. if (!bEnab)
  636. {
  637. if (!bSelect)
  638. {
  639. CRect rcText1(rcText);
  640. rcText1.InflateRect(-1,-1);
  641. pDC->SetTextColor(cr3dHilight);
  642. pDC->DrawText(cs, rcText1, DT_VCENTER|DT_LEFT);
  643. pDC->DrawText(cs1, rcText1, DT_VCENTER|DT_RIGHT);
  644. pDC->SetTextColor(crGrayText);
  645. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  646. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  647. }
  648. else
  649. {
  650. pDC->SetTextColor(crMenu);
  651. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  652. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  653. }
  654. }
  655. else
  656. {
  657. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  658. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  659. }
  660. }
  661. else 
  662. {
  663. if (!bEnab)
  664. {
  665. if (!bSelect)
  666. {
  667. CRect rcText1(rcText);
  668. rcText1.InflateRect(-1,-1);
  669. pDC->SetTextColor(cr3dHilight);
  670. pDC->DrawText(cs, rcText1, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  671. pDC->SetTextColor(crGrayText);
  672. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  673. }
  674. else
  675. {
  676. pDC->SetTextColor(crMenu);
  677. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  678. }
  679. }
  680. else
  681. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  682. }
  683. pDC->SetTextColor(ocr);
  684. pDC->SetBkMode(obk);
  685. }
  687. pDC->SelectObject(of);
  688. }
  689. res = true;
  690. }
  691. return res;
  692. }
  694. bool CMenuSpawn::MeasureItem(LPMEASUREITEMSTRUCT lpm)
  695. {
  696. bool res = false;
  697. if (lpm->CtlType == ODT_MENU)
  698. {
  699. UINT id = lpm->itemID;
  701. SpawnItem * pItem = (SpawnItem *) lpm->itemData;
  702. if (pItem)
  703. {
  704. if (pItem->iCmd == -3) // is a separator
  705. {
  706. lpm->itemWidth  = 10;
  707. lpm->itemHeight = 6;
  708. }
  709. else
  710. {
  711. CString cs(pItem->cText);
  712. if (cs != "")
  713. {
  714. CClientDC dc(AfxGetMainWnd());
  715. CFont * pft = CFont::FromHandle(hMenuFont ? hMenuFont : hGuiFont);
  716. CFont * of = dc.SelectObject(pft);
  717. CSize osz = dc.GetOutputTabbedTextExtent(cs,0,NULL);
  718. if (pItem->iCmd == -4)
  719. {
  720. CRect rci(0,0,0,0);
  721. dc.DrawText(cs, rci, DT_CALCRECT|DT_TOP|DT_VCENTER|DT_SINGLELINE);
  722. lpm->itemHeight = rci.Height();
  723. lpm->itemWidth = rci.Width();
  724. }
  725. else
  726. {
  727. lpm->itemHeight = szImage.cy + 2;
  728. if (osz.cy > (int) lpm->itemHeight) lpm->itemHeight = (int) osz.cy;
  729. lpm->itemWidth  = osz.cx + 2 + 15;
  730. lpm->itemWidth += lpm->itemHeight > (UINT) szImage.cx ? (UINT) lpm->itemHeight : (UINT) szImage.cx;
  731. }
  732. dc.SelectObject(of);
  733. }
  734. else
  735. {
  736. lpm->itemHeight = szImage.cy + 5;
  737. lpm->itemWidth  = 100;
  738. }
  739. }
  740. }
  741. res = true;
  742. }
  743. return res;
  744. }
  746. void CMenuSpawn::EnableMenuItems(CMenu * pMenu, CWnd * pParent)
  747. {
  748. ASSERT(pMenu);
  749. ASSERT(pParent);
  751. int nItem = pMenu->GetMenuItemCount();
  752. CCmdUI state;
  753. state.m_pMenu = pMenu;
  754. state.m_nIndex = nItem-1;
  755. state.m_nIndexMax = nItem;
  757. while ((--nItem)>=0)
  758. {
  759. UINT itemId = pMenu->GetMenuItemID(nItem);
  760. if (itemId == (UINT) -1)
  761. {
  762. CMenu *pops = pMenu->GetSubMenu(nItem);
  763. if (pops) EnableMenuItems(pops, pParent);
  764. }
  765. else
  766. {
  767. if (itemId != 0)
  768. {
  769. state.m_nID = itemId;
  770. pParent->OnCmdMsg(itemId, CN_UPDATE_COMMAND_UI, &state, NULL);
  771. state.DoUpdate(pParent, true);
  772. }
  773. }
  774. state.m_nIndex = nItem-1;
  775. }
  776. }
  779. bool CMenuSpawn::SetFont(LOGFONT * lf)
  780. {
  781. ASSERT(lf);
  782. if (hMenuFont) ::DeleteObject((HGDIOBJ)hMenuFont);
  783. hMenuFont = CreateFontIndirect(lf);
  784. return hMenuFont != NULL ? true : false;
  785. }
  787. bool CMenuSpawn::FindKeyboardShortcut(UINT nChar, UINT nFlags, CMenu * pMenu, LRESULT & lRes)
  788. {
  789. ASSERT(pMenu);
  790. int nItem = pMenu->GetMenuItemCount();
  791. CString csChar((CHAR) nChar);
  792. csChar.MakeLower();
  793. while ((--nItem)>=0)
  794. {
  795. UINT itemId = pMenu->GetMenuItemID(nItem);
  796. if (itemId != 0)
  797. {
  798. MENUITEMINFO lpmi;
  799. ZeroMemory(&lpmi, sizeof(MENUITEMINFO));
  800. lpmi.cbSize = sizeof(MENUITEMINFO);
  801. lpmi.fMask = MIIM_DATA|MIIM_TYPE;
  802. ASSERT(pMenu->GetSafeHmenu());
  803. if (GetMenuItemInfo(pMenu->GetSafeHmenu(), nItem, TRUE, &lpmi))
  804. {
  805. if (lpmi.fType&MFT_OWNERDRAW)
  806. {
  807. SpawnItem * si = (SpawnItem *) lpmi.dwItemData;
  808. if (si)
  809. {
  810. CString csItem(si->cText);
  811. csItem.MakeLower();
  812. int iAmperIdx = csItem.Find('&');
  813. if (iAmperIdx >= 0)
  814. {
  815. csItem = csItem.Mid(iAmperIdx + 1, 1);
  816. if (csItem == csChar)
  817. {
  818. lRes = MAKELONG((WORD)nItem, 2);
  819. return true;
  820. }
  821. }
  822. }
  823. }
  824. }
  825. }
  826. }
  827. return false;
  828. }
  830. void CMenuSpawn::SetTextColor(const COLORREF crNormal, const COLORREF crSelected)
  831. {
  832. crMenuText = crNormal;
  833. crMenuTextSel = crSelected;
  834. }
  836. void CMenuSpawn::SetBackBitmap(const int iRes)
  837. {
  838. if (bmpBack.GetSafeHandle()) bmpBack.DeleteObject();
  839. bmpBack.LoadBitmap(iRes);
  840. bBackBitmap = true;
  841. }
  843. void CMenuSpawn::SetBackBitmap(const int iRes, COLORREF crBackColor)
  844. {
  845. if (bmpBack.GetSafeHandle()) bmpBack.DeleteObject();
  846. COLORMAP cMap1 = { crBackColor, cr3dFace };
  847. bmpBack.LoadMappedBitmap(iRes, 0, &cMap1, 1);
  848. bBackBitmap = true;
  849. }
  851. bool CMenuSpawn::GetMenuItemText(CString &csText, CMenu * pMenu, const int cmd, bool bByPos)
  852. {
  853. ASSERT(pMenu);
  855. UINT itemId = bByPos ? pMenu->GetMenuItemID(cmd) : cmd;
  856. if (itemId != 0)
  857. {
  858. MENUITEMINFO lpmi;
  859. ZeroMemory(&lpmi, sizeof(MENUITEMINFO));
  860. lpmi.cbSize = sizeof(MENUITEMINFO);
  861. lpmi.fMask = MIIM_DATA|MIIM_TYPE;
  862. ASSERT(pMenu->GetSafeHmenu());
  863. if (GetMenuItemInfo(pMenu->GetSafeHmenu(), cmd, bByPos, &lpmi))
  864. {
  865. if (lpmi.fType&MFT_OWNERDRAW)
  866. {
  867. SpawnItem * si = (SpawnItem *) lpmi.dwItemData;
  868. if (si)
  869. {
  870. csText = si->cText;
  871. return true;
  872. }
  873. }
  874. else
  875. {
  876. return pMenu->GetMenuString(cmd, csText, bByPos ? MF_BYPOSITION : MF_BYCOMMAND) > 0;
  877. }
  878. }
  879. }
  880. return false;
  881. }
  883. bool CMenuSpawn::IsSpawnMenu(CMenu * pMenu, const int iItem, const bool bByPos)
  884. {
  885. ASSERT(pMenu);
  887. UINT itemId = bByPos ? pMenu->GetMenuItemID(iItem) : iItem;
  888. if (itemId != 0)
  889. {
  890. MENUITEMINFO lpmi;
  891. ZeroMemory(&lpmi, sizeof(MENUITEMINFO));
  892. lpmi.cbSize = sizeof(MENUITEMINFO);
  893. lpmi.fMask = MIIM_DATA|MIIM_TYPE;
  894. ASSERT(pMenu->GetSafeHmenu());
  895. if (GetMenuItemInfo(pMenu->GetSafeHmenu(), iItem, bByPos, &lpmi))
  896. {
  897. if (lpmi.fType&MFT_OWNERDRAW)
  898. {
  899. SpawnItem * si = (SpawnItem *) lpmi.dwItemData;
  900. if (si) return true;
  901. }
  902. }
  903. }
  904. return false;
  905. }
  907. void CMenuSpawn::TransparentBlt(CDC * pDestDc, int x, int y, int w, int h, CBitmap * pBmp, int sx, int sy, COLORREF crTransparent)
  908. {
  909. CDC memDC, maskDC, tempDC;
  910. maskDC.CreateCompatibleDC(pDestDc);
  911. CBitmap maskBitmap;
  913. //add these to store return of SelectObject() calls
  914. CBitmap* pOldMemBmp = NULL;
  915. CBitmap* pOldMaskBmp = NULL;
  917. memDC.CreateCompatibleDC(pDestDc);
  918. tempDC.CreateCompatibleDC(pDestDc);
  919. CBitmap bmpImage;
  920. bmpImage.CreateCompatibleBitmap( pDestDc, w, h);
  921. pOldMemBmp = memDC.SelectObject( &bmpImage );
  923. CBitmap * oldBmp = tempDC.SelectObject(pBmp);
  925. memDC.BitBlt( 0,0,w, h, &tempDC, sx, sy, SRCCOPY );
  927. // Create monochrome bitmap for the mask
  928. maskBitmap.CreateBitmap(w, h, 1, 1, NULL);
  929. pOldMaskBmp = maskDC.SelectObject( &maskBitmap );
  930. memDC.SetBkColor(crTransparent);
  932. // Create the mask from the memory DC
  933. maskDC.BitBlt(0, 0, w, h, &memDC, 0, 0, SRCCOPY);
  935. memDC.SetBkColor(RGB(0,0,0));
  936. memDC.SetTextColor(RGB(255,255,255));
  937. memDC.BitBlt(0, 0, w, h, &maskDC, 0, 0, SRCAND);
  939. // Set the foreground to black. See comment above.
  940. pDestDc->SetBkColor(RGB(255,255,255));
  941. pDestDc->SetTextColor(RGB(0,0,0));
  942. pDestDc->BitBlt(x, y, w, h, &maskDC, 0, 0, SRCAND);
  944. // Combine the foreground with the background
  945. pDestDc->BitBlt(x, y, w, h, &memDC, 0, 0, SRCPAINT);
  947. tempDC.SelectObject(oldBmp);
  948. if (pOldMaskBmp) maskDC.SelectObject( pOldMaskBmp );
  949. if (pOldMemBmp)  memDC.SelectObject( pOldMemBmp );
  950. }