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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
GfxPopupMenu.cpp
资源名称：一个类似QQ的软件源码.rar　[点击查看]
上传用户：zslianheng
上传日期：2013-04-03
资源大小：946k
文件大小：19k
源码类别：

Linux/Unix编程

开发平台：

Visual C++

GfxPopupMenu.cpp：源码内容
  1. // GfxPopupMenu.cpp: implementation of the CGfxPopupMenu class.
  2. //
  3. // Modified a lot by Zhang Yong
  4. //////////////////////////////////////////////////////////////////////
  6. #include "stdafx.h"
  8. #include "GfxPopupMenu.h"
  10. #ifdef _DEBUG
  11. #undef THIS_FILE
  12. static char THIS_FILE[]=__FILE__;
  13. #define new DEBUG_NEW
  14. #endif
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////
  20. CGfxPopupMenu::CGfxPopupMenu()
  21. {
  22. crMenuText = GetSysColor(COLOR_MENUTEXT);
  23. crMenuTextSel = GetSysColor(COLOR_HIGHLIGHTTEXT);
  25. cr3dFace = GetSysColor(COLOR_3DFACE);
  26. crMenu = GetSysColor(COLOR_MENU);
  27. crHighlight = GetSysColor(COLOR_HIGHLIGHT);
  28. cr3dHilight = GetSysColor(COLOR_3DHILIGHT);
  29. cr3dShadow = GetSysColor(COLOR_3DSHADOW);
  30. crGrayText = GetSysColor(COLOR_GRAYTEXT);
  32. m_clrBtnFace = GetSysColor(COLOR_BTNFACE);
  33. m_clrBtnHilight = GetSysColor(COLOR_BTNHILIGHT);
  34. m_clrBtnShadow = GetSysColor(COLOR_BTNSHADOW);
  36. iSpawnItem = 0;
  37. pSpawnItem = NULL;
  39. iImageItem = 0;
  40. pImageItem = NULL;
  42. hMenuFont = NULL;
  43. /* COLORMAP cMap[3] = { 
  44. { RGB(128,128,128), cr3dShadow }, 
  45. { RGB(192,192,192), cr3dFace }, 
  46. { RGB(255,255,255), cr3dHilight }
  47. };
  48. CBitmap bmp;
  49. bmp.LoadMappedBitmap(IDB_MENUCHK, 0, cMap, 3);
  50. ilOther.Create(19, 19, ILC_COLOR4|ILC_MASK, 1, 0);
  51. ilOther.Add(&bmp, cr3dFace);
  52. bmp.DeleteObject();
  53. */
  54. NONCLIENTMETRICS ncm;
  55. memset(&ncm, 0, sizeof(ncm));
  56. ncm.cbSize = sizeof(ncm);
  58. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, (PVOID) &ncm, 0);
  60. hGuiFont = ::CreateFontIndirect(&ncm.lfMenuFont);
  62. // David 08/04/98 - start - bold font handling
  63. hMenuBoldFont = NULL;
  64. CreateBoldFont();
  65. // David 08/04/98 - end - bold font handling
  67. ilList.Create(16, 16, ILC_MASK | ILC_COLOR8, 5, 15);
  68. szImage = CSize(16, 16);
  70. // @@
  71. vertDrawn = FALSE;
  72. }
  74. CGfxPopupMenu::~CGfxPopupMenu()
  75. {
  76. if (iSpawnItem > 0)
  77. {
  78. for (int t = 0; t < iSpawnItem; t++)
  79. if (pSpawnItem[t]) delete pSpawnItem[t];
  81. GlobalFree((HGLOBAL) pSpawnItem);
  82. }
  83. if (iImageItem > 0)
  84. {
  85. GlobalFree((HGLOBAL) pImageItem);
  86. }
  87. if (hMenuFont) ::DeleteObject((HGDIOBJ)hMenuFont);
  88. if (hMenuBoldFont) ::DeleteObject((HGDIOBJ)hMenuBoldFont);
  89. }
  91. void CGfxPopupMenu::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  92. {
  93. // CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  94. // CRect rcItem(lpDrawItemStruct->rcItem);
  95. // pDC->FillSolidRect(rcItem, RGB(255,0,0));
  96. if (lpDrawItemStruct->CtlType == ODT_MENU)
  97. {
  98. UINT id = lpDrawItemStruct->itemID;
  99. UINT state = lpDrawItemStruct->itemState;
  100. bool bEnab = !(state & ODS_DISABLED);
  101. bool bSelect = (state & ODS_SELECTED) ? true : false;
  102. bool bChecked = (state & ODS_CHECKED) ? true : false;
  103. // David 08/04/98 - start - bold font handling
  104. bool bBold = (state & ODS_DEFAULT) ? true : false;
  105. // David 08/04/98 - end - bold font handling
  107. SpawnItem * pItem = (SpawnItem *) lpDrawItemStruct->itemData;
  108. if (pItem)
  109. {
  110. CDC * pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  111. CFont * pft;
  112. // David 08/04/98 - start - bold font handling
  113. if (!bBold) pft = CFont::FromHandle((HFONT) hMenuFont ? hMenuFont : hGuiFont);
  114. else pft = CFont::FromHandle((HFONT) hMenuBoldFont ? hMenuBoldFont : hGuiFont);
  115. // David 08/04/98 - end - bold font handling
  116. CFont * of = pDC->SelectObject(pft);
  118. CRect rc(lpDrawItemStruct->rcItem);
  120. // @@
  121. if (bmVert.m_hObject) {
  122. BITMAP bm;
  123. bmVert.GetBitmap(&bm);
  124. if ((lpDrawItemStruct->itemAction & ODA_DRAWENTIRE) && !vertDrawn) {
  125. vertDrawn = TRUE;
  127. CDC dcMem;
  128. dcMem.CreateCompatibleDC(pDC);
  129. CBitmap *bmOld = dcMem.SelectObject(&bmVert);
  130. pDC->SelectClipRgn(NULL);
  131. CRect rcWhole;
  132. pDC->GetClipBox(rcWhole);
  133. pDC->BitBlt(0, 0, bm.bmWidth, bm.bmHeight, &dcMem,
  134. 0, bm.bmHeight - rcWhole.Height(), SRCCOPY);
  135. }
  136. rc.left += bm.bmWidth;
  137. }
  139. CRect rcImage(rc), rcText(rc);
  140. rcImage.right = rcImage.left + rc.Height();
  141. rcImage.bottom = rc.bottom;
  143. if (pItem->iCmd == -3) // is a separator
  144. {
  145. CPen pnDk(PS_SOLID,1,cr3dShadow);
  146. CPen pnLt(PS_SOLID,1,cr3dHilight);
  147. CPen * opn = pDC->SelectObject(&pnDk);
  148. pDC->MoveTo(rc.left + 2, rc.top + 2);
  149. pDC->LineTo(rc.right - 2, rc.top + 2);
  150. pDC->SelectObject(&pnLt);
  151. pDC->MoveTo(rc.left + 2, rc.top + 3);
  152. pDC->LineTo(rc.right - 2, rc.top + 3);
  153. pDC->SelectObject(opn);
  154. }
  155. /* else if (pItem->iCmd == -4) // is a title item
  156. {
  157. CString cs(pItem->cText), cs1;
  158. CRect rcBdr(rcText);
  160. if (bSelect && bEnab)
  161. {
  162. rcText.top ++;
  163. rcText.left += 2;
  164. }
  165. pDC->FillSolidRect(rcText, crMenu);
  166. pDC->DrawText(cs, rcText, DT_VCENTER|DT_CENTER|DT_SINGLELINE);
  167. if (bSelect && bEnab) pDC->Draw3dRect(rcBdr,cr3dShadow,cr3dHilight);
  168. }*/
  169. else
  170. {
  171. rcText.left = rcImage.right + 1;
  173. int obk = pDC->SetBkMode(TRANSPARENT);
  175. COLORREF ocr;
  176. if (bSelect)
  177. {
  178. if (pItem->iImageIdx >= 0 || (state & ODS_CHECKED))
  179. //pDC->FillSolidRect(rcText, crHighlight);
  180. pDC->Draw3dRect(rcText, cr3dShadow, cr3dHilight); // @@
  181. else
  182. //pDC->FillSolidRect(rc, crHighlight);
  183. pDC->Draw3dRect(rc, cr3dShadow, cr3dHilight); // @@
  185. //ocr = pDC->SetTextColor(crMenuTextSel);
  186. ocr = pDC->SetTextColor(crHighlight); // @@
  187. }
  188. else
  189. {
  190. if (pItem->iImageIdx >= 0 || (state & ODS_CHECKED))
  191. pDC->FillSolidRect(rcText, crMenu);
  192. else
  193. pDC->FillSolidRect(rc/*rcText*/, crMenu);
  194. ocr = pDC->SetTextColor(crMenuText);
  195. }
  197. if (pItem->iImageIdx >= 0)
  198. {
  199. int ay = (rcImage.Height() - szImage.cy) / 2;
  200. int ax = (rcImage.Width()  - szImage.cx) / 2;
  202. if (bSelect && bEnab)
  203. pDC->Draw3dRect(rcImage,cr3dHilight,cr3dShadow);
  204. else
  205. {
  206. pDC->Draw3dRect(rcImage,crMenu,crMenu);
  207. }
  210. if (bEnab)
  211. {
  212. ilList.Draw(pDC, pItem->iImageIdx, CPoint(rcImage.left + ax, rcImage.top +ay), ILD_NORMAL);
  213. }
  214. else
  215. {
  216. HICON hIcon = ilList.ExtractIcon( pItem->iImageIdx );
  217. pDC->DrawState( CPoint(rcImage.left + ax, rcImage.top + ay ), szImage, (HICON)hIcon, DST_ICON | DSS_DISABLED, (CBrush *)NULL );
  218. }
  219. }
  220. else
  221. {
  222. if (bChecked)
  223. {
  224. int ay = (rcImage.Height() - szImage.cy) / 2;
  225. int ax = (rcImage.Width()  - szImage.cx) / 2;
  227. ilOther.Draw(pDC, 0, CPoint(rcImage.left + ax, rcImage.top + ay - 2), ILD_NORMAL);
  228. }
  229. }
  231. CString cs(pItem->cText), cs1;
  232. if (cs.Compare("dummy") == 0)
  233. pItem = pItem;
  235. CSize sz;
  236. sz = pDC->GetTextExtent(cs);
  237. int ay1 = (rcText.Height() - sz.cy) / 2;
  238. rcText.top += ay1;
  239. rcText.left += 2;
  240. rcText.right -= 15;
  242. int tf = cs.Find('t');
  243. if (tf >= 0)
  244. {
  245. cs1 = cs.Right(cs.GetLength() - tf - 1);
  246. cs = cs.Left(tf);
  247. if (!bEnab)
  248. {
  249. if (!bSelect)
  250. {
  251. CRect rcText1(rcText);
  252. rcText1.InflateRect(-1,-1);
  253. pDC->SetTextColor(cr3dHilight);
  254. pDC->DrawText(cs, rcText1, DT_VCENTER|DT_LEFT);
  255. pDC->DrawText(cs1, rcText1, DT_VCENTER|DT_RIGHT);
  256. pDC->SetTextColor(crGrayText);
  257. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  258. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  259. }
  260. else
  261. {
  262. pDC->SetTextColor(crMenu);
  263. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  264. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  265. }
  266. }
  267. else
  268. {
  269. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  270. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  271. }
  272. }
  273. else 
  274. {
  275. if (!bEnab)
  276. {
  277. // if (!bSelect) // @@
  278. {
  279. CRect rcText1(rcText);
  280. rcText1.InflateRect(-1,-1);
  281. pDC->SetTextColor(cr3dHilight);
  282. pDC->DrawText(cs, rcText1, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  283. pDC->SetTextColor(crGrayText);
  284. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  285. }
  286. /* else
  287. {
  288. pDC->SetTextColor(crMenu);
  289. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  290. }*/
  291. }
  292. else
  293. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  294. }
  295. pDC->SetTextColor(ocr);
  296. pDC->SetBkMode(obk);
  297. }
  299. pDC->SelectObject(of);
  300. }
  301. }
  302. }
  304. void CGfxPopupMenu::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  305. {
  306. // lpMeasureItemStruct->itemWidth = 200;
  307. // lpMeasureItemStruct->itemHeight = 25;
  308. bool res = false;
  309. if (lpMeasureItemStruct->CtlType == ODT_MENU)
  310. {
  311. UINT id = lpMeasureItemStruct->itemID;
  313. SpawnItem * pItem = (SpawnItem *) lpMeasureItemStruct->itemData;
  314. if (pItem)
  315. {
  316. if (pItem->iCmd == -3) // is a separator
  317. {
  318. lpMeasureItemStruct->itemWidth  = 10;
  319. lpMeasureItemStruct->itemHeight = 6;
  320. }
  321. else
  322. {
  323. CString cs(pItem->cText);
  324. if (!cs.IsEmpty())
  325. {
  326. CClientDC dc(AfxGetMainWnd());
  327. CFont * pft = CFont::FromHandle(hMenuFont ? hMenuFont : hGuiFont);
  328. CFont * of = dc.SelectObject(pft);
  329. CSize osz = dc.GetOutputTabbedTextExtent(cs,0,NULL);
  330. // @@
  331. /*if (pItem->iCmd == -4)
  332. {
  333. CRect rci(0,0,0,0);
  334. dc.DrawText(cs, rci, DT_CALCRECT|DT_TOP|DT_VCENTER|DT_SINGLELINE);
  335. lpMeasureItemStruct->itemHeight = rci.Height();
  336. lpMeasureItemStruct->itemWidth = rci.Width();
  337. }
  338. else*/
  339. {
  340. lpMeasureItemStruct->itemHeight = szImage.cy + 5;
  341. if (osz.cy > (int) lpMeasureItemStruct->itemHeight) lpMeasureItemStruct->itemHeight = (int) osz.cy;
  342. lpMeasureItemStruct->itemWidth  = osz.cx + 2 + 15;
  343. lpMeasureItemStruct->itemWidth += lpMeasureItemStruct->itemHeight > (UINT) szImage.cx ? (UINT) lpMeasureItemStruct->itemHeight : (UINT) szImage.cx;
  344. }
  345. dc.SelectObject(of);
  346. }
  347. else
  348. {
  349. lpMeasureItemStruct->itemHeight = szImage.cy + 5;
  350. lpMeasureItemStruct->itemWidth  = 100;
  351. }
  352. }
  353. if (bmVert.m_hObject) {
  354. BITMAP bm;
  355. bmVert.GetBitmap(&bm);
  356. lpMeasureItemStruct->itemWidth += bm.bmWidth;
  357. }
  358. }
  359. }
  360. }
  362. bool CGfxPopupMenu::CreateBoldFont()
  363. {
  364. if (hMenuBoldFont) 
  365. ::DeleteObject((HGDIOBJ)hMenuBoldFont);
  367. LOGFONT lgFont;
  368. ::GetObject (hMenuFont ? hMenuFont : hGuiFont, sizeof (lgFont), &lgFont);
  369. lgFont.lfWeight = FW_BOLD;
  371. hMenuBoldFont = CreateFontIndirect (&lgFont);
  372. return !!hMenuBoldFont;
  373. }
  375. bool CGfxPopupMenu::AddToolBarResource(unsigned int resId)
  376. {
  377. // David 08/04/98 - start - put CMenuSpawn in DLL
  378. HINSTANCE hInst = AfxFindResourceHandle (MAKEINTRESOURCE(resId), RT_TOOLBAR);
  379. if (!hInst)
  380. return false;
  381. // David 08/04/98 - end - put CMenuSpawn in DLL
  383. HRSRC hRsrc = ::FindResource(/*AfxGetResourceHandle()*/hInst, MAKEINTRESOURCE(resId), RT_TOOLBAR);
  384. if (hRsrc == NULL) return false;
  386. HGLOBAL hGlb = ::LoadResource(/*AfxGetResourceHandle()*/hInst, hRsrc);
  387. if (hGlb == NULL) return false;
  390. ToolBarData* pTBData = (ToolBarData*) ::LockResource(hGlb);
  391. if (pTBData == NULL) return false;
  393. ASSERT(pTBData->wVersion == 1);
  395. CBitmap bmp;
  396. bmp.LoadBitmap(resId);
  397. int nBmpItems = ilList.Add(&bmp, RGB(192,192,192));
  398. bmp.DeleteObject();
  400. WORD* pItem = (WORD*)(pTBData+1);
  402. for(int i=0; i<pTBData->wItemCount; i++, pItem++)
  403. {
  404. if(*pItem != ID_SEPARATOR)
  405. AddImageItem(nBmpItems++, (WORD) *pItem);
  406. }
  407. // ** it seem that Windows doesn't free these resource (from Heitor Tome)
  408.     ::UnlockResource(hGlb);
  409.     ::FreeResource(hGlb);
  410. // **
  411. return true;
  412. }
  414. bool CGfxPopupMenu::LoadToolBarResource(unsigned int resId)
  415. {
  416. //David 08/04/98 - start - put CMenuSpawn in DLL
  417. HINSTANCE hInst = AfxFindResourceHandle (MAKEINTRESOURCE(resId), RT_TOOLBAR);
  418. if (!hInst)
  419. return false;
  420. //David 08/04/98 - end - put CMenuSpawn in DLL
  422. HRSRC hRsrc = ::FindResource(/*AfxGetResourceHandle()*/hInst, MAKEINTRESOURCE(resId), RT_TOOLBAR);
  423. if (hRsrc == NULL) return false;
  425. HGLOBAL hGlb = ::LoadResource(/*AfxGetResourceHandle()*/hInst, hRsrc);
  426. if (hGlb == NULL) return false;
  428. ToolBarData* pTBData = (ToolBarData*) ::LockResource(hGlb);
  429. if (pTBData == NULL) return false;
  431. ASSERT(pTBData->wVersion == 1);
  433. szImage.cx = (int) pTBData->wWidth;
  434. szImage.cy = (int) pTBData->wHeight;
  436. if (ilList.Create(szImage.cx, szImage.cy, ILC_COLOR4|ILC_MASK, pTBData->wItemCount, 0) == false)
  437. return false;
  439. ilList.SetBkColor(cr3dFace);
  441. CBitmap bmp;
  442. bmp.LoadBitmap(resId);
  443. ilList.Add(&bmp, RGB(192,192,192));
  444. bmp.DeleteObject();
  446. WORD* pItem = (WORD*)(pTBData+1);
  447. int nBmpItems = 0;
  448. for(int i=0; i<pTBData->wItemCount; i++, pItem++)
  449. {
  450. if(*pItem != ID_SEPARATOR)
  451. AddImageItem(nBmpItems++, (WORD) *pItem);
  452. }
  453. // ** it seem that Windows doesn't free these resource (from Heitor Tome)
  454.     ::UnlockResource(hGlb);
  455.     ::FreeResource(hGlb);
  456. // **
  457. return true;
  458. }
  460. void CGfxPopupMenu::AddImageItem(const int idx, WORD cmd)
  461. {
  462. if (iImageItem == 0)
  463. pImageItem = (ImageItem *) GlobalAlloc(GPTR, sizeof(ImageItem));
  464. else
  465. pImageItem = (ImageItem *) GlobalReAlloc((HGLOBAL) pImageItem, sizeof(ImageItem) * (iImageItem + 1), GMEM_MOVEABLE|GMEM_ZEROINIT);
  467. ASSERT(pImageItem);
  468. pImageItem[iImageItem].iCmd = (int) cmd;
  469. pImageItem[iImageItem].iImageIdx = idx;
  470. iImageItem ++;
  471. }
  473. void CGfxPopupMenu::RemapMenu(CMenu * pMenu)
  474. {
  475. static int iRecurse = 0;
  476. iRecurse ++;
  478. ASSERT(pMenu);
  479. int nItem = pMenu->GetMenuItemCount();
  480. while ((--nItem)>=0)
  481. {
  482. UINT itemId = pMenu->GetMenuItemID(nItem);
  483. if (itemId == (UINT) -1)
  484. {
  485. CMenu *pops = pMenu->GetSubMenu(nItem);
  486. if (pops)
  487. RemapMenu(pops);
  488. if (iRecurse > 0)
  489. {
  490. CString cs;
  491. pMenu->GetMenuString(nItem, cs, MF_BYPOSITION);
  492. if (cs != "")
  493. {
  494. SpawnItem * sp = AddSpawnItem(cs, (iRecurse == 1) ? -4 : -2);
  495. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW, (UINT) -1, (LPCTSTR)sp);
  496. }
  497. }
  498. }
  499. else
  500. {
  501. if (itemId != 0)
  502. {
  503. UINT oldState = pMenu->GetMenuState(nItem,MF_BYPOSITION);
  504. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  505. {
  506. ASSERT(oldState != (UINT)-1);
  507. CString cs;
  508. pMenu->GetMenuString(nItem, cs, MF_BYPOSITION);
  509. SpawnItem * sp = AddSpawnItem(cs, itemId);
  510. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  511. }
  512. }
  513. else
  514. {
  515. UINT oldState = pMenu->GetMenuState(nItem,MF_BYPOSITION);
  516. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  517. {
  518. ASSERT(oldState != (UINT)-1);
  519. SpawnItem * sp = AddSpawnItem("--", -3);
  520. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  521. }
  522. }
  523. }
  524. }
  525. iRecurse --;
  526. }
  528. CGfxPopupMenu::SpawnItem * CGfxPopupMenu::AddSpawnItem(const char * txt, const int cmd)
  529. {
  530. if (iSpawnItem == 0)
  531. pSpawnItem = (SpawnItem **) GlobalAlloc(GPTR, sizeof(SpawnItem));
  532. else
  533. pSpawnItem = (SpawnItem **) GlobalReAlloc((HGLOBAL) pSpawnItem, sizeof(SpawnItem) * (iSpawnItem + 1), GMEM_MOVEABLE|GMEM_ZEROINIT);
  535. ASSERT(pSpawnItem);
  537. SpawnItem * p = new SpawnItem;
  538. ASSERT(p);
  539. pSpawnItem[iSpawnItem] = p;
  540. lstrcpy(p->cText, txt);
  541. p->iCmd = cmd;
  543. if (cmd >= 0) p->iImageIdx = FindImageItem(cmd);
  544. else p->iImageIdx = cmd;
  546. iSpawnItem ++;
  547. return p;
  548. }
  550. int CGfxPopupMenu::FindImageItem(const int cmd)
  551. {
  552. for (int t = 0; t < iImageItem; t++)
  553. if (pImageItem[t].iCmd == cmd) return pImageItem[t].iImageIdx;
  555. return -1;
  556. }
  558. void CGfxPopupMenu::EnableMenuItems(CMenu * pMenu, CWnd * pParent)
  559. {
  560. ASSERT(pMenu);
  561. ASSERT(pParent);
  563. int nItem = pMenu->GetMenuItemCount();
  564. CCmdUI state;
  565. state.m_pMenu = pMenu;
  566. state.m_nIndex = nItem-1;
  567. state.m_nIndexMax = nItem;
  569. while ((--nItem)>=0)
  570. {
  571. UINT itemId = pMenu->GetMenuItemID(nItem);
  572. if (itemId == (UINT) -1)
  573. {
  574. CMenu *pops = pMenu->GetSubMenu(nItem);
  575. if (pops) EnableMenuItems(pops, pParent);
  576. }
  577. else
  578. {
  579. if (itemId != 0)
  580. {
  581. state.m_nID = itemId;
  582. pParent->OnCmdMsg(itemId, CN_UPDATE_COMMAND_UI, &state, NULL);
  583. state.DoUpdate(pParent, true);
  584. }
  585. }
  586. state.m_nIndex = nItem-1;
  587. }
  588. }
  590. void CGfxPopupMenu::modifyMenu(UINT itemId, UINT bitmap, BOOL byCmd)
  591. {
  592. int index;
  593. if (!imageHash.Lookup(bitmap, index)) {
  594. CBitmap bm;
  595. bm.LoadBitmap(bitmap);
  596. index = ilList.Add(&bm, RGB(192, 192, 192));
  597. imageHash.SetAt(bitmap, index);
  598. }
  599. modifyMenuInternal(itemId, index, byCmd);
  600. }
  602. void CGfxPopupMenu::modifyMenu(UINT itemId, HICON icon)
  603. {
  604. int index;
  605. if (!bitmapHash.Lookup(icon, index)) {
  606. index = ilList.Add(icon);
  607. bitmapHash.SetAt(icon, index);
  608. }
  609. modifyMenuInternal(itemId, index, TRUE);
  610. }
  612. void CGfxPopupMenu::modifyMenuInternal(UINT itemId, int imageIndex, BOOL byCmd)
  613. {
  614. if (byCmd) {
  615. UINT oldState = GetMenuState(itemId,MF_BYCOMMAND);
  616. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  617. {
  618. ASSERT(oldState != (UINT)-1);
  619. CString cs;
  620. GetMenuString(itemId, cs, MF_BYCOMMAND);
  621. SpawnItem * sp = AddSpawnItem(cs, itemId);
  622. sp->iImageIdx = imageIndex;
  623. ModifyMenu(itemId,MF_BYCOMMAND|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  624. }
  625. } else {
  626. UINT nItem = itemId;
  627. itemId = GetMenuItemID(nItem);
  629. if (itemId == (UINT) -1)
  630. {
  631. CString cs;
  632. GetMenuString(nItem, cs, MF_BYPOSITION);
  633. if (cs != "")
  634. {
  635. SpawnItem * sp = AddSpawnItem(cs, -4);
  636. sp->iImageIdx = imageIndex;
  637. ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW, (UINT) -1, (LPCTSTR)sp);
  638. }
  639. }
  640. else
  641. {
  642. if (itemId != 0)
  643. {
  644. UINT oldState = GetMenuState(nItem,MF_BYPOSITION);
  645. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  646. {
  647. ASSERT(oldState != (UINT)-1);
  648. CString cs;
  649. GetMenuString(nItem, cs, MF_BYPOSITION);
  650. SpawnItem * sp = AddSpawnItem(cs, itemId);
  651. sp->iImageIdx = imageIndex;
  652. ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  653. }
  654. }
  655. else
  656. {
  657. UINT oldState = GetMenuState(nItem,MF_BYPOSITION);
  658. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  659. {
  660. ASSERT(oldState != (UINT)-1);
  661. SpawnItem * sp = AddSpawnItem("--", -3);
  662. ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  663. }
  664. }
  665. }
  666. }
  667. }
  669. void CGfxPopupMenu::appendMenu(UINT id, UINT bitmap, LPCTSTR str)
  670. {
  671. AppendMenu(MF_BYCOMMAND, id, str);
  672. modifyMenu(id, bitmap);
  673. }
  675. void CGfxPopupMenu::appendMenu(UINT id, UINT bitmap, UINT strID)
  676. {
  677. CString str;
  678. str.LoadString(strID);
  679. appendMenu(id, bitmap, str);
  680. }
  682. void CGfxPopupMenu::setVertBitmap(UINT bitmap)
  683. {
  684. for (int i = GetMenuItemCount() - 1; i >= 0; i--) {
  685. if (GetMenuItemID(i) == 0) {
  686. SpawnItem * sp = AddSpawnItem("--", -3);
  687. ModifyMenu(i, MF_BYPOSITION | MF_OWNERDRAW | MF_SEPARATOR, 0, (LPCTSTR) sp);
  688. }
  689. }
  691. bmVert.LoadBitmap(bitmap);
  692. }