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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
CBmpMenu.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：35k
源码类别：

游戏

开发平台：

Visual C++

CBmpMenu.cpp：源码内容
  1. //********************************************************
  2. //                                                            
  3. // FILENAME : CBmpMenu.cpp
  4. // CONTENTS : Defines the class behaviors for the CBmpMenu class.
  5. //
  6. //  Copyright (c), 1999-2000.   
  7. // All rights reserved   
  8. //                                                        
  9. //  Author(s):  Dipti Deogade
  10. //                                                        
  11. //*********************************************************
  13. //** REVISION LIST ****************************************
  14. //     
  15. // Number Date Author Description
  16. //
  17. //
  18. //*********************************************************
  20. #include "stdafx.h"
  21. #include "CBmpMenu.h"
  23. #ifdef _DEBUG
  24. #define new DEBUG_NEW
  25. #undef THIS_FILE
  26. static char THIS_FILE[] = __FILE__;
  27. #endif
  29. /////////////////////////////////////////////////////////////////////////////
  30. // CBmpMenu
  31. // constructor
  33. CBmpMenu::CBmpMenu(int nBitmapW, BOOL bShowBmp4SubMenu, HBITMAP hBitmap, BOOL bStretchBmp)
  34. {
  35. //check if hbitmap is a valid handle
  36. BITMAP bitmap;
  37. if(GetObject(hBitmap, sizeof(bitmap), &bitmap))
  38. {
  39. m_hBitmap   = hBitmap;
  40. }
  41. else
  42. {
  43. m_hBitmap = NULL;
  44. }
  46. //initialize internal data
  47. m_bShowBmpAll = bShowBmp4SubMenu;
  48. m_pOwnerWnd = m_pToolbar = 0;
  49. m_bSubMenu = FALSE;
  50. m_pSubMenuWnd = 0;
  51. m_bStretchBmp = bStretchBmp;
  52. m_nTBOffSet = nBitmapW;
  53. }
  55. CBmpMenu::~CBmpMenu()
  56. {
  57. }
  59. IMPLEMENT_DYNAMIC( CBmpMenu, CWnd )
  61. BEGIN_MESSAGE_MAP(CBmpMenu, CWnd)
  62. //{{AFX_MSG_MAP(CBmpMenu)
  63. ON_WM_PAINT()
  64. //}}AFX_MSG_MAP
  65. END_MESSAGE_MAP()
  68. /////////////////////////////////////////////////////////////////////////////
  69. // CBmpMenu message handlers
  71. BOOL
  72. CBmpMenu :: Attach( HMENU hMenu )
  73. {
  74. return CMenu::Attach(hMenu);
  75. }
  77. HMENU
  78. CBmpMenu :: Detach()
  79. {
  80. return CMenu::Detach();
  81. }
  84. BOOL CBmpMenu::DestroyWindow() 
  85. {
  86. //Send WM_EXITMENULOOP to the owner window
  87. m_pOwnerWnd->SendMessage(WM_EXITMENULOOP, FALSE);
  89. //destroy the current window and set focus to parent if parent is of the same class
  90. if(::IsWindow(GetParent()->GetSafeHwnd()) && 
  91. GetParent()->IsKindOf(RUNTIME_CLASS(CBmpMenu)))
  92. {
  93. GetParent()->SetFocus();
  94. }
  96. return CWnd::DestroyWindow();
  97. }
  99. BOOL
  100. CBmpMenu :: TrackPopupMenu( UINT nFlags, int x, int y, CWnd* pParentWnd, CRect* pItemRect)
  101. {
  102. //if this is a main menu, then parent window is same as owner window
  103. if(!m_bSubMenu)
  104. {
  105. m_pOwnerWnd = pParentWnd;
  106. }
  108. //Send menu messages to owner window
  109. if(m_pOwnerWnd && IsWindow(m_pOwnerWnd->m_hWnd))
  110. m_pOwnerWnd->SendMessage(m_bSubMenu?WM_INITMENUPOPUP:WM_INITMENU, (WPARAM)m_hMenu, 0);
  111. else
  112. return FALSE;
  114. //create the main window...child of this will be a toolbar which acts as a kind of menu
  115. if(!CreateEx(WS_EX_DLGMODALFRAME|WS_EX_PALETTEWINDOW|WS_EX_CONTROLPARENT
  116. , 0, 0, WS_POPUP|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_BORDER|WS_CHILD, 
  117. CRect(0,0,0,0), pParentWnd, 0))
  118. return FALSE;
  120. //set the data of parent popup menu
  121. if(m_bSubMenu)
  122. {
  123. ((CBmpMenu*)GetParent())->m_pSubMenuWnd = this;
  124. }
  126. //create toolbar
  127. m_pToolbar = new MenuToolBar;
  129. //We add a custom draw toolbar which will act as a menu
  130. m_pToolbar->CreateEx(this, TBSTYLE_FLAT|TBSTYLE_LIST|TBSTYLE_CUSTOMERASE|TBSTYLE_WRAPABLE,
  131. WS_CLIPCHILDREN|CCS_NODIVIDER|CCS_NORESIZE|CCS_NOPARENTALIGN|CBRS_TOOLTIPS);
  133. //Initialize toolbar data and place the menu window on screen
  134. InitToolBarData(m_pToolbar, CPoint(x,y), pItemRect);
  136. //show the menu window without activating it....before that make the owner window as foreground window
  137. if(!m_bSubMenu)
  138. {
  139. m_pOwnerWnd->SetForegroundWindow();
  140. }
  142. ShowWindow(SW_SHOWNA);
  144. //capture keyboard input
  145. SetFocus();
  147. //if this is a submenu and user had opened it by pressing right arrow key
  148. if(m_bSubMenu & MENU_SELECTFIRSTITEM)
  149. {
  150. m_pToolbar->SendMessage(TB_SETHOTITEM, 0, 0);
  151. }
  153. m_bSubMenu &= ~MENU_SELECTFIRSTITEM;
  155. //send a notification message to owner
  156. if(m_pOwnerWnd && IsWindow(m_pOwnerWnd->m_hWnd))
  157. m_pOwnerWnd->SendMessage(WM_ENTERMENULOOP, (WPARAM)m_hMenu, (LPARAM)m_hWnd);
  159. //run the modal loop so that the menu window acts as a kind of dialog
  160. RunModalLoop();
  162. //delete allocated memory and cleanup other stuff
  163. Cleanup();
  165. return TRUE;
  166. }
  167. //wp gives a point on which left mouse button was clicked for the parent menu
  168. void CBmpMenu::PopupSubMenu(WPARAM wp, BOOL bSelectFirstItem)
  169. {
  170. CPoint point(LOWORD(wp), HIWORD(wp));
  172. //Get the button on which left mouse button was clicked
  173. int nBtnIndex = (m_pToolbar->GetToolBarCtrl()).HitTest(&point);
  174. TBBUTTON tbb;
  175. (m_pToolbar->GetToolBarCtrl()).GetButton(nBtnIndex, &tbb);
  177. //Get window rectangle of this button
  178. CRect rect;
  179. (m_pToolbar->GetToolBarCtrl()).GetItemRect(nBtnIndex, &rect);
  180. (m_pToolbar->GetToolBarCtrl()).ClientToScreen(&rect);
  182. //Construct popup menu
  183. CBmpMenu oSubMenu(m_bShowBmpAll?m_nTBOffSet:0, m_bShowBmpAll, m_bShowBmpAll?m_hBitmap:0, m_bStretchBmp);
  185. //intialize data of popup menu
  186. oSubMenu.m_pOwnerWnd = m_pOwnerWnd;
  188. //When user created an instance of CBmpMenu, automatically a handle was associated with root menu
  189. //when he called loadMenu or CreatePopupMenu. But we are not doing any of it for submenus..so just attach
  190. //the menu handle of the submenu to this submenu window
  192. oSubMenu.Attach(((MENUITEMINFO*)(tbb.dwData))->hSubMenu);
  194. //Set data to indicate whther first item should be set as a hot item
  195. oSubMenu.m_bSubMenu = TRUE | bSelectFirstItem;
  197. //Add the blank space with to get bounds rect of this button in root menu
  198. rect.left -= m_nTBOffSet;
  200. //Show the submenu window
  201. oSubMenu.TrackPopupMenu(0, 0, 0, this, &rect);
  203. //detach the menu handle
  204. oSubMenu.Detach();
  205. }
  207. void CBmpMenu::InitToolBarData(CToolBar *pToolBar, CPoint pt, CRect* pItemRect)
  208. {
  209. //enable tooltips
  210. pToolBar->EnableToolTips(TRUE);
  212. //set toolbar buutons bitmap size first. This should be equal to checkmark dimensions
  213. //button size will be automatically calculated by toolbar
  214. pToolBar->SendMessage(TB_SETBITMAPSIZE, 0, MAKELPARAM(GetSystemMetrics(SM_CXMENUCHECK), GetSystemMetrics(SM_CYMENUCHECK)));
  216. //for each menu item...add corrsponding buttons to the toolbar
  217. for(int i=0; i<(int)GetMenuItemCount(); i++)
  218. {
  219. MENUITEMINFO menuInfo, *pMenuInfo;
  220. TBBUTTON buttonInfo;
  221. char *pszBuffer;
  223. //initialize
  224. menuInfo.cbSize = sizeof(menuInfo);
  225. menuInfo.fMask = MIIM_CHECKMARKS|MIIM_DATA|MIIM_ID|MIIM_STATE|MIIM_SUBMENU|MIIM_TYPE;
  226. pszBuffer = new char[MAX_PATH]; //buffer for button text
  227. menuInfo.cch = MAX_PATH;
  228. menuInfo.dwTypeData = pszBuffer;
  229. ZeroMemory(&buttonInfo, sizeof(buttonInfo));
  231. GetMenuItemInfo(i, &menuInfo, TRUE);
  233. if(menuInfo.dwTypeData == 0)
  234. delete pszBuffer;
  236. //store the app defined data pointer
  237. pMenuInfo = new MENUITEMINFO;
  238. *pMenuInfo = menuInfo;
  239. buttonInfo.dwData = (ULONG)pMenuInfo;
  241. //set button info from menuInfo...default state is enabled
  242. buttonInfo.fsState = TBSTATE_ENABLED|TBSTATE_WRAP;
  244. //check if its a separator
  245. if(menuInfo.fType & MFT_SEPARATOR)
  246. {
  247. buttonInfo.fsStyle = TBSTYLE_SEP;
  248. }
  250. //check if the menu item is disabled or grayed
  251. if((menuInfo.fState & MF_GRAYED) || (MF_DISABLED & menuInfo.fState))
  252. buttonInfo.fsState = 0;
  254. //set button command id
  255. buttonInfo.idCommand = menuInfo.wID;
  257. //add the button
  258. (pToolBar->GetToolBarCtrl()).AddButtons(1, &buttonInfo);
  260. //Set button text
  261. if(menuInfo.dwTypeData)
  262. {
  263. pToolBar->SetButtonText(i, pszBuffer);
  264. }
  265. }
  267. //Get the button width and add width of arrow mark to be drawn for popup menus
  268. int nWidth = LOWORD(pToolBar->GetToolBarCtrl().GetButtonSize());
  269. nWidth += GetSystemMetrics(SM_CXMENUCHECK);
  270. //add width for showing arrows for submenus
  271. pToolBar->GetToolBarCtrl().SetButtonWidth(nWidth, nWidth);
  273. //set the toolbar button size
  274. CRect rect1, rect2;
  276. (pToolBar->GetToolBarCtrl()).GetItemRect(0, &rect1);
  277. //if all the buttons have dropdown arrow...the toolbar returns extra height equal to one row
  278. (pToolBar->GetToolBarCtrl()).GetItemRect(GetMenuItemCount()-1, &rect2);
  280. //set the total toolbar size
  281. //offset of 3 pixels to either side of the toolbar
  282. //If another control(bitmap or slider) is to be placed by the side of toolbar then we have to take 
  283. //into account the width of that control=m_nTBOffSet
  284. //Also we need to check that this window rect lies in the screen rect
  285. PositionMenuWindow(pt, pItemRect, CRect(0, 0, rect1.Width()+6+m_nTBOffSet, rect2.bottom-rect1.top+6));
  287. //place the toolbar window in the menu window
  288. pToolBar->MoveWindow(m_nTBOffSet, 0, rect1.Width()+6, rect2.bottom-rect1.top+6);
  290. //Show the toolbar window without activating it
  291. pToolBar->ShowWindow(SW_SHOWNOACTIVATE);
  292. }
  295. LRESULT CBmpMenu::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  296. {
  297. // TODO: Add your specialized code here and/or call the base class
  298. CWnd* pWnd = 0;
  299. BOOL bFlag = FALSE;
  301. switch(message)
  302. {
  303. case WM_ACTIVATE:
  304. {
  305. //Close all menu windows, if another window is being activated because of a mouse click outside menu window
  306. CWnd oWnd;
  307. if(lParam && IsWindow(HWND(lParam)) && (LOWORD(wParam) == WA_INACTIVE))
  308. if(!oWnd.FromHandle(HWND(lParam))->IsKindOf(RUNTIME_CLASS(CBmpMenu)))
  309. DestroyRootMenu();
  311. if(!lParam)
  312. DestroyRootMenu();
  314. return 0L;
  315. }
  316. break;
  318. case WM_SYSKEYDOWN:
  319. //destroy root menu when alt or any syskey is pressed
  320. DestroyRootMenu();
  321. break;
  323. case WM_KEYDOWN:
  324. //pass the keydown event to toolbar
  325. //If a submenu is being shown for this menu, then key down should be handled by submenu window
  326. //else pass it to toolbar
  327. if(m_pSubMenuWnd)
  328. m_pSubMenuWnd->SendMessage(WM_KEYDOWN, wParam, lParam);
  329. else
  330. m_pToolbar->SendMessage(WM_KEYDOWN, wParam, lParam);
  331. return 0L;
  333. case WM_RESETDATA:
  334. //User defined message to be sent to toolbar to reinitialize internal data
  335. m_pToolbar->SendMessage(WM_RESETDATA, 0, 0);
  336. return 0L;
  338. case WM_COMMAND:
  339. //pass on control specific messages(if any) to owner window
  340. m_pOwnerWnd->PostMessage(WM_COMMAND, wParam, lParam);
  341. return 0L;
  343. case WM_POPUPSUBMENU:
  344. //popup the submenu
  345. PopupSubMenu(wParam, lParam);
  346. return 0L;
  347. }
  349. return CWnd::DefWindowProc(message, wParam, lParam);
  350. }
  352. //destroys all menu window
  353. void CBmpMenu::DestroyRootMenu()
  354. {
  355. if(m_hWnd && IsWindow(m_hWnd))
  356. {
  357. CWnd *pParent = GetParent();
  359. if(pParent && IsWindow(pParent->m_hWnd))
  360. {
  361. if(pParent->IsKindOf(RUNTIME_CLASS(CBmpMenu)))
  362. ((CBmpMenu*)pParent)->DestroyRootMenu();
  363. }
  365. if(m_hWnd && IsWindow(m_hWnd))
  366. {
  367. DestroySubMenus();
  369. //end the modal loop started using RunModalLoop in TrackPopupMenu function
  370. EndModalLoop(0);
  372. m_pSubMenuWnd = 0;
  373. }
  374. }
  375. }
  377. //destroy all the submenu window associated with this menu
  378. void CBmpMenu::DestroySubMenus()
  379. {
  380. if(m_pSubMenuWnd)
  381. {
  382. m_pSubMenuWnd->DestroySubMenus();
  384. //end the modal loop started using RunModalLoop in TrackPopupMenu function
  385. m_pSubMenuWnd->EndModalLoop(0);
  387. m_pSubMenuWnd = 0;
  388. }
  389. }
  391. void CBmpMenu::Cleanup()
  392. {
  393. //remove all allocated memory
  394. if(m_pToolbar && IsWindow(m_pToolbar->m_hWnd))
  395. {
  396. for(int i = 0; i<(m_pToolbar->GetToolBarCtrl()).GetButtonCount(); i++)
  397. {
  398. TBBUTTON tbb;
  399. (m_pToolbar->GetToolBarCtrl()).GetButton(i, &tbb);
  400. if(tbb.dwData)
  401. {
  402. if(((MENUITEMINFO*)(tbb.dwData))->dwTypeData)
  403. delete (char*)(((MENUITEMINFO*)(tbb.dwData))->dwTypeData);
  404. delete (MENUITEMINFO*)(tbb.dwData);
  405. tbb.dwData = 0;
  406. }
  407. }
  409. //destroy our windows
  410. m_pToolbar->DestroyWindow();
  411. delete m_pToolbar;
  412. m_pToolbar = 0;
  413. }
  415. if(IsWindow(m_hWnd))
  416. DestroyWindow();
  417. }
  419. BOOL CBmpMenu::PreCreateWindow(CREATESTRUCT& cs) 
  420. {
  421. // TODO: Add your specialized code here and/or call the base class
  423. BOOL bRet = CWnd::PreCreateWindow(cs);
  425. WNDCLASS wc; 
  427. ::GetClassInfo(AfxGetInstanceHandle(), cs.lpszClass, &wc);
  429. //register new class with same info but different class
  430. wc.lpszClassName = cs.lpszClass = "BitmapMenu";
  432. AfxRegisterClass(&wc);
  434. return bRet;
  435. }
  438. void CBmpMenu::OnPaint() 
  439. {
  440. CPaintDC dc(this); // device context for painting
  442. CRect rect;
  443. GetClientRect(&rect);
  445. //Fill the blank space with whiteness
  446. dc.FillSolidRect(&rect, GetSysColor(COLOR_BTNHIGHLIGHT));
  448. //draw the vertical bitmap if required
  449. if(m_hBitmap)
  450. {
  451. CDC memDC;
  452. memDC.CreateCompatibleDC(&dc);
  453. HBITMAP hOldBmp = (HBITMAP)SelectObject(memDC.GetSafeHdc(), m_hBitmap);
  455. BITMAP bitmap;
  456. GetObject(m_hBitmap, sizeof(bitmap), &bitmap);
  458. //draw the bitmap
  459. if(m_bStretchBmp)
  460. dc.StretchBlt(0, 0, m_nTBOffSet, rect.Height(), &memDC, 0, 0, bitmap.bmWidth, bitmap.bmHeight, 
  461. SRCCOPY);
  462. else
  463. {
  464. //draw using pattern brush
  465. HBRUSH hPatternBr = CreatePatternBrush(m_hBitmap);
  466. RECT rect1={0, 0, m_nTBOffSet, rect.Height()};
  467. FillRect(dc.GetSafeHdc(), &rect1, hPatternBr);
  468. DeleteObject(hPatternBr);
  469. }
  471. //restore objects
  472. memDC.SelectObject(hOldBmp);
  473. memDC.DeleteDC();
  474. }
  475. }
  477. //Used to place the menu window
  478. void CBmpMenu::PositionMenuWindow(CPoint pt, CRect* pItemRect, CRect menuRect)
  479. {
  480. CRect deskRect;
  482. GetDesktopWindow()->GetWindowRect(&deskRect);
  484. //Check if this is a submenu...then we need to check either right top or right bottom point of menuRect
  485. if(pItemRect)
  486. {
  487. if(PositionSubMenu(CPoint(pItemRect->right, pItemRect->top), menuRect, TRUE, TRUE) == FALSE)
  488. {
  489. if(PositionSubMenu(CPoint(pItemRect->right, pItemRect->bottom), menuRect, TRUE, FALSE) == FALSE)
  490. {
  491. if(PositionSubMenu(CPoint(pItemRect->left, pItemRect->top), menuRect, FALSE, TRUE) == FALSE)
  492. {
  493. PositionSubMenu(CPoint(pItemRect->left, pItemRect->bottom), menuRect, FALSE, FALSE);
  494. }
  495. }
  496. }
  497. return;
  498. }
  500. //we need to check which position is best for showing menu
  501. //check for left top alignment with pt
  502. if((pt.x+menuRect.Width() < deskRect.right) &&
  503. (pt.y+menuRect.Height() < deskRect.bottom))
  504. {
  505. MoveWindow(pt.x, pt.y, menuRect.Width(), menuRect.Height());
  506. }
  507. else //right top
  508. if((pt.x-menuRect.Width() > deskRect.left) && 
  509. (pt.y+menuRect.Height() < deskRect.bottom))
  510. {
  511. MoveWindow(pt.x-menuRect.Width(), pt.y, menuRect.Width(), menuRect.Height());
  512. }
  513. else
  514. //check for left bottom alignment with pt
  515. if((pt.x+menuRect.Width() < deskRect.right) && 
  516. (pt.y-menuRect.Height() > deskRect.top))
  517. {
  518. MoveWindow(pt.x, pt.y-menuRect.Height(), menuRect.Width(), menuRect.Height());
  519. }
  520. else
  521. //check for right bottom alignment with pt
  522. if((pt.x-menuRect.Width() > deskRect.left) && 
  523. (pt.y-menuRect.Height() > deskRect.top))
  524. {
  525. MoveWindow(pt.x-menuRect.Width(), pt.y-menuRect.Height(), menuRect.Width(), menuRect.Height());
  526. }
  527. else //left top is default
  528. MoveWindow(pt.x, pt.y, menuRect.Width(), menuRect.Height());
  529. }
  531. BOOL
  532. CBmpMenu::PositionSubMenu(CPoint pt, CRect menuRect, BOOL bRtAlign, BOOL bDnAlign)
  533. {
  534. CRect deskRect;
  536. GetDesktopWindow()->GetWindowRect(&deskRect);
  538. if(bRtAlign && bDnAlign)
  539. {
  540. if((pt.x+menuRect.Width() < deskRect.right) &&
  541. (pt.y+menuRect.Height() < deskRect.bottom))
  542. {
  543. MoveWindow(pt.x, pt.y, menuRect.Width(), menuRect.Height());
  544. }
  545. else
  546. {
  547. return FALSE;
  548. }
  549. }
  551. if(bRtAlign && ! bDnAlign)
  552. {
  553. if((pt.x+menuRect.Width() < deskRect.right) && 
  554. (pt.y-menuRect.Height() > deskRect.top))
  555. {
  556. MoveWindow(pt.x, pt.y-menuRect.Height(), menuRect.Width(), menuRect.Height());
  557. }
  558. else
  559. {
  560. return FALSE;
  561. }
  562. }
  564. if(!bRtAlign && bDnAlign)
  565. {
  566. if((pt.x-menuRect.Width() > deskRect.left) && 
  567. (pt.y+menuRect.Height() < deskRect.bottom))
  568. {
  569. MoveWindow(pt.x-menuRect.Width(), pt.y, menuRect.Width(), menuRect.Height());
  570. }
  571. else
  572. {
  573. return FALSE;
  574. }
  575. }
  577. if(!bRtAlign && !bDnAlign)
  578. {
  579. if((pt.x-menuRect.Width() > deskRect.left) && 
  580. (pt.y-menuRect.Height() > deskRect.top))
  581. {
  582. MoveWindow(pt.x-menuRect.Width(), pt.y-menuRect.Height(), menuRect.Width(), menuRect.Height());
  583. }
  584. else
  585. {
  586. return FALSE;
  587. }
  588. }
  589. return TRUE;
  590. }
  592. /////////////////////////////////////////////////////////////////////////////
  593. // MenuToolBar
  595. MenuToolBar::MenuToolBar()
  596. {
  597. m_nLastLBDownIndex = -1;
  598. m_nLastHoverIndex  = -1;
  599. m_oHoverPt.x = -1;
  600. m_oHoverPt.y = -1;
  601. m_nSelectedItem = -1;
  602. }
  604. MenuToolBar::~MenuToolBar()
  605. {
  606. m_oMenuFont.DeleteObject();
  607. }
  610. BEGIN_MESSAGE_MAP(MenuToolBar, CToolBar)
  611. //{{AFX_MSG_MAP(MenuToolBar)
  612. ON_WM_CREATE()
  613. ON_WM_LBUTTONDOWN()
  614. ON_WM_KEYDOWN()
  615. ON_NOTIFY_REFLECT(NM_CUSTOMDRAW , OnCustomDrawNotify)
  616. ON_WM_MOUSEMOVE()
  617. ON_WM_CHAR()
  618. //}}AFX_MSG_MAP
  619. ON_MESSAGE(WM_LBUTTONDOWNAFTER, OnPostLbuttonMsg)
  620. END_MESSAGE_MAP()
  622. /////////////////////////////////////////////////////////////////////////////
  623. // MenuToolBar message handlers
  625. void MenuToolBar::OnCustomDrawNotify(LPARAM lParam, LRESULT* pResult )
  626. {
  627. LPNMTBCUSTOMDRAW lpNMCustomDraw = (LPNMTBCUSTOMDRAW) lParam;
  629. if(!lParam)
  630. return;
  632. if(lpNMCustomDraw->nmcd.dwDrawStage == CDDS_PREPAINT)
  633. {
  634. *pResult = CDRF_NOTIFYITEMDRAW ; //we need CDDS_ITEMPREPAINT notifications
  635. return;
  636. }
  638. if(lpNMCustomDraw->nmcd.dwDrawStage == CDDS_ITEMPREPAINT)
  639. {
  640. MENUITEMINFO menuInfo = *(MENUITEMINFO*)(lpNMCustomDraw->nmcd.lItemlParam);
  641. CRect rcItem = lpNMCustomDraw->nmcd.rc;
  642. CDC dc;
  643. CFont* pOldFont;
  644. dc.Attach(lpNMCustomDraw->nmcd.hdc);
  646. //Check if this is a hot item
  647. if(lpNMCustomDraw->nmcd.uItemState & CDIS_HOT)
  648. {
  649. lpNMCustomDraw->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
  650. lpNMCustomDraw->clrHighlightHotTrack = GetSysColor(COLOR_HIGHLIGHT);
  652. //check if last hot item was same as this hot item. If not then we need to send notification
  653. //to owner window
  654. if(m_nSelectedItem != (int)lpNMCustomDraw->nmcd.dwItemSpec)
  655. {
  656. int ndx = lpNMCustomDraw->nmcd.dwItemSpec;
  658. //for submenus we need to send index of this item rather than Command Id
  659. if(menuInfo.hSubMenu)
  660. {
  661. ndx = CommandToIndex(lpNMCustomDraw->nmcd.dwItemSpec);
  662. menuInfo.fState = MF_POPUP;
  663. }
  665. //Send WM_MENUSELECT notification message to owner window
  666. ((CBmpMenu*)GetParent())->m_pOwnerWnd->SendMessage(WM_MENUSELECT, 
  667. MAKEWPARAM(ndx, menuInfo.fState), 
  668. (LPARAM)((CBmpMenu*)GetParent())->m_hMenu);
  670. }
  671. //store th hot item index
  672. m_nSelectedItem = lpNMCustomDraw->nmcd.dwItemSpec;
  673. }
  674. else
  675. {
  676. lpNMCustomDraw->clrText = GetSysColor(COLOR_MENUTEXT);
  677. lpNMCustomDraw->clrHighlightHotTrack = GetSysColor(COLOR_MENU);
  678. }
  680. if(menuInfo.fState & MF_GRAYED)
  681. {
  682. lpNMCustomDraw->clrText = GetSysColor(COLOR_GRAYTEXT);
  683. //this is required for checkmark color
  684. dc.SetTextColor(GetSysColor(COLOR_GRAYTEXT));
  685. }
  686. else
  687. dc.SetTextColor(GetSysColor(COLOR_MENUTEXT));
  689. //leave a one pixel gap
  690. rcItem.left++;
  692. //draw the background rectangle first
  693. dc.FillSolidRect(rcItem, lpNMCustomDraw->clrHighlightHotTrack);
  695. //Select menu font
  696. pOldFont = dc.SelectObject(&m_oMenuFont);
  698. //check if we need to draw the checkmark for this menu item
  699. if(menuInfo.fState & MF_CHECKED)
  700. {
  701. CRect CheckRect = rcItem;
  702. CheckRect.right = CheckRect.left + CheckRect.Height();
  703. //draw the checkmarked image
  704. Draw3DCheckmark(dc, CheckRect, lpNMCustomDraw->nmcd.uItemState & CDIS_HOT, 
  705. menuInfo.hbmpChecked, TRUE, menuInfo.fState & MF_GRAYED);
  706. }
  707. else
  708. {
  709. //if unchecked bmp is provided
  710. if(menuInfo.hbmpUnchecked)
  711. {
  712. CRect CheckRect = rcItem;
  713. CheckRect.right = CheckRect.left + CheckRect.Height();
  714. //draw the UnCheckmarked image
  715. Draw3DCheckmark(dc, CheckRect, lpNMCustomDraw->nmcd.uItemState & CDIS_HOT, 
  716. menuInfo.hbmpUnchecked, FALSE, menuInfo.fState & MF_GRAYED);
  717. }
  718. }
  720. //draw the background rectangle for this button and then draw menu text
  721. dc.SetTextColor(lpNMCustomDraw->clrText);
  722. dc.SetBkMode(TRANSPARENT);
  724. //calculate text rectangle. The width of Checkmark has to be added
  725. rcItem.left += rcItem.Height() + 2;
  727. //Check if the item is disabled or grayed. Then we need to draw embossed text
  728. if((menuInfo.fState & MF_GRAYED) && !(lpNMCustomDraw->nmcd.uItemState & CDIS_HOT))
  729. {
  730. rcItem.OffsetRect(1,1);
  731. dc.SetTextColor(GetSysColor(COLOR_3DHILIGHT));
  732. dc.DrawText(menuInfo.dwTypeData, rcItem, DT_SINGLELINE|DT_LEFT|DT_VCENTER);
  733. dc.SetTextColor(lpNMCustomDraw->clrText);
  734. rcItem.OffsetRect(-1,-1);
  735. }
  737. //draw the text
  738. dc.DrawText(menuInfo.dwTypeData, rcItem, DT_SINGLELINE|DT_LEFT|DT_VCENTER);
  739. dc.SelectObject(pOldFont);
  741. //draw the popup arrow mark
  742. if(menuInfo.hSubMenu)
  743. {
  744. rcItem.left = rcItem.right-GetSystemMetrics(SM_CXMENUCHECK)*3/4;
  745. rcItem.right = rcItem.left + GetSystemMetrics(SM_CXMENUCHECK);
  746. CRect arrowRect = rcItem;
  747. arrowRect.top += (rcItem.Height()-GetSystemMetrics(SM_CXMENUCHECK))/2;
  748. arrowRect.bottom = arrowRect.top + GetSystemMetrics(SM_CXMENUCHECK);
  750. arrowRect.right -= GetSystemMetrics(SM_CXMENUCHECK)*3/10;
  751. arrowRect.left += GetSystemMetrics(SM_CXMENUCHECK)*3/10;
  752. arrowRect.top += GetSystemMetrics(SM_CXMENUCHECK)*3/10;
  753. arrowRect.bottom -= GetSystemMetrics(SM_CXMENUCHECK)*3/10;
  755. POINT points[3];
  756. points[0].x = arrowRect.left;
  757. points[0].y = arrowRect.top;
  758. points[1].x = arrowRect.left+arrowRect.Width()/2;
  759. points[1].y = arrowRect.top+arrowRect.Height()/2;
  760. points[2].x = points[0].x;
  761. points[2].y = points[1].y + arrowRect.Height()/2;
  763. CPen oPen(PS_SOLID, 1, lpNMCustomDraw->clrText), *pOldPen;
  764. pOldPen=dc.SelectObject(&oPen);
  766. dc.MoveTo(points[0]);
  767. dc.LineTo(points[1]);
  768. dc.LineTo(points[2]);
  769. dc.LineTo(points[0]);
  771. dc.SelectObject(pOldPen);
  773. CBrush oBrush(lpNMCustomDraw->clrText), *pOldBrush;
  774. pOldBrush = dc.SelectObject(&oBrush);
  775. dc.FloodFill(points[0].x +1, points[0].y +2, lpNMCustomDraw->clrText);
  776. dc.SelectObject(pOldBrush);
  777. }
  779. //detach DC
  780. dc.Detach();
  781. *pResult = CDRF_SKIPDEFAULT;
  782. }
  783. else
  784. *pResult = 0;
  786. }
  788. //////////////////
  789. // Draw 3D checkmark
  790. BOOL MenuToolBar::Draw3DCheckmark(CDC& dc, CRect rc,
  791. BOOL bSelected, HBITMAP hbmCheck, BOOL bDrawSunkenBdr, BOOL bGrayImage)
  792. {
  793. // get checkmark bitmap if none, use Windows standard
  794. HBITMAP hbm = hbmCheck;
  796. if (!hbmCheck) {
  797. CBitmap bm;
  798. bm.LoadOEMBitmap(OBM_CHECK);
  799. hbm = (HBITMAP)bm.Detach();
  800. if(!hbm)
  801. return FALSE;
  802. }
  804. // center bitmap in caller's rectangle
  805. BITMAP bm;
  806. ::GetObject(hbm, sizeof(bm), &bm);
  807. int cx = bm.bmWidth;
  808. int cy = bm.bmHeight;
  809. CRect rcDest = rc;
  810. CPoint p(0,0);
  811. CSize delta(CPoint((rc.Width() - cx)/2, (rc.Height() - cy)/2));
  812. if (rc.Width() > cx)
  813. rcDest = CRect(rc.TopLeft() + delta, CSize(cx, cy));
  814. else
  815. p -= delta;
  817. //draw background rectangle first
  818. if(hbmCheck && bDrawSunkenBdr)
  819. dc.FillSolidRect(rc, GetSysColor(COLOR_MENU));
  821. // select checkmark into memory DC
  822. CDC memdc;
  823. memdc.CreateCompatibleDC(&dc);
  825. //change the background colors of bitmap
  826. if(hbmCheck)
  827. {
  828. hbm = GetSysColorBitmap(dc.GetSafeHdc(), hbm, bGrayImage, bSelected);
  829. }
  831. HBITMAP hOldBM = (HBITMAP)::SelectObject(memdc, hbm);
  833. // set BG color based on selected state
  834. COLORREF colorOld = dc.SetBkColor(GetSysColor((bSelected && !bGrayImage)?COLOR_HIGHLIGHT:COLOR_MENU));
  835. dc.BitBlt(rcDest.left, rcDest.top, rcDest.Width(), rcDest.Height(),
  836. &memdc, p.x, p.y, SRCCOPY);
  837. dc.SetBkColor(colorOld);
  839. ::SelectObject(memdc, hOldBM); //restore
  841. //Delete hbm object..it is either created by GetSysColorBitmap function or LoadOEMBitmap
  842. DeleteObject(hbm);
  843. memdc.DeleteDC();
  845. //Check if we need to draw sunken border
  846. if(bDrawSunkenBdr)
  847. {
  848. dc.DrawEdge(rc, BDR_SUNKENOUTER, BF_RECT);
  850. //draw background
  851. CBrush brush;
  852. CBitmap bmp;
  853. WORD      Bits[8] = { 0x0055, 0x00aa, 0x0055, 0x00aa,
  854.  0x0055, 0x00aa, 0x0055, 0x00aa };
  855. bmp.CreateBitmap( 8, 8, 1, 1, &Bits );
  856. //hatched background
  857. brush.CreatePatternBrush(&bmp);
  859. //if item is selected, then we draw plain background
  860. CBrush brush1(GetSysColor(COLOR_MENU));
  862. CBrush* oldBr = dc.SelectObject(bSelected ? &brush1 : &brush);
  864. //the text color is used by pattern brush
  865. dc.SetTextColor(GetSysColor(COLOR_3DHIGHLIGHT));
  866. dc.SetBkColor(GetSysColor(COLOR_MENU));
  868. if(!hbmCheck)
  869. dc.ExtFloodFill(rc.left+1, rc.top+1, GetSysColor(bSelected?COLOR_HIGHLIGHT:COLOR_MENU), FLOODFILLSURFACE);
  870. else
  871. dc.ExtFloodFill(rc.left+1, rc.top+1, GetSysColor(COLOR_MENU), FLOODFILLSURFACE);
  873. //cleanup
  874. dc.SelectObject(oldBr);
  875. brush.DeleteObject();
  876. brush1.DeleteObject();
  877. bmp.DeleteObject();
  878. }
  880. return TRUE;
  881. }
  883. int MenuToolBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  884. {
  885. lpCreateStruct->style &= ~WS_VISIBLE;
  886. if (CToolBar::OnCreate(lpCreateStruct) == -1)
  887. return -1;
  889. ModifyStyleEx(0, WS_EX_TOOLWINDOW);
  890. GetToolBarCtrl().SetExtendedStyle(TBSTYLE_EX_DRAWDDARROWS);
  892. NONCLIENTMETRICS nc;
  893. ZeroMemory(&nc, sizeof(nc));
  894. nc.cbSize = sizeof(nc);
  895. SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &nc, 0);
  896. m_oMenuFont.CreateFontIndirect(&nc.lfMenuFont);
  897. SetFont(&m_oMenuFont);
  899. return 0;
  900. }
  902. void MenuToolBar::OnLButtonDown(UINT nFlags, CPoint point) 
  903. {
  904. //Calculate button index and post a user define message to ourselves..so that this function returns immediately
  905. int nBtnIndex = GetToolBarCtrl().HitTest(&point);
  907. TBBUTTON tbb;
  908. GetToolBarCtrl().GetButton(nBtnIndex, &tbb);
  910. //if this button is disabled or grayed down...then we simply return
  911. BOOL bRet = (((MENUITEMINFO*)(tbb.dwData))->fState & MF_GRAYED) || 
  912. (((MENUITEMINFO*)(tbb.dwData))->fState & MF_DISABLED);
  914. if(bRet)
  915. return;
  917. if(nBtnIndex >= 0)
  918. {
  919. if(m_nLastLBDownIndex != nBtnIndex)
  920. {
  921. //If already another popup menu was opened, then we need to close that window
  922. ((CBmpMenu*)GetParent())->DestroySubMenus();
  924. PostMessage(WM_LBUTTONDOWNAFTER, nFlags, MAKELPARAM(point.x, point.y));
  926. m_nLastLBDownIndex = nBtnIndex;
  927. }
  928. }
  929. }
  931. void MenuToolBar::OnPostLbuttonMsg(UINT nFlags, LPARAM lp)
  932. {
  933. //claculate the button index
  934. CPoint point(LOWORD(lp), HIWORD(lp));
  936. int nBtnIndex = GetToolBarCtrl().HitTest(&point);
  937. TBBUTTON tbb;
  938. GetToolBarCtrl().GetButton(nBtnIndex, &tbb);
  940. //if the click was on a button corresponding to popup item, then we need to open up popup menu 
  941. //and don't pass the message up windows hirarchy.
  942. if(tbb.dwData && ((MENUITEMINFO*)(tbb.dwData))->hSubMenu)
  943. {
  944. ((CBmpMenu*)GetParent())->SendMessage(WM_POPUPSUBMENU, lp, (MENU_SELECTFIRSTITEM & nFlags)?MENU_SELECTFIRSTITEM:0);
  945. return;
  946. }
  948. //If this is a valid button and no submenu then send wm_command message to owner and close all menus
  949. ((CBmpMenu*)GetParent())->m_pOwnerWnd->PostMessage(WM_COMMAND, MAKEWPARAM(tbb.idCommand, 0), 0);
  950. ((CBmpMenu*)GetParent())->DestroyRootMenu();
  951. }
  954. void MenuToolBar::OnMouseMove(UINT nFlags, CPoint point) 
  955. {
  956. // TODO: Add your message handler code here and/or call default
  957. int nBtnIndex = GetToolBarCtrl().HitTest(&point);
  959. //skip mouse move message if this button is disabled or grayed or inactive
  960. TBBUTTON tbb;
  961. GetToolBarCtrl().GetButton(nBtnIndex, &tbb);
  963. //if this button is disabled or grayed down...then we simply return
  964. BOOL bRet = (((MENUITEMINFO*)(tbb.dwData))->fState & MF_GRAYED) || 
  965. (((MENUITEMINFO*)(tbb.dwData))->fState & MF_DISABLED);
  967. if(bRet)
  968. return;
  970. //skip WM_MOUSEMOVE message if the last mouse position is same as curent one.
  971. static CPoint pt(0,0);
  973. if(point != pt)
  974. pt = point;
  975. else
  976. return;
  978. if(nBtnIndex >= 0)
  979. {
  980. if(m_nLastHoverIndex != nBtnIndex)
  981. {
  982. m_nLastHoverIndex = nBtnIndex;
  983. m_oHoverPt = point;
  985. //Hovetrack only for submenu items
  986. TRACKMOUSEEVENT tme = {sizeof(tme), TME_HOVER, m_hWnd, 0};
  988. _TrackMouseEvent(&tme);
  989. }
  990. }
  991. CToolBar::OnMouseMove(nFlags, point);
  992. }
  994. LRESULT MenuToolBar::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  995. {
  996. // TODO: Add your specialized code here and/or call the base class
  997. //Garb WM_MOUSEHOVER message
  998. if(message == WM_MOUSEHOVER)
  999. {
  1000. if(m_nLastHoverIndex >= 0)
  1001. {
  1002. TBBUTTON tbb;
  1003. GetToolBarCtrl().GetButton(m_nLastHoverIndex, &tbb);
  1005. if(tbb.dwData)
  1006. {
  1007. //pass on left mouse down event for submenu items
  1008. if(((MENUITEMINFO*)(tbb.dwData))->hSubMenu)
  1009. {
  1010. SendMessage(WM_LBUTTONDOWN, MK_LBUTTON, MAKELPARAM(m_oHoverPt.x, m_oHoverPt.y));
  1011. SendMessage(WM_LBUTTONUP, MK_LBUTTON, MAKELPARAM(m_oHoverPt.x, m_oHoverPt.y));
  1012. }
  1013. else //delete any submenus present for this menu
  1014. {
  1015. ((CBmpMenu*)GetParent())->DestroySubMenus();
  1016. m_nLastLBDownIndex = -1; //reset after destroying submenus
  1017. }
  1018. }
  1019. }
  1020. }
  1022. if(message == WM_RESETDATA)
  1023. m_nLastLBDownIndex = -1;
  1025. return CToolBar::DefWindowProc(message, wParam, lParam);
  1026. }
  1028. //Grab Key down events
  1029. BOOL MenuToolBar::KeyboardFilter(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1030. {
  1031. //On escape key, we close all menu windows
  1032. if(nChar==VK_ESCAPE)
  1033. {
  1034. ((CBmpMenu*)GetParent())->DestroyRootMenu();
  1035. return TRUE;
  1036. }
  1038. //On left arrow...we need to close the current submenu and go to parent
  1039. if(nChar == VK_LEFT)
  1040. {
  1041. CWnd *pWnd = GetParent()->GetParent();
  1043. if(pWnd && IsWindow(pWnd->m_hWnd) && pWnd->IsKindOf(RUNTIME_CLASS(CBmpMenu)))
  1044. {
  1045. ((CBmpMenu*)pWnd)->DestroySubMenus();
  1047. (CBmpMenu*)pWnd->SendMessage(WM_RESETDATA, 0, 0);
  1048. }
  1049. return TRUE;
  1050. }
  1052. if((nChar == VK_RIGHT) || (nChar == VK_RETURN))
  1053. {
  1054. if(m_nSelectedItem != -1)
  1055. {
  1056. int ndx = CommandToIndex(m_nSelectedItem);
  1058. if(ndx >= 0)
  1059. {
  1060. TBBUTTON tbb;
  1061. GetToolBarCtrl().GetButton(ndx, &tbb);
  1063. CRect rect;
  1064. GetToolBarCtrl().GetItemRect(ndx, &rect);
  1066. if(tbb.dwData)
  1067. {
  1068. //pass on left mouse down event for submenu items..also need to select the first submenu item
  1069. if((((MENUITEMINFO*)(tbb.dwData))->hSubMenu) || (nChar == VK_RETURN))
  1070. {
  1071. m_nLastLBDownIndex = -1;
  1072. SendMessage(WM_LBUTTONDOWN, MK_LBUTTON|MENU_SELECTFIRSTITEM, MAKELPARAM(rect.left+1, rect.top+1));
  1073. SendMessage(WM_LBUTTONUP, MK_LBUTTON|MENU_SELECTFIRSTITEM, MAKELPARAM(rect.left+1, rect.top+1));
  1074. }
  1075. }
  1076. }
  1077. }
  1079. return TRUE;
  1080. }
  1082. //pass on for further processing
  1083. OnChar(nChar, nRepCnt, nFlags);
  1085. return FALSE;
  1086. }
  1088. void MenuToolBar::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1089. {
  1090. // TODO: Add your message handler code here and/or call default
  1091. if(KeyboardFilter(nChar,nRepCnt,nFlags)) 
  1092. return;
  1094. CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
  1095. }
  1097. // User typed a char into menu. Look for item with & preceeding the char typed.
  1098. void MenuToolBar::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1099. {
  1100. // TODO: Add your message handler code here and/or call default
  1101. //////////////////
  1102. UINT iCurrentItem = (UINT)-1; // guaranteed higher than any command ID
  1103. CUIntArray arItemsMatched; // items that match the character typed
  1105. UINT nItem = GetToolBarCtrl().GetButtonCount();
  1107. for (UINT i=0; i< nItem; i++) 
  1108. {
  1109. // get menu info
  1110. TBBUTTON tbb;
  1111. GetToolBarCtrl().GetButton(i, &tbb);
  1113. if(tbb.dwData)
  1114. {
  1115. if(((MENUITEMINFO*)(tbb.dwData))->dwTypeData)
  1116. {
  1117. CString text = ((MENUITEMINFO*)(tbb.dwData))->dwTypeData;
  1118. int iAmpersand = text.Find('&');
  1119. if (iAmpersand >=0 && toupper(nChar)==toupper(text[iAmpersand+1]))
  1120. arItemsMatched.Add(i);
  1121. }
  1122. if ((UINT)SendMessage(TB_GETHOTITEM, 0, 0) == i)
  1123. iCurrentItem = i; // note index of current item
  1124. }
  1125. }
  1126. // arItemsMatched now contains indexes of items that match the char typed.
  1127. UINT nFound = arItemsMatched.GetSize();
  1128. if (nFound == 0)
  1129. {
  1130. //notify owner window and take corresponding action
  1131. UINT lRet = (((CBmpMenu*)GetParent())->m_pOwnerWnd)->SendMessage(WM_MENUCHAR, MAKEWPARAM(nChar, MF_POPUP), 
  1132. (LPARAM)((CBmpMenu*)GetParent())->m_hMenu);
  1134. switch(HIWORD(lRet))
  1135. {
  1136. case MNC_CLOSE:
  1137. ((CBmpMenu*)GetParent())->DestroyRootMenu();
  1138. break;
  1140. case MNC_SELECT:
  1141. //select the menu item
  1142. break;
  1144. case MNC_EXECUTE:
  1145. (((CBmpMenu*)GetParent())->m_pOwnerWnd)->SendMessage(WM_COMMAND, LOWORD(lRet), 0);
  1146. break;
  1147. }
  1149. return;
  1150. }
  1152. else if (nFound==1)
  1153. {
  1154. CRect rect;
  1155. GetToolBarCtrl().GetItemRect(arItemsMatched[0], &rect);
  1156. SendMessage(TB_SETHOTITEM, arItemsMatched[0], 0);
  1157. m_nLastLBDownIndex = -1;
  1158. SendMessage(WM_LBUTTONDOWN, MK_LBUTTON, MAKELPARAM(rect.left+1, rect.top+1));
  1159. SendMessage(WM_LBUTTONUP, MK_LBUTTON, MAKELPARAM(rect.left+1, rect.top+1));
  1160. return;
  1161. }
  1163. // more than one found--return 1st one past current selected item;
  1164. UINT iSelect = 0;
  1165. for (i=0; i < nFound; i++) {
  1166. if (arItemsMatched[i] > iCurrentItem) {
  1167. iSelect = i;
  1168. break;
  1169. }
  1170. }
  1172. SendMessage(TB_SETHOTITEM, iSelect, 0);
  1173. }
  1175. HBITMAP 
  1176. GetSysColorBitmap(HDC hDC, HBITMAP hSourceBitmap, BOOL bMono, BOOL bSelected)
  1177. {
  1178. struct _COLORMAPTABLE{
  1179. COLORREF rgb;
  1180. int nSysColor;
  1181. };
  1183. _COLORMAPTABLE _ColorMap[]=
  1184. {
  1185. // mapping from color in DIB to system color
  1186. { RGB(0x00, 0x00, 0x00),  COLOR_BTNTEXT },       // black
  1187. { RGB(0x80, 0x80, 0x80),  COLOR_BTNSHADOW },     // dark gray
  1188. { RGB(0xC0, 0xC0, 0xC0),  COLOR_MENU },       // bright gray
  1189. { RGB(0xFF, 0xFF, 0xFF),  COLOR_BTNHIGHLIGHT }   // white
  1190. };
  1192. HBITMAP hOldSourceBitmap, hOldDestBitmap, hDestBitmap;
  1193. HDC hMemSrc, hMemDest;
  1194. int height, width;
  1195. int i, j;
  1196. BITMAP SrcBitmap;
  1198. if(bSelected && !bMono)
  1199. _ColorMap[2].nSysColor= COLOR_HIGHLIGHT;
  1200. else
  1201. _ColorMap[2].nSysColor= COLOR_MENU;
  1203. // Step 1: Create a memory DC for the source and destination bitmaps
  1204. //         compatible with the device used.
  1206. hMemSrc = CreateCompatibleDC(hDC);
  1207. hMemDest= CreateCompatibleDC(hDC);
  1210. // Step 2: Get the height and width of the source bitmap.
  1212. GetObject(hSourceBitmap, sizeof(BITMAP), (LPSTR)&SrcBitmap);
  1213. width = SrcBitmap.bmWidth;
  1214. height = SrcBitmap.bmHeight;
  1217. // Step 3: Select the source bitmap into the source DC. Create a
  1218. //         destination bitmap, and select it into the destination DC.
  1220. hOldSourceBitmap = (HBITMAP)SelectObject(hMemSrc, hSourceBitmap);
  1221. hDestBitmap = CreateBitmap(height, width, (bMono)?1:SrcBitmap.bmPlanes,
  1222. (bMono)?1:SrcBitmap.bmBitsPixel, NULL);
  1224. if (hDestBitmap)
  1225. {
  1226. hOldDestBitmap = (HBITMAP)SelectObject(hMemDest, hDestBitmap);
  1228. // Step 4: Copy the pixels from the source to the destination.
  1230. for (i = 0; i < width; ++i)
  1231. {
  1232. for (j = 0; j < height; ++j)
  1233. {
  1234. //Get the color of source bitmap
  1235. COLORREF rgb = GetPixel(hMemSrc, i, j);
  1237. SetPixel(hMemDest, i, j, rgb);
  1239. if(!bMono)
  1240. {
  1241. //check if we need to change this color
  1242. for(int k=0; k<sizeof(_ColorMap)/sizeof(_ColorMap[0]); k++)
  1243. {
  1244. if(rgb == _ColorMap[k].rgb)
  1245. {
  1246. SetPixel(hMemDest, i, j, GetSysColor(_ColorMap[k].nSysColor));
  1247. break;
  1248. }
  1249. }
  1250. }
  1251. }
  1252. }
  1253. }
  1256. // Step 5: Destroy the DCs.
  1258. SelectObject(hMemSrc, hOldSourceBitmap);
  1259. SelectObject(hMemDest, hOldDestBitmap);
  1260. DeleteDC(hMemDest);
  1261. DeleteDC(hMemSrc);
  1264. // Step 6: Return the rotated bitmap.
  1266. return(hDestBitmap);
  1268. }