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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 医药行业 > 查看源码
BtnST.cpp
资源名称：心跳检测.rar　[点击查看]
上传用户：dtengfei
上传日期：2013-01-16
资源大小：393k
文件大小：51k
源码类别：

医药行业

开发平台：

Visual C++

BtnST.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "BtnST.h"
  4. #ifdef _DEBUG
  5. #define new DEBUG_NEW
  6. #undef THIS_FILE
  7. static char THIS_FILE[] = __FILE__;
  8. #endif
  10. /////////////////////////////////////////////////////////////////////////////
  11. // CButtonST
  13. // Mask for control's type
  14. #define BS_TYPEMASK SS_TYPEMASK
  16. CButtonST::CButtonST()
  17. {
  18. m_bIsPressed = FALSE;
  19. m_bIsFocused = FALSE;
  20. m_bIsDisabled = FALSE;
  21. m_bMouseOnButton = FALSE;
  23. FreeResources(FALSE);
  25. // Default type is "flat" button
  26. m_bIsFlat = TRUE;
  27. // Button will be tracked also if when the window is inactive (like Internet Explorer)
  28. m_bAlwaysTrack = TRUE;
  29.   
  30. // By default draw border in "flat" button 
  31. m_bDrawBorder = TRUE; 
  32.   
  33. // By default icon is aligned horizontally
  34. m_byAlign = ST_ALIGN_HORIZ; 
  35.   
  36. // By default, for "flat" button, don't draw the focus rect
  37. m_bDrawFlatFocus = FALSE;
  39. // By default the button is not the default button
  40. m_bIsDefault = FALSE;
  41. // Invalid value, since type still unknown
  42. m_nTypeStyle = BS_TYPEMASK;
  44. // By default the button is not a checkbox
  45. m_bIsCheckBox = FALSE;
  46. m_nCheck = 0;
  48. // Set default colors
  49. SetDefaultColors(FALSE);
  51. // No tooltip created
  52. m_ToolTip.m_hWnd = NULL;
  54. // Do not draw as a transparent button
  55. m_bDrawTransparent = FALSE;
  56. m_pbmpOldBk = NULL;
  58. // No URL defined
  59. SetURL(NULL);
  61. // No cursor defined
  62. m_hCursor = NULL;
  64. // No associated menu
  65. #ifndef BTNST_USE_BCMENU
  66. m_hMenu = NULL;
  67. #endif
  68. m_hParentWndMenu = NULL;
  69. m_bMenuDisplayed = FALSE;
  71. m_bShowDisabledBitmap = TRUE;
  72. } // End of CButtonST
  74. CButtonST::~CButtonST()
  75. {
  76. // Restore old bitmap (if any)
  77. if (m_dcBk.m_hDC && m_pbmpOldBk)
  78. {
  79. m_dcBk.SelectObject(m_pbmpOldBk);
  80. } // if
  82. FreeResources();
  84. // Destroy the cursor (if any)
  85. if (m_hCursor) ::DestroyCursor(m_hCursor);
  87. // Destroy the menu (if any)
  88. #ifdef BTNST_USE_BCMENU
  89. if (m_menuPopup.m_hMenu) m_menuPopup.DestroyMenu();
  90. #else
  91. if (m_hMenu) ::DestroyMenu(m_hMenu);
  92. #endif
  93. } // End of ~CButtonST
  95. BEGIN_MESSAGE_MAP(CButtonST, CButton)
  96.     //{{AFX_MSG_MAP(CButtonST)
  97. ON_WM_SETCURSOR()
  98. ON_WM_KILLFOCUS()
  99. ON_WM_MOUSEMOVE()
  100. ON_WM_SYSCOLORCHANGE()
  101. ON_CONTROL_REFLECT_EX(BN_CLICKED, OnClicked)
  102. ON_WM_ACTIVATE()
  103. ON_WM_ENABLE()
  104. ON_WM_CANCELMODE()
  105. ON_WM_GETDLGCODE()
  106. ON_WM_CTLCOLOR_REFLECT()
  107. //}}AFX_MSG_MAP
  108. #ifdef BTNST_USE_BCMENU
  109. ON_WM_MENUCHAR()
  110. ON_WM_MEASUREITEM()
  111. #endif
  113. ON_MESSAGE(BM_SETSTYLE, OnSetStyle)
  114. ON_MESSAGE(WM_MOUSELEAVE, OnMouseLeave)
  115. ON_MESSAGE(BM_SETCHECK, OnSetCheck)
  116. ON_MESSAGE(BM_GETCHECK, OnGetCheck)
  117. END_MESSAGE_MAP()
  119. void CButtonST::FreeResources(BOOL bCheckForNULL)
  120. {
  121. if (bCheckForNULL)
  122. {
  123. // Destroy icons
  124. // Note: the following two lines MUST be here! even if
  125. // BoundChecker says they are unnecessary!
  126. if (m_csIcons[0].hIcon) ::DestroyIcon(m_csIcons[0].hIcon);
  127. if (m_csIcons[1].hIcon) ::DestroyIcon(m_csIcons[1].hIcon);
  129. // Destroy bitmaps
  130. if (m_csBitmaps[0].hBitmap) ::DeleteObject(m_csBitmaps[0].hBitmap);
  131. if (m_csBitmaps[1].hBitmap) ::DeleteObject(m_csBitmaps[1].hBitmap);
  133. // Destroy mask bitmaps
  134. if (m_csBitmaps[0].hMask) ::DeleteObject(m_csBitmaps[0].hMask);
  135. if (m_csBitmaps[1].hMask) ::DeleteObject(m_csBitmaps[1].hMask);
  136. } // if
  138. ::ZeroMemory(&m_csIcons, sizeof(m_csIcons));
  139. ::ZeroMemory(&m_csBitmaps, sizeof(m_csBitmaps));
  140. } // End of FreeResources
  142. void CButtonST::PreSubclassWindow() 
  143. {
  144. UINT nBS;
  146. nBS = GetButtonStyle();
  148. // Set initial control type
  149. m_nTypeStyle = nBS & BS_TYPEMASK;
  151. // Check if this is a checkbox
  152. if (nBS & BS_CHECKBOX) m_bIsCheckBox = TRUE;
  154. // Set initial default state flag
  155. if (m_nTypeStyle == BS_DEFPUSHBUTTON)
  156. {
  157. // Set default state for a default button
  158. m_bIsDefault = TRUE;
  160. // Adjust style for default button
  161. m_nTypeStyle = BS_PUSHBUTTON;
  162. } // If
  164. // You should not set the Owner Draw before this call
  165. // (don't use the resource editor "Owner Draw" or
  166. // ModifyStyle(0, BS_OWNERDRAW) before calling PreSubclassWindow() )
  167. ASSERT(m_nTypeStyle != BS_OWNERDRAW);
  169. // Switch to owner-draw
  170. ModifyStyle(BS_TYPEMASK, BS_OWNERDRAW, SWP_FRAMECHANGED);
  172. CButton::PreSubclassWindow();
  173. } // End of PreSubclassWindow
  175. UINT CButtonST::OnGetDlgCode() 
  176. {
  177. UINT nCode = CButton::OnGetDlgCode();
  179. // Tell the system if we want default state handling
  180. // (losing default state always allowed)
  181. nCode |= (m_bIsDefault ? DLGC_DEFPUSHBUTTON : DLGC_UNDEFPUSHBUTTON);
  183. return nCode;
  184. } // End of OnGetDlgCode
  186. BOOL CButtonST::PreTranslateMessage(MSG* pMsg) 
  187. {
  188. InitToolTip();
  189. m_ToolTip.RelayEvent(pMsg);
  191. return CButton::PreTranslateMessage(pMsg);
  192. } // End of PreTranslateMessage
  194. LRESULT CButtonST::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  195. {
  196. if (message == WM_LBUTTONDBLCLK)
  197. {
  198. message = WM_LBUTTONDOWN;
  199. } // if
  200. /*
  201. switch (message)
  202. {
  203. case WM_LBUTTONDBLCLK:
  204. message = WM_LBUTTONDOWN;
  205. break;
  206. case WM_MOVE:
  207. CRect rect;
  209. GetClientRect(&rect);
  210. if (::IsWindow(m_ToolTip.m_hWnd))
  211. {
  212. if (m_ToolTip.GetToolCount() != 0)
  213. m_ToolTip.SetToolRect(this, 1, &rect);
  214. } // if
  215. break;
  216. } // switch
  217. */
  218. return CButton::DefWindowProc(message, wParam, lParam);
  219. } // End of DefWindowProc
  221. HBRUSH CButtonST::CtlColor(CDC* pDC, UINT nCtlColor) 
  222. {
  223. return (HBRUSH)::GetStockObject(NULL_BRUSH); 
  224. } // End of CtlColor
  226. void CButtonST::OnSysColorChange() 
  227. {
  228. CButton::OnSysColorChange();
  230. m_dcBk.DeleteDC();
  231. m_bmpBk.DeleteObject();
  232. } // End of OnSysColorChange
  234. LRESULT CButtonST::OnSetStyle(WPARAM wParam, LPARAM lParam)
  235. {
  236. UINT nNewType = (wParam & BS_TYPEMASK);
  238. // Update default state flag
  239. if (nNewType == BS_DEFPUSHBUTTON)
  240. {
  241. m_bIsDefault = TRUE;
  242. } // if
  243. else if (nNewType == BS_PUSHBUTTON)
  244. {
  245. // Losing default state always allowed
  246. m_bIsDefault = FALSE;
  247. } // if
  249. // Can't change control type after owner-draw is set.
  250. // Let the system process changes to other style bits
  251. // and redrawing, while keeping owner-draw style
  252. return DefWindowProc(BM_SETSTYLE,
  253. (wParam & ~BS_TYPEMASK) | BS_OWNERDRAW, lParam);
  254. } // End of OnSetStyle
  256. LRESULT CButtonST::OnSetCheck(WPARAM wParam, LPARAM lParam)
  257. {
  258. ASSERT(m_bIsCheckBox);
  260. switch (wParam)
  261. {
  262. case BST_CHECKED:
  263. case BST_INDETERMINATE: // Indeterminate state is handled like checked state
  264. SetCheck(1);
  265. break;
  266. default:
  267. SetCheck(0);
  268. break;
  269. } // switch
  271. return 0;
  272. } // End of OnSetCheck
  274. LRESULT CButtonST::OnGetCheck(WPARAM wParam, LPARAM lParam)
  275. {
  276. ASSERT(m_bIsCheckBox);
  277. return GetCheck();
  278. } // End of OnGetCheck
  280. #ifdef BTNST_USE_BCMENU
  281. LRESULT CButtonST::OnMenuChar(UINT nChar, UINT nFlags, CMenu* pMenu) 
  282. {
  283. LRESULT lResult;
  284. if (BCMenu::IsMenu(pMenu))
  285. lResult = BCMenu::FindKeyboardShortcut(nChar, nFlags, pMenu);
  286. else
  287. lResult = CButton::OnMenuChar(nChar, nFlags, pMenu);
  288. return lResult;
  289. } // End of OnMenuChar
  290. #endif
  292. #ifdef BTNST_USE_BCMENU
  293. void CButtonST::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
  294. {
  295. BOOL bSetFlag = FALSE;
  296. if (lpMeasureItemStruct->CtlType == ODT_MENU)
  297. {
  298. if (IsMenu((HMENU)lpMeasureItemStruct->itemID) && BCMenu::IsMenu((HMENU)lpMeasureItemStruct->itemID))
  299. {
  300. m_menuPopup.MeasureItem(lpMeasureItemStruct);
  301. bSetFlag = TRUE;
  302. } // if
  303. } // if
  304. if (!bSetFlag) CButton::OnMeasureItem(nIDCtl, lpMeasureItemStruct);
  305. } // End of OnMeasureItem
  306. #endif
  308. void CButtonST::OnEnable(BOOL bEnable) 
  309. {
  310. CButton::OnEnable(bEnable);
  312. if (bEnable == FALSE)
  313. {
  314. CWnd* pWnd = GetParent()->GetNextDlgTabItem(this);
  315. if (pWnd)
  316. pWnd->SetFocus();
  317. else
  318. GetParent()->SetFocus();
  320. CancelHover();
  321. } // if
  322. } // End of OnEnable
  324. void CButtonST::OnKillFocus(CWnd * pNewWnd)
  325. {
  326. CButton::OnKillFocus(pNewWnd);
  327. CancelHover();
  328. } // End of OnKillFocus
  330. void CButtonST::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized) 
  331. {
  332. CButton::OnActivate(nState, pWndOther, bMinimized);
  333. if (nState == WA_INACTIVE) CancelHover();
  334. } // End of OnActivate
  336. void CButtonST::OnCancelMode() 
  337. {
  338. CButton::OnCancelMode();
  339. CancelHover();
  340. } // End of OnCancelMode
  342. BOOL CButtonST::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  343. {
  344. // If a cursor was specified then use it!
  345. if (m_hCursor != NULL)
  346. {
  347. ::SetCursor(m_hCursor);
  348. return TRUE;
  349. } // if
  351. return CButton::OnSetCursor(pWnd, nHitTest, message);
  352. } // End of OnSetCursor
  354. void CButtonST::CancelHover()
  355. {
  356. // Only for flat buttons
  357. if (m_bIsFlat)
  358. {
  359. if (m_bMouseOnButton)
  360. {
  361. m_bMouseOnButton = FALSE;
  362. Invalidate();
  363. } // if
  364. } // if
  365. } // End of CancelHover
  367. void CButtonST::OnMouseMove(UINT nFlags, CPoint point)
  368. {
  369. CWnd* wndUnderMouse = NULL;
  370. CWnd* wndActive = this;
  371. TRACKMOUSEEVENT csTME;
  373. CButton::OnMouseMove(nFlags, point);
  375. ClientToScreen(&point);
  376. wndUnderMouse = WindowFromPoint(point);
  378. // If the mouse enter the button with the left button pressed then do nothing
  379. if (nFlags & MK_LBUTTON && m_bMouseOnButton == FALSE) return;
  381. // If our button is not flat then do nothing
  382. if (m_bIsFlat == FALSE) return;
  384. if (m_bAlwaysTrack == FALSE) wndActive = GetActiveWindow();
  386. if (wndUnderMouse && wndUnderMouse->m_hWnd == m_hWnd && wndActive)
  387. {
  388. if (!m_bMouseOnButton)
  389. {
  390. m_bMouseOnButton = TRUE;
  392. Invalidate();
  394. csTME.cbSize = sizeof(csTME);
  395. csTME.dwFlags = TME_LEAVE;
  396. csTME.hwndTrack = m_hWnd;
  397. ::_TrackMouseEvent(&csTME);
  398. } // if
  399. } else CancelHover();
  400. } // End of OnMouseMove
  402. // Handler for WM_MOUSELEAVE
  403. LRESULT CButtonST::OnMouseLeave(WPARAM wParam, LPARAM lParam)
  404. {
  405. CancelHover();
  406. return 0;
  407. } // End of OnMouseLeave
  409. BOOL CButtonST::OnClicked() 
  410. {
  411. SetFocus();
  413. if (m_bIsCheckBox)
  414. {
  415. m_nCheck = !m_nCheck;
  416. Invalidate();
  417. } // if
  418. else
  419. {
  420. // Handle the menu (if any)
  421. #ifdef BTNST_USE_BCMENU
  422. if (m_menuPopup.m_hMenu)
  423. #else
  424. if (m_hMenu)
  425. #endif
  426. {
  427. CRect rWnd;
  428. GetWindowRect(rWnd);
  430. m_bMenuDisplayed = TRUE;
  431. Invalidate();
  433. #ifdef BTNST_USE_BCMENU
  434. BCMenu *psub = (BCMenu*)m_menuPopup.GetSubMenu(0);
  435. DWORD dwRetValue = psub->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD, rWnd.left, rWnd.bottom, this, NULL);
  436. #else
  437. HMENU hSubMenu = ::GetSubMenu(m_hMenu, 0);
  438. //DWORD dwRetValue = ::TrackPopupMenuEx(hSubMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON, rWnd.left, rWnd.bottom, m_hParentWndMenu, NULL);
  439. DWORD dwRetValue = ::TrackPopupMenuEx(hSubMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD, rWnd.left, rWnd.bottom, m_hParentWndMenu, NULL);
  440. #endif
  442. m_bMenuDisplayed = FALSE;
  443. Invalidate();
  445. if (dwRetValue)
  446. ::PostMessage(m_hParentWndMenu, WM_COMMAND, MAKEWPARAM(dwRetValue, 0), (LPARAM)NULL);
  447. } // if
  448. else
  449. {
  450. // Handle the URL (if any)
  451. if (_tcslen(m_szURL) > 0)
  452. {
  453. SHELLEXECUTEINFO csSEI;
  455. memset(&csSEI, 0, sizeof(csSEI));
  456. csSEI.cbSize = sizeof(SHELLEXECUTEINFO);
  457. csSEI.fMask = SEE_MASK_FLAG_NO_UI;
  458. csSEI.lpVerb = _T("open");
  459. csSEI.lpFile = m_szURL;
  460. csSEI.nShow = SW_SHOWMAXIMIZED;
  461. ::ShellExecuteEx(&csSEI);
  462. } // if
  463. } // else
  464. } // else
  466. return FALSE;
  467. } // End of OnClicked
  469. void CButtonST::DrawItem(LPDRAWITEMSTRUCT lpDIS)
  470. {
  471. CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  472. CPen* pOldPen;
  474. // Checkbox?
  475. if (m_bIsCheckBox)
  476. {
  477. m_bIsPressed  =  (lpDIS->itemState & ODS_SELECTED) || (m_nCheck != 0);
  478. } // if
  479. else // Normal button OR other button style ...
  480. {
  481. m_bIsPressed = (lpDIS->itemState & ODS_SELECTED);
  483. // If there is a menu and it's displayed, draw the button as pressed
  484. if (
  485. #ifdef BTNST_USE_BCMENU
  486. m_menuPopup.m_hMenu 
  487. #else
  488. m_hMenu 
  489. #endif
  490. && m_bMenuDisplayed) m_bIsPressed = TRUE;
  491. } // else
  493. m_bIsFocused  = (lpDIS->itemState & ODS_FOCUS);
  494. m_bIsDisabled = (lpDIS->itemState & ODS_DISABLED);
  496. CRect itemRect = lpDIS->rcItem;
  498. pDC->SetBkMode(TRANSPARENT);
  500. if (m_bIsFlat == FALSE)
  501. {
  502. if (m_bIsFocused || m_bIsDefault)
  503. {
  504. CBrush br(RGB(0,0,0));  
  505. pDC->FrameRect(&itemRect, &br);
  506. itemRect.DeflateRect(1, 1);
  507. } // if
  508. } // if
  510. // Prepare draw... paint button background
  512. // Draw transparent?
  513. if (m_bDrawTransparent)
  514. PaintBk(pDC);
  515. else
  516. OnDrawBackground(pDC, &itemRect);
  518. // Draw pressed button
  519. if (m_bIsPressed)
  520. {
  521. if (m_bIsFlat)
  522. {
  523. if (m_bDrawBorder)
  524. OnDrawBorder(pDC, &itemRect);
  525. }
  526. else    
  527. {
  528. CBrush brBtnShadow(GetSysColor(COLOR_BTNSHADOW));
  529. pDC->FrameRect(&itemRect, &brBtnShadow);
  530. }
  531. }
  532. else // ...else draw non pressed button
  533. {
  534. CPen penBtnHiLight(PS_SOLID, 0, GetSysColor(COLOR_BTNHILIGHT)); // White
  535. CPen pen3DLight(PS_SOLID, 0, GetSysColor(COLOR_3DLIGHT));       // Light gray
  536. CPen penBtnShadow(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));   // Dark gray
  537. CPen pen3DDKShadow(PS_SOLID, 0, GetSysColor(COLOR_3DDKSHADOW)); // Black
  539. if (m_bIsFlat)
  540. {
  541. if (m_bMouseOnButton && m_bDrawBorder)
  542. OnDrawBorder(pDC, &itemRect);
  543. }
  544. else
  545. {
  546. // Draw top-left borders
  547. // White line
  548. pOldPen = pDC->SelectObject(&penBtnHiLight);
  549. pDC->MoveTo(itemRect.left, itemRect.bottom-1);
  550. pDC->LineTo(itemRect.left, itemRect.top);
  551. pDC->LineTo(itemRect.right, itemRect.top);
  552. // Light gray line
  553. pDC->SelectObject(pen3DLight);
  554. pDC->MoveTo(itemRect.left+1, itemRect.bottom-1);
  555. pDC->LineTo(itemRect.left+1, itemRect.top+1);
  556. pDC->LineTo(itemRect.right, itemRect.top+1);
  557. // Draw bottom-right borders
  558. // Black line
  559. pDC->SelectObject(pen3DDKShadow);
  560. pDC->MoveTo(itemRect.left, itemRect.bottom-1);
  561. pDC->LineTo(itemRect.right-1, itemRect.bottom-1);
  562. pDC->LineTo(itemRect.right-1, itemRect.top-1);
  563. // Dark gray line
  564. pDC->SelectObject(penBtnShadow);
  565. pDC->MoveTo(itemRect.left+1, itemRect.bottom-2);
  566. pDC->LineTo(itemRect.right-2, itemRect.bottom-2);
  567. pDC->LineTo(itemRect.right-2, itemRect.top);
  568. //
  569. pDC->SelectObject(pOldPen);
  570. } // else
  571. } // else
  573. // Read the button's title
  574. CString sTitle;
  575. GetWindowText(sTitle);
  577. CRect captionRect = lpDIS->rcItem;
  579. // Draw the icon
  580. if (m_csIcons[0].hIcon)
  581. {
  582. DrawTheIcon(pDC, !sTitle.IsEmpty(), &lpDIS->rcItem, &captionRect, m_bIsPressed, m_bIsDisabled);
  583. } // if
  585. if (m_csBitmaps[0].hBitmap)
  586. {
  587. pDC->SetBkColor(RGB(255,255,255));
  588. DrawTheBitmap(pDC, !sTitle.IsEmpty(), &lpDIS->rcItem, &captionRect, m_bIsPressed, m_bIsDisabled);
  589. } // if
  591. // Write the button title (if any)
  592. if (sTitle.IsEmpty() == FALSE)
  593. {
  594. // Draw the button's title
  595. // If button is pressed then "press" title also
  596. if (m_bIsPressed && m_bIsCheckBox == FALSE)
  597. captionRect.OffsetRect(1, 1);
  598.     
  599. // ONLY FOR DEBUG 
  600. //CBrush brBtnShadow(RGB(255, 0, 0));
  601. //pDC->FrameRect(&captionRect, &brBtnShadow);
  603. // Center text
  604. CRect centerRect = captionRect;
  605. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER | DT_CALCRECT);
  606. captionRect.OffsetRect((centerRect.Width() - captionRect.Width())/2, (centerRect.Height() - captionRect.Height())/2);
  607. /* RFU
  608. captionRect.OffsetRect(0, (centerRect.Height() - captionRect.Height())/2);
  609. captionRect.OffsetRect((centerRect.Width() - captionRect.Width())-4, (centerRect.Height() - captionRect.Height())/2);
  610. */
  612. pDC->SetBkMode(TRANSPARENT);
  613. /*
  614. pDC->DrawState(captionRect.TopLeft(), captionRect.Size(), (LPCTSTR)sTitle, (bIsDisabled ? DSS_DISABLED : DSS_NORMAL), 
  615. TRUE, 0, (CBrush*)NULL);
  616. */
  617. if (m_bIsDisabled)
  618. {
  619. captionRect.OffsetRect(1, 1);
  620. pDC->SetTextColor(::GetSysColor(COLOR_3DHILIGHT));
  621. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER);
  622. captionRect.OffsetRect(-1, -1);
  623. pDC->SetTextColor(::GetSysColor(COLOR_3DSHADOW));
  624. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER);
  625. } // if
  626. else
  627. {
  628. if (m_bMouseOnButton || m_bIsPressed) 
  629. {
  630. pDC->SetTextColor(m_crColors[BTNST_COLOR_FG_IN]);
  631. pDC->SetBkColor(m_crColors[BTNST_COLOR_BK_IN]);
  632. } // if
  633. else 
  634. {
  635. pDC->SetTextColor(m_crColors[BTNST_COLOR_FG_OUT]);
  636. pDC->SetBkColor(m_crColors[BTNST_COLOR_BK_OUT]);
  637. } // else
  638. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER);
  639. } // if
  640. } // if
  642. if (m_bIsFlat == FALSE || (m_bIsFlat && m_bDrawFlatFocus))
  643. {
  644. // Draw the focus rect
  645. if (m_bIsFocused)
  646. {
  647. CRect focusRect = itemRect;
  648. focusRect.DeflateRect(3, 3);
  649. pDC->DrawFocusRect(&focusRect);
  650. } // if
  651. } // if
  652. } // End of DrawItem
  654. void CButtonST::PaintBk(CDC* pDC)
  655. {
  656. CClientDC clDC(GetParent());
  657. CRect rect;
  658. CRect rect1;
  660. GetClientRect(rect);
  662. GetWindowRect(rect1);
  663. GetParent()->ScreenToClient(rect1);
  665. if (m_dcBk.m_hDC == NULL)
  666. {
  667. m_dcBk.CreateCompatibleDC(&clDC);
  668. m_bmpBk.CreateCompatibleBitmap(&clDC, rect.Width(), rect.Height());
  669. m_pbmpOldBk = m_dcBk.SelectObject(&m_bmpBk);
  670. m_dcBk.BitBlt(0, 0, rect.Width(), rect.Height(), &clDC, rect1.left, rect1.top, SRCCOPY);
  671. } // if
  673. pDC->BitBlt(0, 0, rect.Width(), rect.Height(), &m_dcBk, 0, 0, SRCCOPY);
  674. } // End of PaintBk
  676. HBITMAP CButtonST::CreateBitmapMask(HBITMAP hSourceBitmap, DWORD dwWidth, DWORD dwHeight, COLORREF crTransColor)
  677. {
  678. HBITMAP hMask = NULL;
  679. HDC hdcSrc = NULL;
  680. HDC hdcDest = NULL;
  681. HBITMAP hbmSrcT = NULL;
  682. HBITMAP hbmDestT = NULL;
  683. COLORREF crSaveBk;
  684. COLORREF crSaveDestText;
  686. hMask = ::CreateBitmap(dwWidth, dwHeight, 1, 1, NULL);
  687. if (hMask == NULL) return NULL;
  689. hdcSrc = ::CreateCompatibleDC(NULL);
  690. hdcDest = ::CreateCompatibleDC(NULL);
  692. hbmSrcT = (HBITMAP)::SelectObject(hdcSrc, hSourceBitmap);
  693. hbmDestT = (HBITMAP)::SelectObject(hdcDest, hMask);
  695. crSaveBk = ::SetBkColor(hdcSrc, crTransColor);
  697. ::BitBlt(hdcDest, 0, 0, dwWidth, dwHeight, hdcSrc, 0, 0, SRCCOPY);
  699. crSaveDestText = ::SetTextColor(hdcSrc, RGB(255, 255, 255));
  700. ::SetBkColor(hdcSrc,RGB(0, 0, 0));
  702. ::BitBlt(hdcSrc, 0, 0, dwWidth, dwHeight, hdcDest, 0, 0, SRCAND);
  704. SetTextColor(hdcDest, crSaveDestText);
  706. ::SetBkColor(hdcSrc, crSaveBk);
  707. ::SelectObject(hdcSrc, hbmSrcT);
  708. ::SelectObject(hdcDest, hbmDestT);
  710. ::DeleteDC(hdcSrc);
  711. ::DeleteDC(hdcDest);
  713. return hMask;
  714. } // End of CreateBitmapMask
  716. //
  717. // Parameters:
  718. // [IN] bHasTitle
  719. // TRUE if the button has a text
  720. // [IN] rpItem
  721. // A pointer to a RECT structure indicating the allowed paint area
  722. // [IN/OUT]rpTitle
  723. // A pointer to a CRect object indicating the paint area reserved for the
  724. // text. This structure will be modified if necessary.
  725. // [IN] bIsPressed
  726. // TRUE if the button is currently pressed
  727. // [IN] dwWidth
  728. // Width of the image (icon or bitmap)
  729. // [IN] dwHeight
  730. // Height of the image (icon or bitmap)
  731. // [OUT] rpImage
  732. // A pointer to a CRect object that will receive the area available to the image
  733. //
  734. void CButtonST::PrepareImageRect(BOOL bHasTitle, RECT* rpItem, CRect* rpTitle, BOOL bIsPressed, DWORD dwWidth, DWORD dwHeight, CRect* rpImage)
  735. {
  736. CRect rBtn;
  738. rpImage->CopyRect(rpItem);
  740. switch (m_byAlign)
  741. {
  742. case ST_ALIGN_HORIZ:
  743. if (bHasTitle == FALSE)
  744. {
  745. // Center image horizontally
  746. rpImage->left += ((rpImage->Width() - (long)dwWidth)/2);
  747. }
  748. else
  749. {
  750. // Image must be placed just inside the focus rect
  751. rpImage->left += 3;  
  752. rpTitle->left += dwWidth + 3;
  753. }
  754. // Center image vertically
  755. rpImage->top += ((rpImage->Height() - (long)dwHeight)/2);
  756. break;
  758. case ST_ALIGN_HORIZ_RIGHT:
  759. GetClientRect(&rBtn);
  760. if (bHasTitle == FALSE)
  761. {
  762. // Center image horizontally
  763. rpImage->left += ((rpImage->Width() - (long)dwWidth)/2);
  764. }
  765. else
  766. {
  767. // Image must be placed just inside the focus rect
  768. rpTitle->right = rpTitle->Width() - dwWidth - 3;
  769. rpTitle->left = 3;
  770. rpImage->left = rBtn.right - dwWidth - 3;
  771. // Center image vertically
  772. rpImage->top += ((rpImage->Height() - (long)dwHeight)/2);
  773. }
  774. break;
  776. case ST_ALIGN_VERT:
  777. // Center image horizontally
  778. rpImage->left += ((rpImage->Width() - (long)dwWidth)/2);
  779. if (bHasTitle == FALSE)
  780. {
  781. // Center image vertically
  782. rpImage->top += ((rpImage->Height() - (long)dwHeight)/2);           
  783. }
  784. else
  785. {
  786. rpImage->top = 3;
  787. rpTitle->top += dwHeight;
  788. }
  789. break;
  790. }
  791.     
  792. // If button is pressed then press image also
  793. if (bIsPressed && m_bIsCheckBox == FALSE)
  794. rpImage->OffsetRect(1, 1);
  795. } // End of PrepareImageRect
  797. void CButtonST::DrawTheIcon(CDC* pDC, BOOL bHasTitle, RECT* rpItem, CRect* rpTitle, BOOL bIsPressed, BOOL bIsDisabled)
  798. {
  799. BYTE byIndex = 0;
  801. // Select the icon to use
  802. if ((m_bIsCheckBox && bIsPressed) || (!m_bIsCheckBox && (bIsPressed || m_bMouseOnButton)))
  803. byIndex = 0;
  804. else
  805. byIndex = (m_csIcons[1].hIcon == NULL ? 0 : 1);
  807. CRect rImage;
  808. PrepareImageRect(bHasTitle, rpItem, rpTitle, bIsPressed, m_csIcons[byIndex].dwWidth, m_csIcons[byIndex].dwHeight, &rImage);
  810. // Ole'!
  811. pDC->DrawState( rImage.TopLeft(),
  812. rImage.Size(), 
  813. m_csIcons[byIndex].hIcon,
  814. (bIsDisabled ? DSS_DISABLED : DSS_NORMAL), 
  815. (CBrush*)NULL);
  816. } // End of DrawTheIcon
  818. void CButtonST::DrawTheBitmap(CDC* pDC, BOOL bHasTitle, RECT* rItem, CRect *rCaption, BOOL bIsPressed, BOOL bIsDisabled)
  819. {
  820. HDC hdcBmpMem = NULL;
  821. HBITMAP hbmOldBmp = NULL;
  822. HDC hdcMem = NULL;
  823. HBITMAP hbmT = NULL;
  825. BYTE byIndex = 0;
  827. // Select the bitmap to use
  828. if ((m_bIsCheckBox && bIsPressed) || (!m_bIsCheckBox && (bIsPressed || m_bMouseOnButton)))
  829. byIndex = 0;
  830. else
  831. byIndex = (m_csBitmaps[1].hBitmap == NULL ? 0 : 1);
  833. CRect rImage;
  834. PrepareImageRect(bHasTitle, rItem, rCaption, bIsPressed, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, &rImage);
  836. hdcBmpMem = ::CreateCompatibleDC(pDC->m_hDC);
  838. hbmOldBmp = (HBITMAP)::SelectObject(hdcBmpMem, m_csBitmaps[byIndex].hBitmap);
  840. hdcMem = ::CreateCompatibleDC(NULL);
  842. hbmT = (HBITMAP)::SelectObject(hdcMem, m_csBitmaps[byIndex].hMask);
  844. if (bIsDisabled && m_bShowDisabledBitmap)
  845. {
  846. HDC hDC = NULL;
  847. HBITMAP hBitmap = NULL;
  849. hDC = ::CreateCompatibleDC(pDC->m_hDC);
  850. hBitmap = ::CreateCompatibleBitmap(pDC->m_hDC, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight);
  851. HBITMAP hOldBmp2 = (HBITMAP)::SelectObject(hDC, hBitmap);
  853. RECT rRect;
  854. rRect.left = 0;
  855. rRect.top = 0;
  856. rRect.right = rImage.right + 1;
  857. rRect.bottom = rImage.bottom + 1;
  858. ::FillRect(hDC, &rRect, (HBRUSH)RGB(255, 255, 255));
  860. COLORREF crOldColor = ::SetBkColor(hDC, RGB(255,255,255));
  862. ::BitBlt(hDC, 0, 0, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, hdcMem, 0, 0, SRCAND);
  863. ::BitBlt(hDC, 0, 0, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, hdcBmpMem, 0, 0, SRCPAINT);
  865. ::SetBkColor(hDC, crOldColor);
  866. ::SelectObject(hDC, hOldBmp2);
  867. ::DeleteDC(hDC);
  869. pDC->DrawState( CPoint(rImage.left/*+1*/, rImage.top), 
  870. CSize(m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight), 
  871. hBitmap, DST_BITMAP | DSS_DISABLED);
  873. ::DeleteObject(hBitmap);
  874. } // if
  875. else
  876. {
  877. ::BitBlt(pDC->m_hDC, rImage.left, rImage.top, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, hdcMem, 0, 0, SRCAND);
  879. ::BitBlt(pDC->m_hDC, rImage.left, rImage.top, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, hdcBmpMem, 0, 0, SRCPAINT);
  880. } // else
  882. ::SelectObject(hdcMem, hbmT);
  883. ::DeleteDC(hdcMem);
  885. ::SelectObject(hdcBmpMem, hbmOldBmp);
  886. ::DeleteDC(hdcBmpMem);
  887. } // End of DrawTheBitmap
  889. // This function creates a grayscale icon starting from a given icon.
  890. // The resulting icon will have the same size of the original one.
  891. //
  892. // Parameters:
  893. // [IN] hIcon
  894. // Handle to the original icon.
  895. //
  896. // Return value:
  897. // If the function succeeds, the return value is the handle to the newly created
  898. // grayscale icon.
  899. // If the function fails, the return value is NULL.
  900. //
  901. HICON CButtonST::CreateGrayscaleIcon(HICON hIcon)
  902. {
  903. HICON hGrayIcon = NULL;
  904. HDC hMainDC = NULL, hMemDC1 = NULL, hMemDC2 = NULL;
  905. BITMAP bmp;
  906. HBITMAP hOldBmp1 = NULL, hOldBmp2 = NULL;
  907. ICONINFO csII, csGrayII;
  908. BOOL bRetValue = FALSE;
  910. bRetValue = ::GetIconInfo(hIcon, &csII);
  911. if (bRetValue == FALSE) return NULL;
  913. hMainDC = ::GetDC(m_hWnd);
  914. hMemDC1 = ::CreateCompatibleDC(hMainDC);
  915. hMemDC2 = ::CreateCompatibleDC(hMainDC);
  916. if (hMainDC == NULL || hMemDC1 == NULL || hMemDC2 == NULL) return NULL;
  917.   
  918. if (::GetObject(csII.hbmColor, sizeof(BITMAP), &bmp))
  919. {
  920. csGrayII.hbmColor = ::CreateBitmap(csII.xHotspot*2, csII.yHotspot*2, bmp.bmPlanes, bmp.bmBitsPixel, NULL);
  921. if (csGrayII.hbmColor)
  922. {
  923. hOldBmp1 = (HBITMAP)::SelectObject(hMemDC1, csII.hbmColor);
  924. hOldBmp2 = (HBITMAP)::SelectObject(hMemDC2, csGrayII.hbmColor);
  926. ::BitBlt(hMemDC2, 0, 0, csII.xHotspot*2, csII.yHotspot*2, hMemDC1, 0, 0, SRCCOPY);
  928. DWORD dwLoopY = 0, dwLoopX = 0;
  929. COLORREF crPixel = 0;
  930. BYTE byNewPixel = 0;
  932. for (dwLoopY = 0; dwLoopY < csII.yHotspot*2; dwLoopY++)
  933. {
  934. for (dwLoopX = 0; dwLoopX < csII.xHotspot*2; dwLoopX++)
  935. {
  936. crPixel = ::GetPixel(hMemDC2, dwLoopX, dwLoopY);
  938. byNewPixel = (BYTE)((GetRValue(crPixel) * 0.299) + (GetGValue(crPixel) * 0.587) + (GetBValue(crPixel) * 0.114));
  939. if (crPixel) ::SetPixel(hMemDC2, dwLoopX, dwLoopY, RGB(byNewPixel, byNewPixel, byNewPixel));
  940. } // for
  941. } // for
  943. ::SelectObject(hMemDC1, hOldBmp1);
  944. ::SelectObject(hMemDC2, hOldBmp2);
  946. csGrayII.hbmMask = csII.hbmMask;
  948. csGrayII.fIcon = TRUE;
  949. hGrayIcon = ::CreateIconIndirect(&csGrayII);
  950. } // if
  952. ::DeleteObject(csGrayII.hbmColor);
  953. //::DeleteObject(csGrayII.hbmMask);
  954. } // if
  956. ::DeleteObject(csII.hbmColor);
  957. ::DeleteObject(csII.hbmMask);
  958. ::DeleteDC(hMemDC1);
  959. ::DeleteDC(hMemDC2);
  960. ::ReleaseDC(m_hWnd, hMainDC);
  962. return hGrayIcon;
  963. } // End of CreateGrayscaleIcon
  965. // This function assigns icons to the button.
  966. // Any previous icon or bitmap will be removed.
  967. //
  968. // Parameters:
  969. // [IN] nIconIn
  970. // ID number of the icon resource to show when the mouse is over the button.
  971. // Pass NULL to remove any icon from the button.
  972. // [IN] nIconOut
  973. // ID number of the icon resource to show when the mouse is outside the button.
  974. // Can be NULL.
  975. //
  976. // Return value:
  977. // BTNST_OK
  978. // Function executed successfully.
  979. // BTNST_INVALIDRESOURCE
  980. // Failed loading the specified resource.
  981. //
  982. DWORD CButtonST::SetIcon(int nIconIn, int nIconOut)
  983. {
  984. HICON hIconIn = NULL;
  985. HICON hIconOut = NULL;
  986. HINSTANCE hInstResource = NULL;
  988. // Find correct resource handle
  989. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nIconIn), RT_GROUP_ICON);
  991. // Set icon when the mouse is IN the button
  992. hIconIn = (HICON)::LoadImage(hInstResource, MAKEINTRESOURCE(nIconIn), IMAGE_ICON, 0, 0, 0);
  994.    // Set icon when the mouse is OUT the button
  995. if (nIconOut)
  996. {
  997. if (nIconOut == (int)BTNST_AUTO_GRAY)
  998. hIconOut = BTNST_AUTO_GRAY;
  999. else
  1000. hIconOut = (HICON)::LoadImage(hInstResource, MAKEINTRESOURCE(nIconOut), IMAGE_ICON, 0, 0, 0);
  1001. } // if
  1003. return SetIcon(hIconIn, hIconOut);
  1004. } // End of SetIcon
  1006. // This function assigns icons to the button.
  1007. // Any previous icon or bitmap will be removed.
  1008. //
  1009. // Parameters:
  1010. // [IN] hIconIn
  1011. // Handle fo the icon to show when the mouse is over the button.
  1012. // Pass NULL to remove any icon from the button.
  1013. // [IN] hIconOut
  1014. // Handle to the icon to show when the mouse is outside the button.
  1015. // Can be NULL.
  1016. //
  1017. // Return value:
  1018. // BTNST_OK
  1019. // Function executed successfully.
  1020. // BTNST_INVALIDRESOURCE
  1021. // Failed loading the specified resource.
  1022. //
  1023. DWORD CButtonST::SetIcon(HICON hIconIn, HICON hIconOut)
  1024. {
  1025. BOOL bRetValue;
  1026. ICONINFO ii;
  1028. // Free any loaded resource
  1029. FreeResources();
  1031. if (hIconIn)
  1032. {
  1033. // Icon when mouse over button?
  1034. m_csIcons[0].hIcon = hIconIn;
  1035. // Get icon dimension
  1036. ::ZeroMemory(&ii, sizeof(ICONINFO));
  1037. bRetValue = ::GetIconInfo(hIconIn, &ii);
  1038. if (bRetValue == FALSE)
  1039. {
  1040. FreeResources();
  1041. return BTNST_INVALIDRESOURCE;
  1042. } // if
  1044. m_csIcons[0].dwWidth = (DWORD)(ii.xHotspot * 2);
  1045. m_csIcons[0].dwHeight = (DWORD)(ii.yHotspot * 2);
  1046. ::DeleteObject(ii.hbmMask);
  1047. ::DeleteObject(ii.hbmColor);
  1049. // Icon when mouse outside button?
  1050. if (hIconOut)
  1051. {
  1052. if (hIconOut == BTNST_AUTO_GRAY)
  1053. {
  1054. hIconOut = CreateGrayscaleIcon(hIconIn);
  1055. } // if
  1057. m_csIcons[1].hIcon = hIconOut;
  1058. // Get icon dimension
  1059. ::ZeroMemory(&ii, sizeof(ICONINFO));
  1060. bRetValue = ::GetIconInfo(hIconOut, &ii);
  1061. if (bRetValue == FALSE)
  1062. {
  1063. FreeResources();
  1064. return BTNST_INVALIDRESOURCE;
  1065. } // if
  1067. m_csIcons[1].dwWidth = (DWORD)(ii.xHotspot * 2);
  1068. m_csIcons[1].dwHeight = (DWORD)(ii.yHotspot * 2);
  1069. ::DeleteObject(ii.hbmMask);
  1070. ::DeleteObject(ii.hbmColor);
  1071. } // if
  1072. } // if
  1074. Invalidate();
  1076. return BTNST_OK;
  1077. } // End of SetIcon
  1079. // This function assigns bitmaps to the button.
  1080. // Any previous icon or bitmap will be removed.
  1081. //
  1082. // Parameters:
  1083. // [IN] nBitmapIn
  1084. // ID number of the bitmap resource to show when the mouse is over the button.
  1085. // Pass NULL to remove any bitmap from the button.
  1086. // [IN] crTransColorIn
  1087. // Color (inside nBitmapIn) to be used as transparent color.
  1088. // [IN] nBitmapOut
  1089. // ID number of the bitmap resource to show when the mouse is outside the button.
  1090. // Can be NULL.
  1091. // [IN] crTransColorOut
  1092. // Color (inside nBitmapOut) to be used as transparent color.
  1093. //
  1094. // Return value:
  1095. // BTNST_OK
  1096. // Function executed successfully.
  1097. // BTNST_INVALIDRESOURCE
  1098. // Failed loading the specified resource.
  1099. // BTNST_FAILEDMASK
  1100. // Failed creating mask bitmap.
  1101. //
  1102. DWORD CButtonST::SetBitmaps(int nBitmapIn, COLORREF crTransColorIn, int nBitmapOut, COLORREF crTransColorOut)
  1103. {
  1104. HBITMAP hBitmapIn = NULL;
  1105. HBITMAP hBitmapOut = NULL;
  1106. HINSTANCE hInstResource = NULL;
  1108. // Find correct resource handle
  1109. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nBitmapIn), RT_BITMAP);
  1111. // Load bitmap In
  1112. hBitmapIn = (HBITMAP)::LoadImage(hInstResource, MAKEINTRESOURCE(nBitmapIn), IMAGE_BITMAP, 0, 0, 0);
  1114. // Load bitmap Out
  1115. if (nBitmapOut)
  1116. hBitmapOut = (HBITMAP)::LoadImage(hInstResource, MAKEINTRESOURCE(nBitmapOut), IMAGE_BITMAP, 0, 0, 0);
  1118. return SetBitmaps(hBitmapIn, crTransColorIn, hBitmapOut, crTransColorOut);
  1119. } // End of SetBitmaps
  1121. // This function assigns bitmaps to the button.
  1122. // Any previous icon or bitmap will be removed.
  1123. //
  1124. // Parameters:
  1125. // [IN] hBitmapIn
  1126. // Handle fo the bitmap to show when the mouse is over the button.
  1127. // Pass NULL to remove any bitmap from the button.
  1128. // [IN] crTransColorIn
  1129. // Color (inside hBitmapIn) to be used as transparent color.
  1130. // [IN] hBitmapOut
  1131. // Handle to the bitmap to show when the mouse is outside the button.
  1132. // Can be NULL.
  1133. // [IN] crTransColorOut
  1134. // Color (inside hBitmapOut) to be used as transparent color.
  1135. //
  1136. // Return value:
  1137. // BTNST_OK
  1138. // Function executed successfully.
  1139. // BTNST_INVALIDRESOURCE
  1140. // Failed loading the specified resource.
  1141. // BTNST_FAILEDMASK
  1142. // Failed creating mask bitmap.
  1143. //
  1144. DWORD CButtonST::SetBitmaps(HBITMAP hBitmapIn, COLORREF crTransColorIn, HBITMAP hBitmapOut, COLORREF crTransColorOut)
  1145. {
  1146. int nRetValue;
  1147. BITMAP csBitmapSize;
  1149. // Free any loaded resource
  1150. FreeResources();
  1152. if (hBitmapIn)
  1153. {
  1154. m_csBitmaps[0].hBitmap = hBitmapIn;
  1155. m_csBitmaps[0].crTransparent = crTransColorIn;
  1156. // Get bitmap size
  1157. nRetValue = ::GetObject(hBitmapIn, sizeof(csBitmapSize), &csBitmapSize);
  1158. if (nRetValue == 0)
  1159. {
  1160. FreeResources();
  1161. return BTNST_INVALIDRESOURCE;
  1162. } // if
  1163. m_csBitmaps[0].dwWidth = (DWORD)csBitmapSize.bmWidth;
  1164. m_csBitmaps[0].dwHeight = (DWORD)csBitmapSize.bmHeight;
  1166. // Create mask for bitmap In
  1167. m_csBitmaps[0].hMask = CreateBitmapMask(hBitmapIn, m_csBitmaps[0].dwWidth, m_csBitmaps[0].dwHeight, crTransColorIn);
  1168. if (m_csBitmaps[0].hMask == NULL)
  1169. {
  1170. FreeResources();
  1171. return BTNST_FAILEDMASK;
  1172. } // if
  1174. if (hBitmapOut)
  1175. {
  1176. m_csBitmaps[1].hBitmap = hBitmapOut;
  1177. m_csBitmaps[1].crTransparent = crTransColorOut;
  1178. // Get bitmap size
  1179. nRetValue = ::GetObject(hBitmapOut, sizeof(csBitmapSize), &csBitmapSize);
  1180. if (nRetValue == 0)
  1181. {
  1182. FreeResources();
  1183. return BTNST_INVALIDRESOURCE;
  1184. } // if
  1185. m_csBitmaps[1].dwWidth = (DWORD)csBitmapSize.bmWidth;
  1186. m_csBitmaps[1].dwHeight = (DWORD)csBitmapSize.bmHeight;
  1188. // Create mask for bitmap Out
  1189. m_csBitmaps[1].hMask = CreateBitmapMask(hBitmapOut, m_csBitmaps[1].dwWidth, m_csBitmaps[1].dwHeight, crTransColorOut);
  1190. if (m_csBitmaps[1].hMask == NULL)
  1191. {
  1192. FreeResources();
  1193. return BTNST_FAILEDMASK;
  1194. } // if
  1195. } // if
  1196. } // if
  1198. Invalidate();
  1200. return BTNST_OK;
  1201. } // End of SetBitmaps
  1203. // This functions sets the button to have a standard or flat style.
  1204. //
  1205. // Parameters:
  1206. // [IN] bFlat
  1207. // If TRUE the button will have a flat style, else
  1208. // will have a standard style.
  1209. // By default, CButtonST buttons are flat.
  1210. // [IN] bRepaint
  1211. // If TRUE the control will be repainted.
  1212. //
  1213. // Return value:
  1214. // BTNST_OK
  1215. // Function executed successfully.
  1216. //
  1217. DWORD CButtonST::SetFlat(BOOL bFlat, BOOL bRepaint)
  1218. {
  1219. m_bIsFlat = bFlat;
  1220. if (bRepaint) Invalidate();
  1222. return BTNST_OK;
  1223. } // End of SetFlat
  1225. // This function sets the alignment type between icon/bitmap and text.
  1226. //
  1227. // Parameters:
  1228. // [IN] byAlign
  1229. // Alignment type. Can be one of the following values:
  1230. // ST_ALIGN_HORIZ Icon/bitmap on the left, text on the right
  1231. // ST_ALIGN_VERT Icon/bitmap on the top, text on the bottom
  1232. // ST_ALIGN_HORIZ_RIGHT Icon/bitmap on the right, text on the left
  1233. // By default, CButtonST buttons have ST_ALIGN_HORIZ alignment.
  1234. // [IN] bRepaint
  1235. // If TRUE the control will be repainted.
  1236. //
  1237. // Return value:
  1238. // BTNST_OK
  1239. // Function executed successfully.
  1240. // BTNST_INVALIDALIGN
  1241. // Alignment type not supported.
  1242. //
  1243. DWORD CButtonST::SetAlign(BYTE byAlign, BOOL bRepaint)
  1244. {
  1245. switch (byAlign)
  1246. {    
  1247. case ST_ALIGN_HORIZ:
  1248. case ST_ALIGN_HORIZ_RIGHT:
  1249. case ST_ALIGN_VERT:
  1250. m_byAlign = byAlign;
  1251. if (bRepaint) Invalidate();
  1252. return BTNST_OK;
  1253. break;
  1254. } // switch
  1256. return BTNST_INVALIDALIGN;
  1257. } // End of SetAlign
  1259. // This function sets the state of the checkbox.
  1260. // If the button is not a checkbox, this function has no meaning.
  1261. //
  1262. // Parameters:
  1263. // [IN] nCheck
  1264. // 1 to check the checkbox.
  1265. // 0 to un-check the checkbox.
  1266. // [IN] bRepaint
  1267. // If TRUE the control will be repainted.
  1268. //
  1269. // Return value:
  1270. // BTNST_OK
  1271. // Function executed successfully.
  1272. //
  1273. DWORD CButtonST::SetCheck(int nCheck, BOOL bRepaint)
  1274. {
  1275. if (m_bIsCheckBox)
  1276. {
  1277. if (nCheck == 0) m_nCheck = 0;
  1278. else m_nCheck = 1;
  1280. if (bRepaint) Invalidate();
  1281. } // if
  1283. return BTNST_OK;
  1284. } // End of SetCheck
  1286. // This function returns the current state of the checkbox.
  1287. // If the button is not a checkbox, this function has no meaning.
  1288. //
  1289. // Return value:
  1290. // The current state of the checkbox.
  1291. // 1 if checked.
  1292. // 0 if not checked or the button is not a checkbox.
  1293. //
  1294. int CButtonST::GetCheck()
  1295. {
  1296. return m_nCheck;
  1297. } // End of GetCheck
  1299. // This function sets all colors to a default value.
  1300. //
  1301. // Parameters:
  1302. // [IN] bRepaint
  1303. // If TRUE the control will be repainted.
  1304. //
  1305. // Return value:
  1306. // BTNST_OK
  1307. // Function executed successfully.
  1308. //
  1309. DWORD CButtonST::SetDefaultColors(BOOL bRepaint)
  1310. {
  1311. m_crColors[BTNST_COLOR_BK_IN] = ::GetSysColor(COLOR_BTNFACE);
  1312. m_crColors[BTNST_COLOR_FG_IN] = ::GetSysColor(COLOR_BTNTEXT);
  1313. m_crColors[BTNST_COLOR_BK_OUT] = ::GetSysColor(COLOR_BTNFACE);
  1314. m_crColors[BTNST_COLOR_FG_OUT] = ::GetSysColor(COLOR_BTNTEXT);
  1315. m_crColors[BTNST_COLOR_BK_FOCUS] = ::GetSysColor(COLOR_BTNFACE);
  1316. m_crColors[BTNST_COLOR_FG_FOCUS] = ::GetSysColor(COLOR_BTNTEXT);
  1318. if (bRepaint) Invalidate();
  1320. return BTNST_OK;
  1321. } // End of SetDefaultColors
  1323. // This function sets the color to use for a particular state.
  1324. //
  1325. // Parameters:
  1326. // [IN] byColorIndex
  1327. // Index of the color to set. Can be one of the following values:
  1328. // BTNST_COLOR_BK_IN Background color when mouse is over the button
  1329. // BTNST_COLOR_FG_IN Text color when mouse is over the button
  1330. // BTNST_COLOR_BK_OUT Background color when mouse is outside the button
  1331. // BTNST_COLOR_FG_OUT Text color when mouse is outside the button
  1332. // BTNST_COLOR_BK_FOCUS Background color when the button is focused
  1333. // BTNST_COLOR_FG_FOCUS Text color when the button is focused
  1334. // [IN] crColor
  1335. // New color.
  1336. // [IN] bRepaint
  1337. // If TRUE the control will be repainted.
  1338. //
  1339. // Return value:
  1340. // BTNST_OK
  1341. // Function executed successfully.
  1342. // BTNST_INVALIDINDEX
  1343. // Invalid color index.
  1344. //
  1345. DWORD CButtonST::SetColor(BYTE byColorIndex, COLORREF crColor, BOOL bRepaint)
  1346. {
  1347. if (byColorIndex >= BTNST_MAX_COLORS) return BTNST_INVALIDINDEX;
  1349. // Set new color
  1350. m_crColors[byColorIndex] = crColor;
  1352. if (bRepaint) Invalidate();
  1354. return BTNST_OK;
  1355. } // End of SetColor
  1357. // This functions returns the color used for a particular state.
  1358. //
  1359. // Parameters:
  1360. // [IN] byColorIndex
  1361. // Index of the color to get.
  1362. // See SetColor for the list of available colors.
  1363. // [OUT] crpColor
  1364. // A pointer to a COLORREF that will receive the color.
  1365. //
  1366. // Return value:
  1367. // BTNST_OK
  1368. // Function executed successfully.
  1369. // BTNST_INVALIDINDEX
  1370. // Invalid color index.
  1371. //
  1372. DWORD CButtonST::GetColor(BYTE byColorIndex, COLORREF* crpColor)
  1373. {
  1374. if (byColorIndex >= BTNST_MAX_COLORS) return BTNST_INVALIDINDEX;
  1376. // Get color
  1377. *crpColor = m_crColors[byColorIndex];
  1379. return BTNST_OK;
  1380. } // End of GetColor
  1382. // This function applies an offset to the RGB components of the specified color.
  1383. // This function can be seen as an easy way to make a color darker or lighter than
  1384. // its default value.
  1385. //
  1386. // Parameters:
  1387. // [IN] byColorIndex
  1388. // Index of the color to set.
  1389. // See SetColor for the list of available colors.
  1390. // [IN] shOffsetColor
  1391. // A short value indicating the offset to apply to the color.
  1392. // This value must be between -255 and 255.
  1393. // [IN] bRepaint
  1394. // If TRUE the control will be repainted.
  1395. //
  1396. // Return value:
  1397. // BTNST_OK
  1398. // Function executed successfully.
  1399. // BTNST_INVALIDINDEX
  1400. // Invalid color index.
  1401. // BTNST_BADPARAM
  1402. // The specified offset is out of range.
  1403. //
  1404. DWORD CButtonST::OffsetColor(BYTE byColorIndex, short shOffset, BOOL bRepaint)
  1405. {
  1406. BYTE byRed = 0;
  1407. BYTE byGreen = 0;
  1408. BYTE byBlue = 0;
  1409. short shOffsetR = shOffset;
  1410. short shOffsetG = shOffset;
  1411. short shOffsetB = shOffset;
  1413. if (byColorIndex >= BTNST_MAX_COLORS) return BTNST_INVALIDINDEX;
  1414. if (shOffset < -255 || shOffset > 255) return BTNST_BADPARAM;
  1416. // Get RGB components of specified color
  1417. byRed = GetRValue(m_crColors[byColorIndex]);
  1418. byGreen = GetGValue(m_crColors[byColorIndex]);
  1419. byBlue = GetBValue(m_crColors[byColorIndex]);
  1421. // Calculate max. allowed real offset
  1422. if (shOffset > 0)
  1423. {
  1424. if (byRed + shOffset > 255) shOffsetR = 255 - byRed;
  1425. if (byGreen + shOffset > 255) shOffsetG = 255 - byGreen;
  1426. if (byBlue + shOffset > 255) shOffsetB = 255 - byBlue;
  1428. shOffset = min(min(shOffsetR, shOffsetG), shOffsetB);
  1429. } // if
  1430. else
  1431. {
  1432. if (byRed + shOffset < 0) shOffsetR = -byRed;
  1433. if (byGreen + shOffset < 0) shOffsetG = -byGreen;
  1434. if (byBlue + shOffset < 0) shOffsetB = -byBlue;
  1436. shOffset = max(max(shOffsetR, shOffsetG), shOffsetB);
  1437. } // else
  1439. // Set new color
  1440. m_crColors[byColorIndex] = RGB(byRed + shOffset, byGreen + shOffset, byBlue + shOffset);
  1442. if (bRepaint) Invalidate();
  1444. return BTNST_OK;
  1445. } // End of OffsetColor
  1447. // This function sets the hilight logic for the button.
  1448. // Applies only to flat buttons.
  1449. //
  1450. // Parameters:
  1451. // [IN] bAlwaysTrack
  1452. // If TRUE the button will be hilighted even if the window that owns it, is
  1453. // not the active window.
  1454. // If FALSE the button will be hilighted only if the window that owns it,
  1455. // is the active window.
  1456. //
  1457. // Return value:
  1458. // BTNST_OK
  1459. // Function executed successfully.
  1460. //
  1461. DWORD CButtonST::SetAlwaysTrack(BOOL bAlwaysTrack)
  1462. {
  1463. m_bAlwaysTrack = bAlwaysTrack;
  1464. return BTNST_OK;
  1465. } // End of SetAlwaysTrack
  1467. // This function sets the cursor to be used when the mouse is over the button.
  1468. //
  1469. // Parameters:
  1470. // [IN] nCursorId
  1471. // ID number of the cursor resource.
  1472. // Pass NULL to remove a previously loaded cursor.
  1473. // [IN] bRepaint
  1474. // If TRUE the control will be repainted.
  1475. //
  1476. // Return value:
  1477. // BTNST_OK
  1478. // Function executed successfully.
  1479. // BTNST_INVALIDRESOURCE
  1480. // Failed loading the specified resource.
  1481. //
  1482. DWORD CButtonST::SetBtnCursor(int nCursorId, BOOL bRepaint)
  1483. {
  1484. HINSTANCE hInstResource = NULL;
  1485. // Destroy any previous cursor
  1486. if (m_hCursor)
  1487. {
  1488. ::DestroyCursor(m_hCursor);
  1489. m_hCursor = NULL;
  1490. } // if
  1492. // Load cursor
  1493. if (nCursorId)
  1494. {
  1495. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nCursorId), RT_GROUP_CURSOR);
  1496. // Load cursor resource
  1497. m_hCursor = (HCURSOR)::LoadImage(hInstResource, MAKEINTRESOURCE(nCursorId), IMAGE_CURSOR, 0, 0, 0);
  1498. // Repaint the button
  1499. if (bRepaint) Invalidate();
  1500. // If something wrong
  1501. if (m_hCursor == NULL) return BTNST_INVALIDRESOURCE;
  1502. } // if
  1504. return BTNST_OK;
  1505. } // End of SetBtnCursor
  1507. // This function sets if the button border must be drawn.
  1508. // Applies only to flat buttons.
  1509. //
  1510. // Parameters:
  1511. // [IN] bDrawBorder
  1512. // If TRUE the border will be drawn.
  1513. // [IN] bRepaint
  1514. // If TRUE the control will be repainted.
  1515. //
  1516. // Return value:
  1517. // BTNST_OK
  1518. // Function executed successfully.
  1519. //
  1520. DWORD CButtonST::DrawBorder(BOOL bDrawBorder, BOOL bRepaint)
  1521. {
  1522. m_bDrawBorder = bDrawBorder;
  1523. // Repaint the button
  1524. if (bRepaint) Invalidate();
  1526. return BTNST_OK;
  1527. } // End of DrawBorder
  1529. // This function sets if the focus rectangle must be drawn for flat buttons.
  1530. //
  1531. // Parameters:
  1532. // [IN] bDrawFlatFocus
  1533. // If TRUE the focus rectangle will be drawn also for flat buttons.
  1534. // [IN] bRepaint
  1535. // If TRUE the control will be repainted.
  1536. //
  1537. // Return value:
  1538. // BTNST_OK
  1539. // Function executed successfully.
  1540. //
  1541. DWORD CButtonST::DrawFlatFocus(BOOL bDrawFlatFocus, BOOL bRepaint)
  1542. {
  1543. m_bDrawFlatFocus = bDrawFlatFocus;
  1544. // Repaint the button
  1545. if (bRepaint) Invalidate();
  1547. return BTNST_OK;
  1548. } // End of DrawFlatFocus
  1550. void CButtonST::InitToolTip()
  1551. {
  1552. if (m_ToolTip.m_hWnd == NULL)
  1553. {
  1554. // Create ToolTip control
  1555. m_ToolTip.Create(this);
  1556. // Create inactive
  1557. m_ToolTip.Activate(FALSE);
  1558. // Enable multiline
  1559. m_ToolTip.SendMessage(TTM_SETMAXTIPWIDTH, 0, 400);
  1560. } // if
  1561. } // End of InitToolTip
  1563. // This function sets the text to show in the button tooltip.
  1564. //
  1565. // Parameters:
  1566. // [IN] nText
  1567. // ID number of the string resource containing the text to show.
  1568. // [IN] bActivate
  1569. // If TRUE the tooltip will be created active.
  1570. //
  1571. void CButtonST::SetTooltipText(int nText, BOOL bActivate)
  1572. {
  1573. CString sText;
  1575. // Load string resource
  1576. sText.LoadString(nText);
  1577. // If string resource is not empty
  1578. if (sText.IsEmpty() == FALSE) SetTooltipText((LPCTSTR)sText, bActivate);
  1579. } // End of SetTooltipText
  1581. // This function sets the text to show in the button tooltip.
  1582. //
  1583. // Parameters:
  1584. // [IN] lpszText
  1585. // Pointer to a null-terminated string containing the text to show.
  1586. // [IN] bActivate
  1587. // If TRUE the tooltip will be created active.
  1588. //
  1589. void CButtonST::SetTooltipText(LPCTSTR lpszText, BOOL bActivate)
  1590. {
  1591. // We cannot accept NULL pointer
  1592. if (lpszText == NULL) return;
  1594. // Initialize ToolTip
  1595. InitToolTip();
  1597. // If there is no tooltip defined then add it
  1598. if (m_ToolTip.GetToolCount() == 0)
  1599. {
  1600. CRect rectBtn; 
  1601. GetClientRect(rectBtn);
  1602. m_ToolTip.AddTool(this, lpszText, rectBtn, 1);
  1603. } // if
  1605. // Set text for tooltip
  1606. m_ToolTip.UpdateTipText(lpszText, this, 1);
  1607. m_ToolTip.Activate(bActivate);
  1608. } // End of SetTooltipText
  1610. // This function enables or disables the button tooltip.
  1611. //
  1612. // Parameters:
  1613. // [IN] bActivate
  1614. // If TRUE the tooltip will be activated.
  1615. //
  1616. void CButtonST::ActivateTooltip(BOOL bActivate)
  1617. {
  1618. // If there is no tooltip then do nothing
  1619. if (m_ToolTip.GetToolCount() == 0) return;
  1621. // Activate tooltip
  1622. m_ToolTip.Activate(bActivate);
  1623. } // End of EnableTooltip
  1625. // This function returns if the button is the default button.
  1626. //
  1627. // Return value:
  1628. // TRUE
  1629. // The button is the default button.
  1630. // FALSE
  1631. // The button is not the default button.
  1632. //
  1633. BOOL CButtonST::GetDefault()
  1634. {
  1635. return m_bIsDefault;
  1636. } // End of GetDefault
  1638. // This function enables the transparent mode.
  1639. // Note: this operation is not reversible.
  1640. // DrawTransparent should be called just after the button is created.
  1641. // Do not use trasparent buttons until you really need it (you have a bitmapped
  1642. // background) since each transparent button makes a copy in memory of its background.
  1643. // This may bring unnecessary memory use and execution overload.
  1644. //
  1645. // Parameters:
  1646. // [IN] bRepaint
  1647. // If TRUE the control will be repainted.
  1648. //
  1649. void CButtonST::DrawTransparent(BOOL bRepaint)
  1650. {
  1651. m_bDrawTransparent = TRUE;
  1653. // Restore old bitmap (if any)
  1654. if (m_dcBk.m_hDC != NULL && m_pbmpOldBk != NULL)
  1655. {
  1656. m_dcBk.SelectObject(m_pbmpOldBk);
  1657. } // if
  1659. m_bmpBk.DeleteObject();
  1660. m_dcBk.DeleteDC();
  1662. // Repaint the button
  1663. if (bRepaint) Invalidate();
  1664. } // End of DrawTransparent
  1666. // This function sets the URL that will be opened when the button is clicked.
  1667. //
  1668. // Parameters:
  1669. // [IN] lpszURL
  1670. // Pointer to a null-terminated string that contains the URL.
  1671. // Pass NULL to removed any previously specified URL.
  1672. //
  1673. // Return value:
  1674. // BTNST_OK
  1675. // Function executed successfully.
  1676. //
  1677. DWORD CButtonST::SetURL(LPCTSTR lpszURL)
  1678. {
  1679. // Remove any existing URL
  1680. memset(m_szURL, 0, sizeof(m_szURL));
  1682. if (lpszURL)
  1683. {
  1684. // Store the URL
  1685. _tcsncpy(m_szURL, lpszURL, _MAX_PATH);
  1686. } // if
  1688. return BTNST_OK;
  1689. } // End of SetURL
  1691. // This function associates a menu to the button.
  1692. // The menu will be displayed clicking the button.
  1693. //
  1694. // Parameters:
  1695. // [IN] nMenu
  1696. // ID number of the menu resource.
  1697. // Pass NULL to remove any menu from the button.
  1698. // [IN] hParentWnd
  1699. // Handle to the window that owns the menu.
  1700. // This window receives all messages from the menu.
  1701. // [IN] bRepaint
  1702. // If TRUE the control will be repainted.
  1703. //
  1704. // Return value:
  1705. // BTNST_OK
  1706. // Function executed successfully.
  1707. // BTNST_INVALIDRESOURCE
  1708. // Failed loading the specified resource.
  1709. //
  1710. #ifndef BTNST_USE_BCMENU
  1711. DWORD CButtonST::SetMenu(UINT nMenu, HWND hParentWnd, BOOL bRepaint)
  1712. {
  1713. HINSTANCE hInstResource = NULL;
  1715. // Destroy any previous menu
  1716. if (m_hMenu)
  1717. {
  1718. ::DestroyMenu(m_hMenu);
  1719. m_hMenu = NULL;
  1720. m_hParentWndMenu = NULL;
  1721. m_bMenuDisplayed = FALSE;
  1722. } // if
  1724. // Load menu
  1725. if (nMenu)
  1726. {
  1727. // Find correct resource handle
  1728. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nMenu), RT_MENU);
  1729. // Load menu resource
  1730. m_hMenu = ::LoadMenu(hInstResource, MAKEINTRESOURCE(nMenu));
  1731. m_hParentWndMenu = hParentWnd;
  1732. // If something wrong
  1733. if (m_hMenu == NULL) return BTNST_INVALIDRESOURCE;
  1734. } // if
  1736. // Repaint the button
  1737. if (bRepaint) Invalidate();
  1739. return BTNST_OK;
  1740. } // End of SetMenu
  1741. #endif
  1743. // This function associates a menu to the button.
  1744. // The menu will be displayed clicking the button.
  1745. // The menu will be handled by the BCMenu class.
  1746. //
  1747. // Parameters:
  1748. // [IN] nMenu
  1749. // ID number of the menu resource.
  1750. // Pass NULL to remove any menu from the button.
  1751. // [IN] hParentWnd
  1752. // Handle to the window that owns the menu.
  1753. // This window receives all messages from the menu.
  1754. // [IN] bWinXPStyle
  1755. // If TRUE the menu will be displayed using the new Windows XP style.
  1756. // If FALSE the menu will be displayed using the standard style.
  1757. // [IN] nToolbarID
  1758. // Resource ID of the toolbar to be associated to the menu.
  1759. // [IN] sizeToolbarIcon
  1760. // A CSize object indicating the size (in pixels) of each icon into the toolbar.
  1761. // All icons into the toolbar must have the same size.
  1762. // [IN] crToolbarBk
  1763. // A COLORREF value indicating the color to use as background for the icons into the toolbar.
  1764. // This color will be used as the "transparent" color.
  1765. // [IN] bRepaint
  1766. // If TRUE the control will be repainted.
  1767. //
  1768. // Return value:
  1769. // BTNST_OK
  1770. // Function executed successfully.
  1771. // BTNST_INVALIDRESOURCE
  1772. // Failed loading the specified resource.
  1773. //
  1774. #ifdef BTNST_USE_BCMENU
  1775. DWORD CButtonST::SetMenu(UINT nMenu, HWND hParentWnd, BOOL bWinXPStyle, UINT nToolbarID, CSize sizeToolbarIcon, COLORREF crToolbarBk, BOOL bRepaint)
  1776. {
  1777. BOOL bRetValue = FALSE;
  1779. // Destroy any previous menu
  1780. if (m_menuPopup.m_hMenu)
  1781. {
  1782. m_menuPopup.DestroyMenu();
  1783. m_hParentWndMenu = NULL;
  1784. m_bMenuDisplayed = FALSE;
  1785. } // if
  1787. // Load menu
  1788. if (nMenu)
  1789. {
  1790. m_menuPopup.SetMenuDrawMode(bWinXPStyle);
  1791. // Load menu
  1792. bRetValue = m_menuPopup.LoadMenu(nMenu);
  1793. // If something wrong
  1794. if (bRetValue == FALSE) return BTNST_INVALIDRESOURCE;
  1796. // Load toolbar
  1797. if (nToolbarID)
  1798. {
  1799. m_menuPopup.SetBitmapBackground(crToolbarBk);
  1800. m_menuPopup.SetIconSize(sizeToolbarIcon.cx, sizeToolbarIcon.cy);
  1802. bRetValue = m_menuPopup.LoadToolbar(nToolbarID);
  1803. // If something wrong
  1804. if (bRetValue == FALSE) 
  1805. {
  1806. m_menuPopup.DestroyMenu();
  1807. return BTNST_INVALIDRESOURCE;
  1808. } // if
  1809. } // if
  1811. m_hParentWndMenu = hParentWnd;
  1812. } // if
  1814. // Repaint the button
  1815. if (bRepaint) Invalidate();
  1817. return BTNST_OK;
  1818. } // End of SetMenu
  1819. #endif
  1821. // This function is called every time the button background needs to be painted.
  1822. // If the button is in transparent mode this function will NOT be called.
  1823. // This is a virtual function that can be rewritten in CButtonST-derived classes
  1824. // to produce a whole range of buttons not available by default.
  1825. //
  1826. // Parameters:
  1827. // [IN] pDC
  1828. // Pointer to a CDC object that indicates the device context.
  1829. // [IN] pRect
  1830. // Pointer to a CRect object that indicates the bounds of the
  1831. // area to be painted.
  1832. //
  1833. // Return value:
  1834. // BTNST_OK
  1835. // Function executed successfully.
  1836. //
  1837. DWORD CButtonST::OnDrawBackground(CDC* pDC, LPCRECT pRect)
  1838. {
  1839. COLORREF crColor;
  1841. if (m_bMouseOnButton || m_bIsPressed)
  1842. crColor = m_crColors[BTNST_COLOR_BK_IN];
  1843. else
  1844. {
  1845. if (m_bIsFocused)
  1846. crColor = m_crColors[BTNST_COLOR_BK_FOCUS];
  1847. else
  1848. crColor = m_crColors[BTNST_COLOR_BK_OUT];
  1849. } // else
  1851. CBrush brBackground(crColor);
  1853. pDC->FillRect(pRect, &brBackground);
  1855. return BTNST_OK;
  1856. } // End of OnDrawBackground
  1858. // This function is called every time the button border needs to be painted.
  1859. // If the button is in standard (not flat) mode this function will NOT be called.
  1860. // This is a virtual function that can be rewritten in CButtonST-derived classes
  1861. // to produce a whole range of buttons not available by default.
  1862. //
  1863. // Parameters:
  1864. // [IN] pDC
  1865. // Pointer to a CDC object that indicates the device context.
  1866. // [IN] pRect
  1867. // Pointer to a CRect object that indicates the bounds of the
  1868. // area to be painted.
  1869. //
  1870. // Return value:
  1871. // BTNST_OK
  1872. // Function executed successfully.
  1873. //
  1874. DWORD CButtonST::OnDrawBorder(CDC* pDC, LPCRECT pRect)
  1875. {
  1876. if (m_bIsPressed)
  1877. pDC->Draw3dRect(pRect, ::GetSysColor(COLOR_BTNSHADOW), ::GetSysColor(COLOR_BTNHILIGHT));
  1878. else
  1879. pDC->Draw3dRect(pRect, ::GetSysColor(COLOR_BTNHILIGHT), ::GetSysColor(COLOR_BTNSHADOW));
  1881. return BTNST_OK;
  1882. } // End of OnDrawBorder
  1884. #undef BS_TYPEMASK