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

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

菜单

开发平台：

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. //////////////////////////////////////////////////////////////////////
  16. // Construction/Destruction
  17. //////////////////////////////////////////////////////////////////////
  19. CMenuSpawn::CMenuSpawn()
  20. {
  21. Init();
  22. }
  24. CMenuSpawn::CMenuSpawn(const bool _IsPopup)
  25. {
  26. Init();
  27. bIsPopup = _IsPopup;
  28. }
  30. CMenuSpawn::~CMenuSpawn()
  31. {
  32. if (iSpawnItem > 0)
  33. {
  34. for (int t = 0; t < iSpawnItem; t++)
  35. if (pSpawnItem[t]) delete pSpawnItem[t];
  37. GlobalFree((HGLOBAL) pSpawnItem);
  38. }
  39. if (iImageItem > 0)
  40. {
  41. GlobalFree((HGLOBAL) pImageItem);
  42. }
  43. if (hMenuFont) ::DeleteObject((HGDIOBJ)hMenuFont);
  44. // if (hGuiFont) ::DeleteObject((HGDIOBJ)hGuiFont);
  45. }
  47. void CMenuSpawn::TransparentBlt(CDC * pDestDc, int x, int y, int w, int h, CBitmap * pBmp, int sx, int sy, COLORREF crTransparent)
  48. {
  49. CDC memDC, maskDC, tempDC;
  50. maskDC.CreateCompatibleDC(pDestDc);
  51. CBitmap maskBitmap;
  53. //add these to store return of SelectObject() calls
  54. CBitmap* pOldMemBmp = NULL;
  55. CBitmap* pOldMaskBmp = NULL;
  57. memDC.CreateCompatibleDC(pDestDc);
  58. tempDC.CreateCompatibleDC(pDestDc);
  59. CBitmap bmpImage;
  60. bmpImage.CreateCompatibleBitmap( pDestDc, w, h);
  61. pOldMemBmp = memDC.SelectObject( &bmpImage );
  63. CBitmap * oldBmp = tempDC.SelectObject(pBmp);
  65. memDC.BitBlt( 0,0,w, h, &tempDC, sx, sy, SRCCOPY );
  67. // Create monochrome bitmap for the mask
  68. maskBitmap.CreateBitmap(w, h, 1, 1, NULL);
  69. pOldMaskBmp = maskDC.SelectObject( &maskBitmap );
  70. memDC.SetBkColor(crTransparent);
  72. // Create the mask from the memory DC
  73. maskDC.BitBlt(0, 0, w, h, &memDC, 0, 0, SRCCOPY);
  75. memDC.SetBkColor(RGB(0,0,0));
  76. memDC.SetTextColor(RGB(255,255,255));
  77. memDC.BitBlt(0, 0, w, h, &maskDC, 0, 0, SRCAND);
  79. // Set the foreground to black. See comment above.
  80. pDestDc->SetBkColor(RGB(255,255,255));
  81. pDestDc->SetTextColor(RGB(0,0,0));
  82. pDestDc->BitBlt(x, y, w, h, &maskDC, 0, 0, SRCAND);
  84. // Combine the foreground with the background
  85. pDestDc->BitBlt(x, y, w, h, &memDC, 0, 0, SRCPAINT);
  87. tempDC.SelectObject(oldBmp);
  88. if (pOldMaskBmp) maskDC.SelectObject( pOldMaskBmp );
  89. if (pOldMemBmp)  memDC.SelectObject( pOldMemBmp );
  90. }
  94. void CMenuSpawn::Init()
  95. {
  96. crMenuText = GetSysColor(COLOR_MENUTEXT);
  97. crMenuTextSel = GetSysColor(COLOR_HIGHLIGHTTEXT);
  99. cr3dFace = GetSysColor(COLOR_3DFACE);
  100. crMenu = GetSysColor(COLOR_MENU);
  101. crHighlight = GetSysColor(COLOR_HIGHLIGHT);
  102. cr3dHilight = GetSysColor(COLOR_3DHILIGHT);
  103. cr3dShadow = GetSysColor(COLOR_3DSHADOW);
  104. crGrayText = GetSysColor(COLOR_GRAYTEXT);
  106. m_clrBtnFace = GetSysColor(COLOR_BTNFACE);
  107. m_clrBtnHilight = GetSysColor(COLOR_BTNHILIGHT);
  108. m_clrBtnShadow = GetSysColor(COLOR_BTNSHADOW);
  110. iSpawnItem = 0;
  111. pSpawnItem = NULL;
  113. iImageItem = 0;
  114. pImageItem = NULL;
  116. szImage = CSize(20,20);
  118. hMenuFont = NULL;
  119. COLORMAP cMap[3] = { 
  120. { RGB(128,128,128), cr3dShadow }, 
  121. { RGB(192,192,192), cr3dFace }, 
  122. { RGB(255,255,255), cr3dHilight }
  123. };
  124. CBitmap bmp;
  125. bmp.LoadMappedBitmap(IDB_MENUCHK, 0, cMap, 3);
  126. ilOther.Create(19, 19, ILC_COLOR4|ILC_MASK, 1, 0);
  127. ilOther.Add(&bmp, cr3dFace);
  128. bmp.DeleteObject();
  130. NONCLIENTMETRICS ncm;
  131. memset(&ncm, 0, sizeof(ncm));
  132. ncm.cbSize = sizeof(ncm);
  134. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, (PVOID) &ncm, 0);
  136. hGuiFont = ::CreateFontIndirect(&ncm.lfMenuFont);
  138. bIsPopup = false;
  139. bBackBitmap = false;
  140. }
  142. bool CMenuSpawn::AddToolBarResource(unsigned int resId)
  143. {
  144. HRSRC hRsrc = ::FindResource(AfxGetResourceHandle(), MAKEINTRESOURCE(resId), RT_TOOLBAR);
  145. if (hRsrc == NULL) return false;
  147. HGLOBAL hGlb = ::LoadResource(AfxGetResourceHandle(), hRsrc);
  148. if (hGlb == NULL) return false;
  150. ToolBarData* pTBData = (ToolBarData*) ::LockResource(hGlb);
  151. if (pTBData == NULL) return false;
  153. ASSERT(pTBData->wVersion == 1);
  155. CBitmap bmp;
  156. bmp.LoadBitmap(resId);
  157. int nBmpItems = ilList.Add(&bmp, RGB(192,192,192));
  158. bmp.DeleteObject();
  160. WORD* pItem = (WORD*)(pTBData+1);
  162. for(int i=0; i<pTBData->wItemCount; i++, pItem++)
  163. {
  164. if(*pItem != ID_SEPARATOR)
  165. AddImageItem(nBmpItems++, (WORD) *pItem);
  166. }
  167. // ** it seem that Windows doesn't free these resource (from Heitor Tome)
  168.     ::UnlockResource(hGlb);
  169.     ::FreeResource(hGlb);
  170. // **
  171. return true;
  172. }
  174. bool CMenuSpawn::LoadToolBarResource(unsigned int resId)
  175. {
  176. HRSRC hRsrc = ::FindResource(AfxGetResourceHandle(), MAKEINTRESOURCE(resId), RT_TOOLBAR);
  177. if (hRsrc == NULL) return false;
  179. HGLOBAL hGlb = ::LoadResource(AfxGetResourceHandle(), hRsrc);
  180. if (hGlb == NULL) return false;
  182. ToolBarData* pTBData = (ToolBarData*) ::LockResource(hGlb);
  183. if (pTBData == NULL) return false;
  185. ASSERT(pTBData->wVersion == 1);
  187. szImage.cx = (int) pTBData->wWidth;
  188. szImage.cy = (int) pTBData->wHeight;
  190. if (ilList.Create(szImage.cx, szImage.cy, ILC_COLOR4|ILC_MASK, pTBData->wItemCount, 0) == false)
  191. return false;
  193. ilList.SetBkColor(cr3dFace);
  195. CBitmap bmp;
  196. bmp.LoadBitmap(resId);
  197. ilList.Add(&bmp, RGB(192,192,192));
  198. bmp.DeleteObject();
  200. WORD* pItem = (WORD*)(pTBData+1);
  201. int nBmpItems = 0;
  202. for(int i=0; i<pTBData->wItemCount; i++, pItem++)
  203. {
  204. if(*pItem != ID_SEPARATOR)
  205. AddImageItem(nBmpItems++, (WORD) *pItem);
  206. }
  207. // ** it seem that Windows doesn't free these resource (from Heitor Tome)
  208.     ::UnlockResource(hGlb);
  209.     ::FreeResource(hGlb);
  210. // **
  211. return true;
  212. }
  214. void CMenuSpawn::AddImageItem(const int idx, WORD cmd)
  215. {
  216. if (iImageItem == 0)
  217. pImageItem = (ImageItem *) GlobalAlloc(GPTR, sizeof(ImageItem));
  218. else
  219. pImageItem = (ImageItem *) GlobalReAlloc((HGLOBAL) pImageItem, sizeof(ImageItem) * (iImageItem + 1), GMEM_MOVEABLE|GMEM_ZEROINIT);
  221. ASSERT(pImageItem);
  222. pImageItem[iImageItem].iCmd = (int) cmd;
  223. pImageItem[iImageItem].iImageIdx = idx;
  224. iImageItem ++;
  225. }
  227. void CMenuSpawn::RemapMenu(CMenu * pMenu)
  228. {
  229. static int iRecurse = 0;
  230. iRecurse ++;
  232. ASSERT(pMenu);
  233. int nItem = pMenu->GetMenuItemCount();
  234. while ((--nItem)>=0)
  235. {
  236. UINT itemId = pMenu->GetMenuItemID(nItem);
  237. if (itemId == (UINT) -1)
  238. {
  239. CMenu *pops = pMenu->GetSubMenu(nItem);
  240. if (pops) RemapMenu(pops);
  241. if (bIsPopup || iRecurse > 0)
  242. {
  243. CString cs;
  244. pMenu->GetMenuString(nItem, cs, MF_BYPOSITION);
  245. if (cs != "")
  246. {
  247. SpawnItem * sp = AddSpawnItem(cs, (!bIsPopup && iRecurse == 1) ? -4 : -2);
  248. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW, (UINT) -1, (LPCTSTR)sp);
  249. }
  250. }
  251. }
  252. else
  253. {
  254. if (itemId != 0)
  255. {
  256. UINT oldState = pMenu->GetMenuState(nItem,MF_BYPOSITION);
  257. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  258. {
  259. ASSERT(oldState != (UINT)-1);
  260. CString cs;
  261. pMenu->GetMenuString(nItem, cs, MF_BYPOSITION);
  262. SpawnItem * sp = AddSpawnItem(cs, itemId);
  263. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  264. }
  265. }
  266. else
  267. {
  268. UINT oldState = pMenu->GetMenuState(nItem,MF_BYPOSITION);
  269. if (!(oldState&MF_OWNERDRAW) && !(oldState&MF_BITMAP))
  270. {
  271. ASSERT(oldState != (UINT)-1);
  272. SpawnItem * sp = AddSpawnItem("--", -3);
  273. pMenu->ModifyMenu(nItem,MF_BYPOSITION|MF_OWNERDRAW|oldState, (LPARAM)itemId, (LPCTSTR)sp);
  274. }
  275. }
  276. }
  277. }
  278. iRecurse --;
  279. }
  281. CMenuSpawn::SpawnItem * CMenuSpawn::AddSpawnItem(const char * txt, const int cmd)
  282. {
  283. if (iSpawnItem == 0)
  284. pSpawnItem = (SpawnItem **) GlobalAlloc(GPTR, sizeof(SpawnItem));
  285. else
  286. pSpawnItem = (SpawnItem **) GlobalReAlloc((HGLOBAL) pSpawnItem, sizeof(SpawnItem) * (iSpawnItem + 1), GMEM_MOVEABLE|GMEM_ZEROINIT);
  288. ASSERT(pSpawnItem);
  290. SpawnItem * p = new SpawnItem;
  291. ASSERT(p);
  292. pSpawnItem[iSpawnItem] = p;
  293. lstrcpy(p->cText, txt);
  294. p->iCmd = cmd;
  296. if (cmd >= 0) p->iImageIdx = FindImageItem(cmd);
  297. else p->iImageIdx = cmd;
  299. iSpawnItem ++;
  300. return p;
  301. }
  303. int CMenuSpawn::FindImageItem(const int cmd)
  304. {
  305. for (int t = 0; t < iImageItem; t++)
  306. if (pImageItem[t].iCmd == cmd) return pImageItem[t].iImageIdx;
  308. return -1;
  309. }
  311. bool CMenuSpawn::DrawItem(LPDRAWITEMSTRUCT lp)
  312. {
  313. bool res = false;
  314. if (lp->CtlType == ODT_MENU)
  315. {
  316. UINT id = lp->itemID;
  317. UINT state = lp->itemState;
  318. bool bEnab = !(state & ODS_DISABLED);
  319. bool bSelect = (state & ODS_SELECTED) ? true : false;
  320. bool bChecked = (state & ODS_CHECKED) ? true : false;
  322. SpawnItem * pItem = (SpawnItem *) lp->itemData;
  323. if (pItem)
  324. {
  325. CDC * pDC = CDC::FromHandle(lp->hDC);
  326. CFont * pft = CFont::FromHandle((HFONT) hMenuFont ? hMenuFont : hGuiFont);
  327. CFont * of = pDC->SelectObject(pft);
  328. CRect rc(lp->rcItem);
  329. CRect rcImage(rc), rcText(rc);
  330. rcImage.right = rcImage.left + rc.Height();
  331. rcImage.bottom = rc.bottom;
  333. if (bBackBitmap) 
  334. {
  335. CDC tempDC;
  336. tempDC.CreateCompatibleDC(pDC);
  337. tempDC.FillSolidRect(rc, crMenu);
  338. CBitmap * ob = tempDC.SelectObject(&bmpBack);
  339. pDC->FillSolidRect(rc, crMenu);
  340. pDC->BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), &tempDC, rc.left, rc.top, SRCCOPY );
  341. }
  343. if (pItem->iCmd == -3) // is a separator
  344. {
  345. CPen pnDk(PS_SOLID,1,cr3dShadow);
  346. CPen pnLt(PS_SOLID,1,cr3dHilight);
  347. CPen * opn = pDC->SelectObject(&pnDk);
  348. pDC->MoveTo(rc.left + 2, rc.top + 2);
  349. pDC->LineTo(rc.right - 2, rc.top + 2);
  350. pDC->SelectObject(&pnLt);
  351. pDC->MoveTo(rc.left + 2, rc.top + 3);
  352. pDC->LineTo(rc.right - 2, rc.top + 3);
  353. pDC->SelectObject(opn);
  354. }
  355. else if (pItem->iCmd == -4) // is a title item
  356. {
  357. CString cs(pItem->cText), cs1;
  358. CRect rcBdr(rcText);
  360. if (bSelect && bEnab)
  361. {
  362. rcText.top ++;
  363. rcText.left += 2;
  364. }
  365. pDC->FillSolidRect(rcText, crMenu);
  366. pDC->DrawText(cs, rcText, DT_VCENTER|DT_CENTER|DT_SINGLELINE);
  367. if (bSelect && bEnab) pDC->Draw3dRect(rcBdr,cr3dShadow,cr3dHilight);
  368. }
  369. else
  370. {
  371. rcText.left += rcImage.right + 1;
  373. int obk = pDC->SetBkMode(TRANSPARENT);
  375. COLORREF ocr;
  376. if (bSelect)
  377. {
  378. if (pItem->iImageIdx >= 0 || (state & ODS_CHECKED))
  379. pDC->FillSolidRect(rcText, crHighlight);
  380. else
  381. pDC->FillSolidRect(rc, crHighlight);
  383. ocr = pDC->SetTextColor(crMenuTextSel);
  384. }
  385. else
  386. {
  387. if (!bBackBitmap) 
  388. {
  389. if (pItem->iImageIdx >= 0 || (state & ODS_CHECKED))
  390. pDC->FillSolidRect(rcText, crMenu);
  391. else
  392. pDC->FillSolidRect(rc/*rcText*/, crMenu);
  393. }
  394. ocr = pDC->SetTextColor(crMenuText);
  395. }
  397. if (pItem->iImageIdx >= 0)
  398. {
  399. int ay = (rcImage.Height() - szImage.cy) / 2;
  400. int ax = (rcImage.Width()  - szImage.cx) / 2;
  402. if (bSelect && bEnab)
  403. pDC->Draw3dRect(rcImage,cr3dHilight,cr3dShadow);
  404. else
  405. {
  406. if (!bBackBitmap) pDC->Draw3dRect(rcImage,crMenu,crMenu);
  407. }
  410. if (bEnab)
  411. {
  412. ilList.Draw(pDC, pItem->iImageIdx, CPoint(rcImage.left + ax, rcImage.top +ay), ILD_NORMAL);
  413. }
  414. else
  415. {
  416. HICON hIcon = ilList.ExtractIcon( pItem->iImageIdx );
  417. pDC->DrawState( CPoint(rcImage.left + ax, rcImage.top + ay ), szImage, (HICON)hIcon, DST_ICON | DSS_DISABLED, (CBrush *)NULL );
  418. }
  419. }
  420. else
  421. {
  422. if (bChecked)
  423. {
  424. int ay = (rcImage.Height() - szImage.cy) / 2;
  425. int ax = (rcImage.Width()  - szImage.cx) / 2;
  427. ilOther.Draw(pDC, 0, CPoint(rcImage.left + ax, rcImage.top + ay - 2), ILD_NORMAL);
  428. }
  429. }
  431. CString cs(pItem->cText), cs1;
  432. CSize sz;
  433. sz = pDC->GetTextExtent(cs);
  434. int ay1 = (rcText.Height() - sz.cy) / 2;
  435. rcText.top += ay1;
  436. rcText.left += 2;
  437. rcText.right -= 15;
  439. int tf = cs.Find('t');
  440. if (tf >= 0)
  441. {
  442. cs1 = cs.Right(cs.GetLength() - tf - 1);
  443. cs = cs.Left(tf);
  444. if (!bEnab)
  445. {
  446. if (!bSelect)
  447. {
  448. CRect rcText1(rcText);
  449. rcText1.InflateRect(-1,-1);
  450. pDC->SetTextColor(cr3dHilight);
  451. pDC->DrawText(cs, rcText1, DT_VCENTER|DT_LEFT);
  452. pDC->DrawText(cs1, rcText1, DT_VCENTER|DT_RIGHT);
  453. pDC->SetTextColor(crGrayText);
  454. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  455. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  456. }
  457. else
  458. {
  459. pDC->SetTextColor(crMenu);
  460. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  461. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  462. }
  463. }
  464. else
  465. {
  466. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT);
  467. pDC->DrawText(cs1, rcText, DT_VCENTER|DT_RIGHT);
  468. }
  469. }
  470. else 
  471. {
  472. if (!bEnab)
  473. {
  474. if (!bSelect)
  475. {
  476. CRect rcText1(rcText);
  477. rcText1.InflateRect(-1,-1);
  478. pDC->SetTextColor(cr3dHilight);
  479. pDC->DrawText(cs, rcText1, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  480. pDC->SetTextColor(crGrayText);
  481. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  482. }
  483. else
  484. {
  485. pDC->SetTextColor(crMenu);
  486. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  487. }
  488. }
  489. else
  490. pDC->DrawText(cs, rcText, DT_VCENTER|DT_LEFT|DT_EXPANDTABS);
  491. }
  492. pDC->SetTextColor(ocr);
  493. pDC->SetBkMode(obk);
  494. }
  496. pDC->SelectObject(of);
  497. }
  498. res = true;
  499. }
  500. return res;
  501. }
  503. bool CMenuSpawn::MeasureItem(LPMEASUREITEMSTRUCT lpm)
  504. {
  505. bool res = false;
  506. if (lpm->CtlType == ODT_MENU)
  507. {
  508. UINT id = lpm->itemID;
  510. SpawnItem * pItem = (SpawnItem *) lpm->itemData;
  511. if (pItem)
  512. {
  513. if (pItem->iCmd == -3) // is a separator
  514. {
  515. lpm->itemWidth  = 10;
  516. lpm->itemHeight = 6;
  517. }
  518. else
  519. {
  520. CString cs(pItem->cText);
  521. if (cs != "")
  522. {
  523. CClientDC dc(AfxGetMainWnd());
  524. CFont * pft = CFont::FromHandle(hMenuFont ? hMenuFont : hGuiFont);
  525. CFont * of = dc.SelectObject(pft);
  526. CSize osz = dc.GetOutputTabbedTextExtent(cs,0,NULL);
  527. if (pItem->iCmd == -4)
  528. {
  529. CRect rci(0,0,0,0);
  530. dc.DrawText(cs, rci, DT_CALCRECT|DT_TOP|DT_VCENTER|DT_SINGLELINE);
  531. lpm->itemHeight = rci.Height();
  532. lpm->itemWidth = rci.Width();
  533. }
  534. else
  535. {
  536. lpm->itemHeight = szImage.cy + 5;
  537. if (osz.cy > (int) lpm->itemHeight) lpm->itemHeight = (int) osz.cy;
  538. lpm->itemWidth  = osz.cx + 2 + 15;
  539. lpm->itemWidth += lpm->itemHeight > (UINT) szImage.cx ? (UINT) lpm->itemHeight : (UINT) szImage.cx;
  540. }
  541. dc.SelectObject(of);
  542. }
  543. else
  544. {
  545. lpm->itemHeight = szImage.cy + 5;
  546. lpm->itemWidth  = 100;
  547. }
  548. }
  549. }
  550. res = true;
  551. }
  552. return res;
  553. }
  555. void CMenuSpawn::EnableMenuItems(CMenu * pMenu, CWnd * pParent)
  556. {
  557. ASSERT(pMenu);
  558. ASSERT(pParent);
  560. int nItem = pMenu->GetMenuItemCount();
  561. CCmdUI state;
  562. state.m_pMenu = pMenu;
  563. state.m_nIndex = nItem-1;
  564. state.m_nIndexMax = nItem;
  566. while ((--nItem)>=0)
  567. {
  568. UINT itemId = pMenu->GetMenuItemID(nItem);
  569. if (itemId == (UINT) -1)
  570. {
  571. CMenu *pops = pMenu->GetSubMenu(nItem);
  572. if (pops) EnableMenuItems(pops, pParent);
  573. }
  574. else
  575. {
  576. if (itemId != 0)
  577. {
  578. state.m_nID = itemId;
  579. pParent->OnCmdMsg(itemId, CN_UPDATE_COMMAND_UI, &state, NULL);
  580. state.DoUpdate(pParent, true);
  581. }
  582. }
  583. state.m_nIndex = nItem-1;
  584. }
  585. }
  588. bool CMenuSpawn::SetFont(LOGFONT * lf)
  589. {
  590. ASSERT(lf);
  591. if (hMenuFont) ::DeleteObject((HGDIOBJ)hMenuFont);
  592. hMenuFont = CreateFontIndirect(lf);
  593. return hMenuFont != NULL ? true : false;
  594. }
  596. bool CMenuSpawn::FindKeyboardShortcut(UINT nChar, UINT nFlags, CMenu * pMenu, LRESULT & lRes)
  597. {
  598. ASSERT(pMenu);
  599. int nItem = pMenu->GetMenuItemCount();
  600. CString csChar((CHAR) nChar);
  601. csChar.MakeLower();
  602. while ((--nItem)>=0)
  603. {
  604. UINT itemId = pMenu->GetMenuItemID(nItem);
  605. if (itemId != 0)
  606. {
  607. MENUITEMINFO lpmi;
  608. ZeroMemory(&lpmi, sizeof(MENUITEMINFO));
  609. lpmi.cbSize = sizeof(MENUITEMINFO);
  610. lpmi.fMask = MIIM_DATA|MIIM_TYPE;
  611. ASSERT(pMenu->GetSafeHmenu());
  612. if (GetMenuItemInfo(pMenu->GetSafeHmenu(), nItem, TRUE, &lpmi))
  613. {
  614. if (lpmi.fType&MFT_OWNERDRAW)
  615. {
  616. SpawnItem * si = (SpawnItem *) lpmi.dwItemData;
  617. if (si)
  618. {
  619. CString csItem(si->cText);
  620. csItem.MakeLower();
  621. int iAmperIdx = csItem.Find('&');
  622. if (iAmperIdx >= 0)
  623. {
  624. csItem = csItem.Mid(iAmperIdx + 1, 1);
  625. if (csItem == csChar)
  626. {
  627. lRes = MAKELONG((WORD)nItem, 2);
  628. return true;
  629. }
  630. }
  631. }
  632. }
  633. }
  634. }
  635. }
  636. return false;
  637. }
  639. void CMenuSpawn::SetTextColor(const COLORREF crNormal, const COLORREF crSelected)
  640. {
  641. crMenuText = crNormal;
  642. crMenuTextSel = crSelected;
  643. }
  645. void CMenuSpawn::SetBackBitmap(const int iRes)
  646. {
  647. if (bmpBack.GetSafeHandle()) bmpBack.DeleteObject();
  648. bmpBack.LoadBitmap(iRes);
  649. bBackBitmap = true;
  650. }
  652. void CMenuSpawn::SetBackBitmap(const int iRes, COLORREF crBackColor)
  653. {
  654. if (bmpBack.GetSafeHandle()) bmpBack.DeleteObject();
  655. COLORMAP cMap1 = { crBackColor, cr3dFace };
  656. bmpBack.LoadMappedBitmap(iRes, 0, &cMap1, 1);
  657. bBackBitmap = true;
  658. }
  660. bool CMenuSpawn::GetMenuItemText(CString &csText, CMenu * pMenu, const int cmd, bool bByPos)
  661. {
  662. ASSERT(pMenu);
  664. UINT itemId = bByPos ? pMenu->GetMenuItemID(cmd) : cmd;
  665. if (itemId != 0)
  666. {
  667. MENUITEMINFO lpmi;
  668. ZeroMemory(&lpmi, sizeof(MENUITEMINFO));
  669. lpmi.cbSize = sizeof(MENUITEMINFO);
  670. lpmi.fMask = MIIM_DATA|MIIM_TYPE;
  671. ASSERT(pMenu->GetSafeHmenu());
  672. if (GetMenuItemInfo(pMenu->GetSafeHmenu(), cmd, bByPos, &lpmi))
  673. {
  674. if (lpmi.fType&MFT_OWNERDRAW)
  675. {
  676. SpawnItem * si = (SpawnItem *) lpmi.dwItemData;
  677. if (si)
  678. {
  679. csText = si->cText;
  680. return true;
  681. }
  682. }
  683. else
  684. {
  685. return pMenu->GetMenuString(cmd, csText, bByPos ? MF_BYPOSITION : MF_BYCOMMAND) > 0;
  686. }
  687. }
  688. }
  689. return false;
  690. }
  692. bool CMenuSpawn::IsSpawnMenu(CMenu * pMenu, const int iItem, const bool bByPos)
  693. {
  694. ASSERT(pMenu);
  696. UINT itemId = bByPos ? pMenu->GetMenuItemID(iItem) : iItem;
  697. if (itemId != 0)
  698. {
  699. MENUITEMINFO lpmi;
  700. ZeroMemory(&lpmi, sizeof(MENUITEMINFO));
  701. lpmi.cbSize = sizeof(MENUITEMINFO);
  702. lpmi.fMask = MIIM_DATA|MIIM_TYPE;
  703. ASSERT(pMenu->GetSafeHmenu());
  704. if (GetMenuItemInfo(pMenu->GetSafeHmenu(), iItem, bByPos, &lpmi))
  705. {
  706. if (lpmi.fType&MFT_OWNERDRAW)
  707. {
  708. SpawnItem * si = (SpawnItem *) lpmi.dwItemData;
  709. if (si) return true;
  710. }
  711. }
  712. }
  713. return false;
  714. }