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

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

Linux/Unix编程

开发平台：

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; // @@ I change this default value to TRUE!!!
  30.   
  31. // By default draw border in "flat" button 
  32. m_bDrawBorder = TRUE; 
  33.   
  34. // By default icon is aligned horizontally
  35. m_byAlign = ST_ALIGN_HORIZ; 
  36.   
  37. // By default, for "flat" button, don't draw the focus rect
  38. m_bDrawFlatFocus = FALSE;
  40. // By default the button is not the default button
  41. m_bIsDefault = FALSE;
  42. // Invalid value, since type still unknown
  43. m_nTypeStyle = BS_TYPEMASK;
  45. // By default the button is not a checkbox
  46. m_bIsCheckBox = FALSE;
  47. m_nCheck = 0;
  49. // Set default colors
  50. SetDefaultColors(FALSE);
  52. // No tooltip created
  53. m_ToolTip.m_hWnd = NULL;
  55. // Do not draw as a transparent button
  56. m_bDrawTransparent = FALSE;
  57. m_pbmpOldBk = NULL;
  59. // No URL defined
  60. SetURL(NULL);
  62. // No cursor defined
  63. m_hCursor = NULL;
  65. // No associated menu
  66. m_hMenu = NULL;
  67. m_hParentWndMenu = NULL;
  68. m_bMenuDisplayed = FALSE;
  70. } // End of CButtonST
  72. CButtonST::~CButtonST()
  73. {
  74. // Restore old bitmap (if any)
  75. if (m_dcBk.m_hDC && m_pbmpOldBk)
  76. {
  77. m_dcBk.SelectObject(m_pbmpOldBk);
  78. } // if
  80. FreeResources();
  82. // Destroy the cursor (if any)
  83. if (m_hCursor) ::DestroyCursor(m_hCursor);
  85. // Destroy the menu (if any)
  86. if (m_hMenu) ::DestroyMenu(m_hMenu);
  87. } // End of ~CButtonST
  89. BEGIN_MESSAGE_MAP(CButtonST, CButton)
  90.     //{{AFX_MSG_MAP(CButtonST)
  91. ON_WM_SETCURSOR()
  92. ON_WM_KILLFOCUS()
  93. ON_WM_MOUSEMOVE()
  94. ON_WM_SYSCOLORCHANGE()
  95. ON_CONTROL_REFLECT_EX(BN_CLICKED, OnClicked)
  96. ON_WM_ACTIVATE()
  97. ON_WM_ENABLE()
  98. ON_WM_CANCELMODE()
  99. ON_WM_GETDLGCODE()
  100. ON_WM_CTLCOLOR_REFLECT()
  101. //}}AFX_MSG_MAP
  102. ON_MESSAGE(BM_SETSTYLE, OnSetStyle)
  103. ON_MESSAGE(WM_MOUSELEAVE, OnMouseLeave)
  104. END_MESSAGE_MAP()
  106. void CButtonST::FreeResources(BOOL bCheckForNULL)
  107. {
  108. if (bCheckForNULL)
  109. {
  110. // Destroy icons
  111. // Note: the following two lines MUST be here! even if
  112. // BoundChecker says they are unnecessary!
  113. if (m_csIcons[0].hIcon) ::DestroyIcon(m_csIcons[0].hIcon);
  114. if (m_csIcons[1].hIcon) ::DestroyIcon(m_csIcons[1].hIcon);
  116. // Destroy bitmaps
  117. if (m_csBitmaps[0].hBitmap) ::DeleteObject(m_csBitmaps[0].hBitmap);
  118. if (m_csBitmaps[1].hBitmap) ::DeleteObject(m_csBitmaps[1].hBitmap);
  120. // Destroy mask bitmaps
  121. if (m_csBitmaps[0].hMask) ::DeleteObject(m_csBitmaps[0].hMask);
  122. if (m_csBitmaps[1].hMask) ::DeleteObject(m_csBitmaps[1].hMask);
  123. } // if
  125. ::ZeroMemory(&m_csIcons, sizeof(m_csIcons));
  126. ::ZeroMemory(&m_csBitmaps, sizeof(m_csBitmaps));
  127. } // End of FreeResources
  129. void CButtonST::PreSubclassWindow() 
  130. {
  131. UINT nBS;
  133. nBS = GetButtonStyle();
  135. // Set initial control type
  136. m_nTypeStyle = nBS & BS_TYPEMASK;
  138. // Check if this is a checkbox
  139. if (nBS & BS_CHECKBOX) m_bIsCheckBox = TRUE;
  141. // Set initial default state flag
  142. if (m_nTypeStyle == BS_DEFPUSHBUTTON)
  143. {
  144. // Set default state for a default button
  145. m_bIsDefault = TRUE;
  147. // Adjust style for default button
  148. m_nTypeStyle = BS_PUSHBUTTON;
  149. } // If
  151. // You should not set the Owner Draw before this call
  152. // (don't use the resource editor "Owner Draw" or
  153. // ModifyStyle(0, BS_OWNERDRAW) before calling PreSubclassWindow() )
  154. ASSERT(m_nTypeStyle != BS_OWNERDRAW);
  156. // Switch to owner-draw
  157. ModifyStyle(BS_TYPEMASK, BS_OWNERDRAW, SWP_FRAMECHANGED);
  159. CButton::PreSubclassWindow();
  160. } // End of PreSubclassWindow
  162. UINT CButtonST::OnGetDlgCode() 
  163. {
  164. UINT nCode = CButton::OnGetDlgCode();
  166. // Tell the system if we want default state handling
  167. // (losing default state always allowed)
  168. nCode |= (m_bIsDefault ? DLGC_DEFPUSHBUTTON : DLGC_UNDEFPUSHBUTTON);
  170. return nCode;
  171. } // End of OnGetDlgCode
  173. BOOL CButtonST::PreTranslateMessage(MSG* pMsg) 
  174. {
  175. InitToolTip();
  176. m_ToolTip.RelayEvent(pMsg);
  178. return CButton::PreTranslateMessage(pMsg);
  179. } // End of PreTranslateMessage
  181. LRESULT CButtonST::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  182. {
  183. if (message == WM_LBUTTONDBLCLK)
  184. {
  185. message = WM_LBUTTONDOWN;
  186. } // if
  187. return CButton::DefWindowProc(message, wParam, lParam);
  188. } // End of DefWindowProc
  190. HBRUSH CButtonST::CtlColor(CDC* pDC, UINT nCtlColor) 
  191. {
  192. return (HBRUSH)::GetStockObject(NULL_BRUSH); 
  193. } // End of CtlColor
  195. void CButtonST::OnSysColorChange() 
  196. {
  197. CButton::OnSysColorChange();
  199. m_dcBk.DeleteDC();
  200. m_bmpBk.DeleteObject();
  201. } // End of OnSysColorChange
  203. LRESULT CButtonST::OnSetStyle(WPARAM wParam, LPARAM lParam)
  204. {
  205. UINT nNewType = (wParam & BS_TYPEMASK);
  207. // Update default state flag
  208. if (nNewType == BS_DEFPUSHBUTTON)
  209. {
  210. m_bIsDefault = TRUE;
  211. } // if
  212. else if (nNewType == BS_PUSHBUTTON)
  213. {
  214. // Losing default state always allowed
  215. m_bIsDefault = FALSE;
  216. } // if
  218. // Can't change control type after owner-draw is set.
  219. // Let the system process changes to other style bits
  220. // and redrawing, while keeping owner-draw style
  221. return DefWindowProc(BM_SETSTYLE,
  222. (wParam & ~BS_TYPEMASK) | BS_OWNERDRAW, lParam);
  223. } // End of OnSetStyle
  225. void CButtonST::OnEnable(BOOL bEnable) 
  226. {
  227. CButton::OnEnable(bEnable);
  229. if (bEnable == FALSE)
  230. {
  231. CWnd* pWnd = GetParent()->GetNextDlgTabItem(this);
  232. if (pWnd)
  233. pWnd->SetFocus();
  234. else
  235. GetParent()->SetFocus();
  237. CancelHover();
  238. } // if
  239. } // End of OnEnable
  241. void CButtonST::OnKillFocus(CWnd * pNewWnd)
  242. {
  243. CButton::OnKillFocus(pNewWnd);
  244. CancelHover();
  245. } // End of OnKillFocus
  247. void CButtonST::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized) 
  248. {
  249. CButton::OnActivate(nState, pWndOther, bMinimized);
  250. if (nState == WA_INACTIVE) CancelHover();
  251. } // End of OnActivate
  253. void CButtonST::OnCancelMode() 
  254. {
  255. CButton::OnCancelMode();
  256. CancelHover();
  257. } // End of OnCancelMode
  259. BOOL CButtonST::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  260. {
  261. // If a cursor was specified then use it!
  262. if (m_hCursor != NULL)
  263. {
  264. ::SetCursor(m_hCursor);
  265. return TRUE;
  266. } // if
  268. return CButton::OnSetCursor(pWnd, nHitTest, message);
  269. } // End of OnSetCursor
  271. void CButtonST::CancelHover()
  272. {
  273. // Only for flat buttons
  274. if (m_bIsFlat)
  275. {
  276. if (m_bMouseOnButton)
  277. {
  278. m_bMouseOnButton = FALSE;
  279. Invalidate();
  280. } // if
  281. } // if
  282. } // End of CancelHover
  284. void CButtonST::OnMouseMove(UINT nFlags, CPoint point)
  285. {
  286. CWnd* wndUnderMouse = NULL;
  287. CWnd* wndActive = this;
  288. TRACKMOUSEEVENT csTME;
  290. CButton::OnMouseMove(nFlags, point);
  292. ClientToScreen(&point);
  293. wndUnderMouse = WindowFromPoint(point);
  295. // If the mouse enter the button with the left button pressed then do nothing
  296. if (nFlags & MK_LBUTTON && m_bMouseOnButton == FALSE) return;
  298. // If our button is not flat then do nothing
  299. if (m_bIsFlat == FALSE) return;
  301. if (m_bAlwaysTrack == FALSE) wndActive = GetActiveWindow();
  303. if (wndUnderMouse && wndUnderMouse->m_hWnd == m_hWnd && wndActive)
  304. {
  305. if (!m_bMouseOnButton)
  306. {
  307. m_bMouseOnButton = TRUE;
  309. Invalidate();
  311. csTME.cbSize = sizeof(csTME);
  312. csTME.dwFlags = TME_LEAVE;
  313. csTME.hwndTrack = m_hWnd;
  314. ::_TrackMouseEvent(&csTME);
  315. } // if
  316. } else CancelHover();
  317. } // End of OnMouseMove
  319. // Handler for WM_MOUSELEAVE
  320. LRESULT CButtonST::OnMouseLeave(WPARAM wParam, LPARAM lParam)
  321. {
  322. CancelHover();
  323. return 0;
  324. } // End of OnMouseLeave
  326. BOOL CButtonST::OnClicked() 
  327. {
  328. if (m_bIsCheckBox)
  329. {
  330. m_nCheck = !m_nCheck;
  331. Invalidate();
  332. } // if
  333. else
  334. {
  335. // Handle the menu (if any)
  336. if (m_hMenu)
  337. {
  338. HMENU hSubMenu = NULL;
  339. CRect rWnd;
  341. hSubMenu = ::GetSubMenu(m_hMenu, 0);
  343. GetWindowRect(rWnd);
  345. m_bMenuDisplayed = TRUE;
  346. Invalidate();
  348. ::TrackPopupMenuEx(hSubMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON, rWnd.left, rWnd.bottom, m_hParentWndMenu, NULL);
  350. m_bMenuDisplayed = FALSE;
  351. Invalidate();
  352. } // if
  353. else
  354. {
  355. // Handle the URL (if any)
  356. if (_tcslen(m_szURL) > 0)
  357. {
  358. SHELLEXECUTEINFO csSEI;
  360. memset(&csSEI, 0, sizeof(csSEI));
  361. csSEI.cbSize = sizeof(SHELLEXECUTEINFO);
  362. csSEI.fMask = SEE_MASK_FLAG_NO_UI;
  363. csSEI.lpVerb = _T("open");
  364. csSEI.lpFile = m_szURL;
  365. csSEI.nShow = SW_SHOWMAXIMIZED;
  366. ::ShellExecuteEx(&csSEI);
  367. } // if
  368. } // else
  369. } // else
  371. return FALSE;
  372. } // End of OnClicked
  374. void CButtonST::DrawItem(LPDRAWITEMSTRUCT lpDIS)
  375. {
  376. CDC* pDC = CDC::FromHandle(lpDIS->hDC);
  377. CPen* pOldPen;
  379. // Checkbox?
  380. if (m_bIsCheckBox)
  381. {
  382. m_bIsPressed  =  (lpDIS->itemState & ODS_SELECTED) || (m_nCheck != 0);
  383. } // if
  384. else // Normal button OR other button style ...
  385. {
  386. m_bIsPressed = (lpDIS->itemState & ODS_SELECTED);
  388. // If there is a menu and it's displayed, draw the button as pressed
  389. if (m_hMenu && m_bMenuDisplayed) m_bIsPressed = TRUE;
  390. } // else
  392. m_bIsFocused  = (lpDIS->itemState & ODS_FOCUS);
  393. m_bIsDisabled = (lpDIS->itemState & ODS_DISABLED);
  395. CRect itemRect = lpDIS->rcItem;
  397. pDC->SetBkMode(TRANSPARENT);
  399. if (m_bIsFlat == FALSE)
  400. {
  401. if (m_bIsFocused || m_bIsDefault)
  402. {
  403. CBrush br(RGB(0,0,0));  
  404. pDC->FrameRect(&itemRect, &br);
  405. // itemRect.DeflateRect(1, 1); // @@
  406. } // if
  407. } // if
  409. // Prepare draw... paint button background
  411. // Draw transparent?
  412. if (m_bDrawTransparent)
  413. PaintBk(pDC);
  414. else
  415. OnDrawBackground(pDC, &itemRect);
  417. // Draw pressed button
  418. if (m_bIsPressed)
  419. {
  420. if (m_bIsFlat)
  421. {
  422. if (m_bDrawBorder)
  423. OnDrawBorder(pDC, &itemRect);
  424. }
  425. else    
  426. {
  427. CBrush brBtnShadow(GetSysColor(COLOR_BTNSHADOW));
  428. pDC->FrameRect(&itemRect, &brBtnShadow);
  429. }
  430. }
  431. else // ...else draw non pressed button
  432. {
  433. CPen penBtnHiLight(PS_SOLID, 0, GetSysColor(COLOR_BTNHILIGHT)); // White
  434. CPen pen3DLight(PS_SOLID, 0, GetSysColor(COLOR_3DLIGHT));       // Light gray
  435. CPen penBtnShadow(PS_SOLID, 0, GetSysColor(COLOR_BTNSHADOW));   // Dark gray
  436. CPen pen3DDKShadow(PS_SOLID, 0, GetSysColor(COLOR_3DDKSHADOW)); // Black
  438. if (m_bIsFlat)
  439. {
  440. if (m_bMouseOnButton && m_bDrawBorder)
  441. OnDrawBorder(pDC, &itemRect);
  442. }
  443. else
  444. {
  445. // Draw top-left borders
  446. // White line
  447. pOldPen = pDC->SelectObject(&penBtnHiLight);
  448. pDC->MoveTo(itemRect.left, itemRect.bottom-1);
  449. pDC->LineTo(itemRect.left, itemRect.top);
  450. pDC->LineTo(itemRect.right, itemRect.top);
  451. // Light gray line
  452. pDC->SelectObject(pen3DLight);
  453. pDC->MoveTo(itemRect.left+1, itemRect.bottom-1);
  454. pDC->LineTo(itemRect.left+1, itemRect.top+1);
  455. pDC->LineTo(itemRect.right, itemRect.top+1);
  456. // Draw bottom-right borders
  457. // Black line
  458. pDC->SelectObject(pen3DDKShadow);
  459. pDC->MoveTo(itemRect.left, itemRect.bottom-1);
  460. pDC->LineTo(itemRect.right-1, itemRect.bottom-1);
  461. pDC->LineTo(itemRect.right-1, itemRect.top-1);
  462. // Dark gray line
  463. pDC->SelectObject(penBtnShadow);
  464. pDC->MoveTo(itemRect.left+1, itemRect.bottom-2);
  465. pDC->LineTo(itemRect.right-2, itemRect.bottom-2);
  466. pDC->LineTo(itemRect.right-2, itemRect.top);
  467. //
  468. pDC->SelectObject(pOldPen);
  469. } // else
  470. } // else
  472. // Read the button's title
  473. CString sTitle;
  474. GetWindowText(sTitle);
  476. CRect captionRect = lpDIS->rcItem;
  478. // Draw the icon
  479. if (m_csIcons[0].hIcon)
  480. {
  481. DrawTheIcon(pDC, !sTitle.IsEmpty(), &lpDIS->rcItem, &captionRect, m_bIsPressed, m_bIsDisabled);
  482. } // if
  484. if (m_csBitmaps[0].hBitmap)
  485. {
  486. pDC->SetBkColor(RGB(255,255,255));
  487. DrawTheBitmap(pDC, !sTitle.IsEmpty(), &lpDIS->rcItem, &captionRect, m_bIsPressed, m_bIsDisabled);
  488. } // if
  490. // Write the button title (if any)
  491. if (sTitle.IsEmpty() == FALSE)
  492. {
  493. // Draw the button's title
  494. // If button is pressed then "press" title also
  495. if (m_bIsPressed && m_bIsCheckBox == FALSE)
  496. captionRect.OffsetRect(1, 1);
  497.     
  498. // ONLY FOR DEBUG 
  499. //CBrush brBtnShadow(RGB(255, 0, 0));
  500. //pDC->FrameRect(&captionRect, &brBtnShadow);
  502. // @@
  503. CSize szText = pDC->GetTextExtent(sTitle);
  504. if (szText.cx <= captionRect.Width()) {
  505. // Center text
  506. CRect centerRect = captionRect;
  507. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER | DT_CALCRECT);
  508. captionRect.OffsetRect((centerRect.Width() - captionRect.Width())/2, (centerRect.Height() - captionRect.Height())/2);
  509. /* RFU
  510. captionRect.OffsetRect(0, (centerRect.Height() - captionRect.Height())/2);
  511. captionRect.OffsetRect((centerRect.Width() - captionRect.Width())-4, (centerRect.Height() - captionRect.Height())/2);
  512. */
  514. pDC->SetBkMode(TRANSPARENT);
  515. /*
  516. pDC->DrawState(captionRect.TopLeft(), captionRect.Size(), (LPCTSTR)sTitle, (bIsDisabled ? DSS_DISABLED : DSS_NORMAL), 
  517. TRUE, 0, (CBrush*)NULL);
  518. */
  519. if (m_bIsDisabled)
  520. {
  521. captionRect.OffsetRect(1, 1);
  522. pDC->SetTextColor(::GetSysColor(COLOR_3DHILIGHT));
  523. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER);
  524. captionRect.OffsetRect(-1, -1);
  525. pDC->SetTextColor(::GetSysColor(COLOR_3DSHADOW));
  526. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER);
  527. } // if
  528. else
  529. {
  530. if (m_bMouseOnButton || m_bIsPressed) 
  531. {
  532. pDC->SetTextColor(m_crColors[BTNST_COLOR_FG_IN]);
  533. pDC->SetBkColor(m_crColors[BTNST_COLOR_BK_IN]);
  534. } // if
  535. else 
  536. {
  537. pDC->SetTextColor(m_crColors[BTNST_COLOR_FG_OUT]);
  538. pDC->SetBkColor(m_crColors[BTNST_COLOR_BK_OUT]);
  539. } // else
  540. pDC->DrawText(sTitle, -1, captionRect, DT_WORDBREAK | DT_CENTER);
  541. } // if
  542. }
  543. } // if
  545. if (m_bIsFlat == FALSE || (m_bIsFlat && m_bDrawFlatFocus))
  546. {
  547. // Draw the focus rect
  548. if (m_bIsFocused)
  549. {
  550. CRect focusRect = itemRect;
  551. focusRect.DeflateRect(3, 3);
  552. // pDC->DrawFocusRect(&focusRect); // @@
  553. } // if
  554. } // if
  555. } // End of DrawItem
  557. void CButtonST::PaintBk(CDC* pDC)
  558. {
  559. CClientDC clDC(GetParent());
  560. CRect rect;
  561. CRect rect1;
  563. GetClientRect(rect);
  565. GetWindowRect(rect1);
  566. GetParent()->ScreenToClient(rect1);
  568. if (m_dcBk.m_hDC == NULL)
  569. {
  570. m_dcBk.CreateCompatibleDC(&clDC);
  571. m_bmpBk.CreateCompatibleBitmap(&clDC, rect.Width(), rect.Height());
  572. m_pbmpOldBk = m_dcBk.SelectObject(&m_bmpBk);
  573. m_dcBk.BitBlt(0, 0, rect.Width(), rect.Height(), &clDC, rect1.left, rect1.top, SRCCOPY);
  574. } // if
  576. pDC->BitBlt(0, 0, rect.Width(), rect.Height(), &m_dcBk, 0, 0, SRCCOPY);
  577. } // End of PaintBk
  579. HBITMAP CButtonST::CreateBitmapMask(HBITMAP hSourceBitmap, DWORD dwWidth, DWORD dwHeight, COLORREF crTransColor)
  580. {
  581. HBITMAP hMask = NULL;
  582. HDC hdcSrc = NULL;
  583. HDC hdcDest = NULL;
  584. HBITMAP hbmSrcT = NULL;
  585. HBITMAP hbmDestT = NULL;
  586. COLORREF crSaveBk;
  587. COLORREF crSaveDestText;
  589. hMask = ::CreateBitmap(dwWidth, dwHeight, 1, 1, NULL);
  590. if (hMask == NULL) return NULL;
  592. hdcSrc = ::CreateCompatibleDC(NULL);
  593. hdcDest = ::CreateCompatibleDC(NULL);
  595. hbmSrcT = (HBITMAP)::SelectObject(hdcSrc, hSourceBitmap);
  596. hbmDestT = (HBITMAP)::SelectObject(hdcDest, hMask);
  598. crSaveBk = ::SetBkColor(hdcSrc, crTransColor);
  600. ::BitBlt(hdcDest, 0, 0, dwWidth, dwHeight, hdcSrc, 0, 0, SRCCOPY);
  602. crSaveDestText = ::SetTextColor(hdcSrc, RGB(255, 255, 255));
  603. ::SetBkColor(hdcSrc,RGB(0, 0, 0));
  605. ::BitBlt(hdcSrc, 0, 0, dwWidth, dwHeight, hdcDest, 0, 0, SRCAND);
  607. SetTextColor(hdcDest, crSaveDestText);
  609. ::SetBkColor(hdcSrc, crSaveBk);
  610. ::SelectObject(hdcSrc, hbmSrcT);
  611. ::SelectObject(hdcDest, hbmDestT);
  613. ::DeleteDC(hdcSrc);
  614. ::DeleteDC(hdcDest);
  616. return hMask;
  617. } // End of CreateBitmapMask
  619. //
  620. // Parameters:
  621. // [IN] bHasTitle
  622. // TRUE if the button has a text
  623. // [IN] rpItem
  624. // A pointer to a RECT structure indicating the allowed paint area
  625. // [IN/OUT]rpTitle
  626. // A pointer to a CRect object indicating the paint area reserved for the
  627. // text. This structure will be modified if necessary.
  628. // [IN] bIsPressed
  629. // TRUE if the button is currently pressed
  630. // [IN] dwWidth
  631. // Width of the image (icon or bitmap)
  632. // [IN] dwHeight
  633. // Height of the image (icon or bitmap)
  634. // [OUT] rpImage
  635. // A pointer to a CRect object that will receive the area available to the image
  636. //
  637. void CButtonST::PrepareImageRect(BOOL bHasTitle, RECT* rpItem, CRect* rpTitle, BOOL bIsPressed, DWORD dwWidth, DWORD dwHeight, CRect* rpImage)
  638. {
  639. CRect rBtn;
  641. rpImage->CopyRect(rpItem);
  643. switch (m_byAlign)
  644. {
  645. case ST_ALIGN_HORIZ:
  646. if (bHasTitle == FALSE)
  647. {
  648. // Center image horizontally
  649. rpImage->left += ((rpImage->Width() - dwWidth)/2);
  650. }
  651. else
  652. {
  653. // Image must be placed just inside the focus rect
  654. rpImage->left += 3;  
  655. rpTitle->left += dwWidth + 3;
  656. }
  657. // Center image vertically
  658. rpImage->top += ((rpImage->Height() - dwHeight)/2);
  659. break;
  661. case ST_ALIGN_HORIZ_RIGHT:
  662. GetClientRect(&rBtn);
  663. if (bHasTitle == FALSE)
  664. {
  665. // Center image horizontally
  666. rpImage->left += ((rpImage->Width() - dwWidth)/2);
  667. }
  668. else
  669. {
  670. // Image must be placed just inside the focus rect
  671. rpTitle->right = rpTitle->Width() - dwWidth - 3;
  672. rpTitle->left = 3;
  673. rpImage->left = rBtn.right - dwWidth - 3;
  674. // Center image vertically
  675. rpImage->top += ((rpImage->Height() - dwHeight)/2);
  676. }
  677. break;
  679. case ST_ALIGN_VERT:
  680. // Center image horizontally
  681. rpImage->left += ((rpImage->Width() - dwWidth)/2);
  682. if (bHasTitle == FALSE)
  683. {
  684. // Center image vertically
  685. rpImage->top += ((rpImage->Height() - dwHeight)/2);           
  686. }
  687. else
  688. {
  689. rpImage->top = 3;
  690. rpTitle->top += dwHeight;
  691. }
  692. break;
  693. }
  694.     
  695. // If button is pressed then press image also
  696. if (bIsPressed && m_bIsCheckBox == FALSE)
  697. rpImage->OffsetRect(1, 1);
  698. } // End of PrepareImageRect
  700. void CButtonST::DrawTheIcon(CDC* pDC, BOOL bHasTitle, RECT* rpItem, CRect* rpTitle, BOOL bIsPressed, BOOL bIsDisabled)
  701. {
  702. BYTE byIndex = 0;
  704. // Select the icon to use
  705. if ((m_bIsCheckBox && bIsPressed) || (!m_bIsCheckBox && (bIsPressed || m_bMouseOnButton)))
  706. byIndex = 0;
  707. else
  708. byIndex = (m_csIcons[1].hIcon == NULL ? 0 : 1);
  710. CRect rImage;
  711. PrepareImageRect(bHasTitle, rpItem, rpTitle, bIsPressed, m_csIcons[byIndex].dwWidth, m_csIcons[byIndex].dwHeight, &rImage);
  713. // Ole'!
  714. pDC->DrawState( rImage.TopLeft(),
  715. rImage.Size(), 
  716. m_csIcons[byIndex].hIcon,
  717. (bIsDisabled ? DSS_DISABLED : DSS_NORMAL), 
  718. (CBrush*)NULL);
  719. } // End of DrawTheIcon
  721. void CButtonST::DrawTheBitmap(CDC* pDC, BOOL bHasTitle, RECT* rItem, CRect *rCaption, BOOL bIsPressed, BOOL bIsDisabled)
  722. {
  723. HDC hdcBmpMem = NULL;
  724. HBITMAP hbmOldBmp = NULL;
  725. HDC hdcMem = NULL;
  726. HBITMAP hbmT = NULL;
  728. BYTE byIndex = 0;
  730. // Select the bitmap to use
  731. if ((m_bIsCheckBox && bIsPressed) || (!m_bIsCheckBox && (bIsPressed || m_bMouseOnButton)))
  732. byIndex = 0;
  733. else
  734. byIndex = (m_csBitmaps[1].hBitmap == NULL ? 0 : 1);
  736. CRect rImage;
  737. PrepareImageRect(bHasTitle, rItem, rCaption, bIsPressed, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, &rImage);
  739. hdcBmpMem = ::CreateCompatibleDC(pDC->m_hDC);
  741. hbmOldBmp = (HBITMAP)::SelectObject(hdcBmpMem, m_csBitmaps[byIndex].hBitmap);
  743. hdcMem = ::CreateCompatibleDC(NULL);
  745. hbmT = (HBITMAP)::SelectObject(hdcMem, m_csBitmaps[byIndex].hMask);
  747. ::BitBlt(pDC->m_hDC, rImage.left, rImage.top, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, hdcMem, 0, 0, SRCAND);
  749. ::BitBlt(pDC->m_hDC, rImage.left, rImage.top, m_csBitmaps[byIndex].dwWidth, m_csBitmaps[byIndex].dwHeight, hdcBmpMem, 0, 0, SRCPAINT);
  751. ::SelectObject(hdcMem, hbmT);
  752. ::DeleteDC(hdcMem);
  754. ::SelectObject(hdcBmpMem, hbmOldBmp);
  755. ::DeleteDC(hdcBmpMem);
  756. } // End of DrawTheBitmap
  758. // This function assigns icons to the button.
  759. // Any previous icon or bitmap will be removed.
  760. //
  761. // Parameters:
  762. // [IN] nIconIn
  763. // ID number of the icon resource to show when the mouse is over the button.
  764. // Pass NULL to remove any icon from the button.
  765. // [IN] nIconOut
  766. // ID number of the icon resource to show when the mouse is outside the button.
  767. // Can be NULL.
  768. //
  769. // Return value:
  770. // BTNST_OK
  771. // Function executed successfully.
  772. // BTNST_INVALIDRESOURCE
  773. // Failed loading the specified resource.
  774. //
  775. DWORD CButtonST::SetIcon(int nIconIn, int nIconOut)
  776. {
  777. HICON hIconIn = NULL;
  778. HICON hIconOut = NULL;
  779. HINSTANCE hInstResource = NULL;
  781. // Find correct resource handle
  782. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nIconIn), RT_GROUP_ICON);
  784. // Set icon when the mouse is IN the button
  785. hIconIn = (HICON)::LoadImage(hInstResource, MAKEINTRESOURCE(nIconIn), IMAGE_ICON, 0, 0, 0);
  786.    // Set icon when the mouse is OUT the button
  787. if (nIconOut)
  788. hIconOut = (HICON)::LoadImage(hInstResource, MAKEINTRESOURCE(nIconOut), IMAGE_ICON, 0, 0, 0);
  790. return SetIcon(hIconIn, hIconOut);
  791. } // End of SetIcon
  793. // This function assigns icons to the button.
  794. // Any previous icon or bitmap will be removed.
  795. //
  796. // Parameters:
  797. // [IN] hIconIn
  798. // Handle fo the icon to show when the mouse is over the button.
  799. // Pass NULL to remove any icon from the button.
  800. // [IN] hIconOut
  801. // Handle to the icon to show when the mouse is outside the button.
  802. // Can be NULL.
  803. //
  804. // Return value:
  805. // BTNST_OK
  806. // Function executed successfully.
  807. // BTNST_INVALIDRESOURCE
  808. // Failed loading the specified resource.
  809. //
  810. DWORD CButtonST::SetIcon(HICON hIconIn, HICON hIconOut)
  811. {
  812. BOOL bRetValue;
  813. ICONINFO ii;
  815. // Free any loaded resource
  816. // @@
  817. //FreeResources();
  819. if (hIconIn)
  820. {
  821. // Icon when mouse over button?
  822. m_csIcons[0].hIcon = hIconIn;
  823. // Get icon dimension
  824. ::ZeroMemory(&ii, sizeof(ICONINFO));
  825. bRetValue = ::GetIconInfo(hIconIn, &ii);
  826. if (bRetValue == FALSE)
  827. {
  828. FreeResources();
  829. return BTNST_INVALIDRESOURCE;
  830. } // if
  832. m_csIcons[0].dwWidth = (DWORD)(ii.xHotspot * 2);
  833. m_csIcons[0].dwHeight = (DWORD)(ii.yHotspot * 2);
  834. ::DeleteObject(ii.hbmMask);
  835. ::DeleteObject(ii.hbmColor);
  837. // Icon when mouse outside button?
  838. if (hIconOut)
  839. {
  840. m_csIcons[1].hIcon = hIconOut;
  841. // Get icon dimension
  842. ::ZeroMemory(&ii, sizeof(ICONINFO));
  843. bRetValue = ::GetIconInfo(hIconOut, &ii);
  844. if (bRetValue == FALSE)
  845. {
  846. FreeResources();
  847. return BTNST_INVALIDRESOURCE;
  848. } // if
  850. m_csIcons[1].dwWidth = (DWORD)(ii.xHotspot * 2);
  851. m_csIcons[1].dwHeight = (DWORD)(ii.yHotspot * 2);
  852. ::DeleteObject(ii.hbmMask);
  853. ::DeleteObject(ii.hbmColor);
  854. } // if
  855. } // if
  857. Invalidate();
  859. return BTNST_OK;
  860. } // End of SetIcon
  862. // This function assigns bitmaps to the button.
  863. // Any previous icon or bitmap will be removed.
  864. //
  865. // Parameters:
  866. // [IN] nBitmapIn
  867. // ID number of the bitmap resource to show when the mouse is over the button.
  868. // Pass NULL to remove any bitmap from the button.
  869. // [IN] crTransColorIn
  870. // Color (inside nBitmapIn) to be used as transparent color.
  871. // [IN] nBitmapOut
  872. // ID number of the bitmap resource to show when the mouse is outside the button.
  873. // Can be NULL.
  874. // [IN] crTransColorOut
  875. // Color (inside nBitmapOut) to be used as transparent color.
  876. //
  877. // Return value:
  878. // BTNST_OK
  879. // Function executed successfully.
  880. // BTNST_INVALIDRESOURCE
  881. // Failed loading the specified resource.
  882. // BTNST_FAILEDMASK
  883. // Failed creating mask bitmap.
  884. //
  885. DWORD CButtonST::SetBitmaps(int nBitmapIn, COLORREF crTransColorIn, int nBitmapOut, COLORREF crTransColorOut)
  886. {
  887. HBITMAP hBitmapIn = NULL;
  888. HBITMAP hBitmapOut = NULL;
  889. HINSTANCE hInstResource = NULL;
  891. // Find correct resource handle
  892. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nBitmapIn), RT_BITMAP);
  894. // Load bitmap In
  895. hBitmapIn = (HBITMAP)::LoadImage(hInstResource, MAKEINTRESOURCE(nBitmapIn), IMAGE_BITMAP, 0, 0, 0);
  897. // Load bitmap Out
  898. if (nBitmapOut)
  899. hBitmapOut = (HBITMAP)::LoadImage(hInstResource, MAKEINTRESOURCE(nBitmapOut), IMAGE_BITMAP, 0, 0, 0);
  901. return SetBitmaps(hBitmapIn, crTransColorIn, hBitmapOut, crTransColorOut);
  902. } // End of SetBitmaps
  904. // This function assigns bitmaps to the button.
  905. // Any previous icon or bitmap will be removed.
  906. //
  907. // Parameters:
  908. // [IN] hBitmapIn
  909. // Handle fo the bitmap to show when the mouse is over the button.
  910. // Pass NULL to remove any bitmap from the button.
  911. // [IN] crTransColorIn
  912. // Color (inside hBitmapIn) to be used as transparent color.
  913. // [IN] hBitmapOut
  914. // Handle to the bitmap to show when the mouse is outside the button.
  915. // Can be NULL.
  916. // [IN] crTransColorOut
  917. // Color (inside hBitmapOut) to be used as transparent color.
  918. //
  919. // Return value:
  920. // BTNST_OK
  921. // Function executed successfully.
  922. // BTNST_INVALIDRESOURCE
  923. // Failed loading the specified resource.
  924. // BTNST_FAILEDMASK
  925. // Failed creating mask bitmap.
  926. //
  927. DWORD CButtonST::SetBitmaps(HBITMAP hBitmapIn, COLORREF crTransColorIn, HBITMAP hBitmapOut, COLORREF crTransColorOut)
  928. {
  929. int nRetValue;
  930. BITMAP csBitmapSize;
  932. // Free any loaded resource
  933. FreeResources();
  935. if (hBitmapIn)
  936. {
  937. m_csBitmaps[0].hBitmap = hBitmapIn;
  938. m_csBitmaps[0].crTransparent = crTransColorIn;
  939. // Get bitmap size
  940. nRetValue = ::GetObject(hBitmapIn, sizeof(csBitmapSize), &csBitmapSize);
  941. if (nRetValue == 0)
  942. {
  943. FreeResources();
  944. return BTNST_INVALIDRESOURCE;
  945. } // if
  946. m_csBitmaps[0].dwWidth = (DWORD)csBitmapSize.bmWidth;
  947. m_csBitmaps[0].dwHeight = (DWORD)csBitmapSize.bmHeight;
  949. // Create mask for bitmap In
  950. m_csBitmaps[0].hMask = CreateBitmapMask(hBitmapIn, m_csBitmaps[0].dwWidth, m_csBitmaps[0].dwHeight, crTransColorIn);
  951. if (m_csBitmaps[0].hMask == NULL)
  952. {
  953. FreeResources();
  954. return BTNST_FAILEDMASK;
  955. } // if
  957. if (hBitmapOut)
  958. {
  959. m_csBitmaps[1].hBitmap = hBitmapOut;
  960. m_csBitmaps[1].crTransparent = crTransColorOut;
  961. // Get bitmap size
  962. nRetValue = ::GetObject(hBitmapOut, sizeof(csBitmapSize), &csBitmapSize);
  963. if (nRetValue == 0)
  964. {
  965. FreeResources();
  966. return BTNST_INVALIDRESOURCE;
  967. } // if
  968. m_csBitmaps[1].dwWidth = (DWORD)csBitmapSize.bmWidth;
  969. m_csBitmaps[1].dwHeight = (DWORD)csBitmapSize.bmHeight;
  971. // Create mask for bitmap Out
  972. m_csBitmaps[1].hMask = CreateBitmapMask(hBitmapOut, m_csBitmaps[1].dwWidth, m_csBitmaps[1].dwHeight, crTransColorOut);
  973. if (m_csBitmaps[1].hMask == NULL)
  974. {
  975. FreeResources();
  976. return BTNST_FAILEDMASK;
  977. } // if
  978. } // if
  979. } // if
  981. Invalidate();
  983. return BTNST_OK;
  984. } // End of SetBitmaps
  986. // This functions sets the button to have a standard or flat style.
  987. //
  988. // Parameters:
  989. // [IN] bFlat
  990. // If TRUE the button will have a flat style, else
  991. // will have a standard style.
  992. // By default, CButtonST buttons are flat.
  993. // [IN] bRepaint
  994. // If TRUE the control will be repainted.
  995. //
  996. // Return value:
  997. // BTNST_OK
  998. // Function executed successfully.
  999. //
  1000. DWORD CButtonST::SetFlat(BOOL bFlat, BOOL bRepaint)
  1001. {
  1002. m_bIsFlat = bFlat;
  1003. if (bRepaint) Invalidate();
  1005. return BTNST_OK;
  1006. } // End of SetFlat
  1008. // This function sets the alignment type between icon/bitmap and text.
  1009. //
  1010. // Parameters:
  1011. // [IN] byAlign
  1012. // Alignment type. Can be one of the following values:
  1013. // ST_ALIGN_HORIZ Icon/bitmap on the left, text on the right
  1014. // ST_ALIGN_VERT Icon/bitmap on the top, text on the bottom
  1015. // ST_ALIGN_HORIZ_RIGHT Icon/bitmap on the right, text on the left
  1016. // By default, CButtonST buttons have ST_ALIGN_HORIZ alignment.
  1017. // [IN] bRepaint
  1018. // If TRUE the control will be repainted.
  1019. //
  1020. // Return value:
  1021. // BTNST_OK
  1022. // Function executed successfully.
  1023. // BTNST_INVALIDALIGN
  1024. // Alignment type not supported.
  1025. //
  1026. DWORD CButtonST::SetAlign(BYTE byAlign, BOOL bRepaint)
  1027. {
  1028. switch (byAlign)
  1029. {    
  1030. case ST_ALIGN_HORIZ:
  1031. case ST_ALIGN_HORIZ_RIGHT:
  1032. case ST_ALIGN_VERT:
  1033. m_byAlign = byAlign;
  1034. if (bRepaint) Invalidate();
  1035. return BTNST_OK;
  1036. break;
  1037. } // switch
  1039. return BTNST_INVALIDALIGN;
  1040. } // End of SetAlign
  1042. // This function sets the state of the checkbox.
  1043. // If the button is not a checkbox, this function has no meaning.
  1044. //
  1045. // Parameters:
  1046. // [IN] nCheck
  1047. // 1 to check the checkbox.
  1048. // 0 to un-check the checkbox.
  1049. // [IN] bRepaint
  1050. // If TRUE the control will be repainted.
  1051. //
  1052. // Return value:
  1053. // BTNST_OK
  1054. // Function executed successfully.
  1055. //
  1056. DWORD CButtonST::SetCheck(int nCheck, BOOL bRepaint)
  1057. {
  1058. if (m_bIsCheckBox)
  1059. {
  1060. if (nCheck == 0) m_nCheck = 0;
  1061. else m_nCheck = 1;
  1063. if (bRepaint) Invalidate();
  1064. } // if
  1066. return BTNST_OK;
  1067. } // End of SetCheck
  1069. // This function returns the current state of the checkbox.
  1070. // If the button is not a checkbox, this function has no meaning.
  1071. //
  1072. // Return value:
  1073. // The current state of the checkbox.
  1074. // 1 if checked.
  1075. // 0 if not checked or the button is not a checkbox.
  1076. //
  1077. int CButtonST::GetCheck()
  1078. {
  1079. return m_nCheck;
  1080. } // End of GetCheck
  1082. // This function sets all colors to a default value.
  1083. //
  1084. // Parameters:
  1085. // [IN] bRepaint
  1086. // If TRUE the control will be repainted.
  1087. //
  1088. // Return value:
  1089. // BTNST_OK
  1090. // Function executed successfully.
  1091. //
  1092. DWORD CButtonST::SetDefaultColors(BOOL bRepaint)
  1093. {
  1094. m_crColors[BTNST_COLOR_BK_IN] = ::GetSysColor(COLOR_BTNFACE);
  1095. m_crColors[BTNST_COLOR_FG_IN] = ::GetSysColor(COLOR_BTNTEXT);
  1096. m_crColors[BTNST_COLOR_BK_OUT] = ::GetSysColor(COLOR_BTNFACE);
  1097. m_crColors[BTNST_COLOR_FG_OUT] = ::GetSysColor(COLOR_BTNTEXT);
  1098. m_crColors[BTNST_COLOR_BK_FOCUS] = ::GetSysColor(COLOR_BTNFACE);
  1099. m_crColors[BTNST_COLOR_FG_FOCUS] = ::GetSysColor(COLOR_BTNTEXT);
  1101. if (bRepaint) Invalidate();
  1103. return BTNST_OK;
  1104. } // End of SetDefaultColors
  1106. // This function sets the color to use for a particular state.
  1107. //
  1108. // Parameters:
  1109. // [IN] byColorIndex
  1110. // Index of the color to set. Can be one of the following values:
  1111. // BTNST_COLOR_BK_IN Background color when mouse is over the button
  1112. // BTNST_COLOR_FG_IN Text color when mouse is over the button
  1113. // BTNST_COLOR_BK_OUT Background color when mouse is outside the button
  1114. // BTNST_COLOR_FG_OUT Text color when mouse is outside the button
  1115. // BTNST_COLOR_BK_FOCUS Background color when the button is focused
  1116. // BTNST_COLOR_FG_FOCUS Text color when the button is focused
  1117. // [IN] crColor
  1118. // New color.
  1119. // [IN] bRepaint
  1120. // If TRUE the control will be repainted.
  1121. //
  1122. // Return value:
  1123. // BTNST_OK
  1124. // Function executed successfully.
  1125. // BTNST_INVALIDINDEX
  1126. // Invalid color index.
  1127. //
  1128. DWORD CButtonST::SetColor(BYTE byColorIndex, COLORREF crColor, BOOL bRepaint)
  1129. {
  1130. if (byColorIndex >= BTNST_MAX_COLORS) return BTNST_INVALIDINDEX;
  1132. // Set new color
  1133. m_crColors[byColorIndex] = crColor;
  1135. if (bRepaint) Invalidate();
  1137. return BTNST_OK;
  1138. } // End of SetColor
  1140. // This functions returns the color used for a particular state.
  1141. //
  1142. // Parameters:
  1143. // [IN] byColorIndex
  1144. // Index of the color to get. Can be one of the following values:
  1145. // BTNST_COLOR_BK_IN Background color when mouse is over the button
  1146. // BTNST_COLOR_FG_IN Text color when mouse is over the button
  1147. // BTNST_COLOR_BK_OUT Background color when mouse is outside the button
  1148. // BTNST_COLOR_FG_OUT Text color when mouse is outside the button
  1149. // BTNST_COLOR_BK_FOCUS Background color when the button is focused
  1150. // BTNST_COLOR_FG_FOCUS Text color when the button is focused
  1151. // [OUT] crpColor
  1152. // A pointer to a COLORREF that will receive the color.
  1153. //
  1154. // Return value:
  1155. // BTNST_OK
  1156. // Function executed successfully.
  1157. // BTNST_INVALIDINDEX
  1158. // Invalid color index.
  1159. //
  1160. DWORD CButtonST::GetColor(BYTE byColorIndex, COLORREF* crpColor)
  1161. {
  1162. if (byColorIndex >= BTNST_MAX_COLORS) return BTNST_INVALIDINDEX;
  1164. // Get color
  1165. *crpColor = m_crColors[byColorIndex];
  1167. return BTNST_OK;
  1168. } // End of GetColor
  1170. // This function sets the hilight logic for the button.
  1171. // Applies only to flat buttons.
  1172. //
  1173. // Parameters:
  1174. // [IN] bAlwaysTrack
  1175. // If TRUE the button will be hilighted even if the window that owns it, is
  1176. // not the active window.
  1177. // If FALSE the button will be hilighted only if the window that owns it,
  1178. // is the active window.
  1179. //
  1180. // Return value:
  1181. // BTNST_OK
  1182. // Function executed successfully.
  1183. //
  1184. DWORD CButtonST::SetAlwaysTrack(BOOL bAlwaysTrack)
  1185. {
  1186. m_bAlwaysTrack = bAlwaysTrack;
  1187. return BTNST_OK;
  1188. } // End of SetAlwaysTrack
  1190. // This function sets the cursor to be used when the mouse is over the button.
  1191. //
  1192. // Parameters:
  1193. // [IN] nCursorId
  1194. // ID number of the cursor resource.
  1195. // Pass NULL to remove a previously loaded cursor.
  1196. // [IN] bRepaint
  1197. // If TRUE the control will be repainted.
  1198. //
  1199. // Return value:
  1200. // BTNST_OK
  1201. // Function executed successfully.
  1202. // BTNST_INVALIDRESOURCE
  1203. // Failed loading the specified resource.
  1204. //
  1205. DWORD CButtonST::SetBtnCursor(int nCursorId, BOOL bRepaint)
  1206. {
  1207. HINSTANCE hInstResource = NULL;
  1208. // Destroy any previous cursor
  1209. if (m_hCursor)
  1210. {
  1211. ::DestroyCursor(m_hCursor);
  1212. m_hCursor = NULL;
  1213. } // if
  1215. // Load cursor
  1216. if (nCursorId)
  1217. {
  1218. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nCursorId), RT_GROUP_CURSOR);
  1219. // Load cursor resource
  1220. m_hCursor = (HCURSOR)::LoadImage(hInstResource, MAKEINTRESOURCE(nCursorId), IMAGE_CURSOR, 0, 0, 0);
  1221. // Repaint the button
  1222. if (bRepaint) Invalidate();
  1223. // If something wrong
  1224. if (m_hCursor == NULL) return BTNST_INVALIDRESOURCE;
  1225. } // if
  1227. return BTNST_OK;
  1228. } // End of SetBtnCursor
  1230. // This function sets if the button border must be drawn.
  1231. // Applies only to flat buttons.
  1232. //
  1233. // Parameters:
  1234. // [IN] bDrawBorder
  1235. // If TRUE the border will be drawn.
  1236. // [IN] bRepaint
  1237. // If TRUE the control will be repainted.
  1238. //
  1239. // Return value:
  1240. // BTNST_OK
  1241. // Function executed successfully.
  1242. //
  1243. DWORD CButtonST::DrawBorder(BOOL bDrawBorder, BOOL bRepaint)
  1244. {
  1245. m_bDrawBorder = bDrawBorder;
  1246. // Repaint the button
  1247. if (bRepaint) Invalidate();
  1249. return BTNST_OK;
  1250. } // End of DrawBorder
  1252. // This function sets if the focus rectangle must be drawn for flat buttons.
  1253. //
  1254. // Parameters:
  1255. // [IN] bDrawFlatFocus
  1256. // If TRUE the focus rectangle will be drawn also for flat buttons.
  1257. // [IN] bRepaint
  1258. // If TRUE the control will be repainted.
  1259. //
  1260. // Return value:
  1261. // BTNST_OK
  1262. // Function executed successfully.
  1263. //
  1264. DWORD CButtonST::DrawFlatFocus(BOOL bDrawFlatFocus, BOOL bRepaint)
  1265. {
  1266. m_bDrawFlatFocus = bDrawFlatFocus;
  1267. // Repaint the button
  1268. if (bRepaint) Invalidate();
  1270. return BTNST_OK;
  1271. } // End of DrawFlatFocus
  1273. void CButtonST::InitToolTip()
  1274. {
  1275. if (m_ToolTip.m_hWnd == NULL)
  1276. {
  1277. // Create ToolTip control
  1278. m_ToolTip.Create(this);
  1279. // Create inactive
  1280. m_ToolTip.Activate(FALSE);
  1281. // Enable multiline
  1282. m_ToolTip.SendMessage(TTM_SETMAXTIPWIDTH, 0, 400);
  1283. } // if
  1284. } // End of InitToolTip
  1286. // This function sets the text to show in the button tooltip.
  1287. //
  1288. // Parameters:
  1289. // [IN] nText
  1290. // ID number of the string resource containing the text to show.
  1291. // [IN] bActivate
  1292. // If TRUE the tooltip will be created active.
  1293. //
  1294. void CButtonST::SetTooltipText(int nText, BOOL bActivate)
  1295. {
  1296. CString sText;
  1298. // Load string resource
  1299. sText.LoadString(nText);
  1300. // If string resource is not empty
  1301. if (sText.IsEmpty() == FALSE) SetTooltipText((LPCTSTR)sText, bActivate);
  1302. } // End of SetTooltipText
  1304. // This function sets the text to show in the button tooltip.
  1305. //
  1306. // Parameters:
  1307. // [IN] lpszText
  1308. // Pointer to a null-terminated string containing the text to show.
  1309. // [IN] bActivate
  1310. // If TRUE the tooltip will be created active.
  1311. //
  1312. void CButtonST::SetTooltipText(LPCTSTR lpszText, BOOL bActivate)
  1313. {
  1314. // We cannot accept NULL pointer
  1315. if (lpszText == NULL) return;
  1317. // Initialize ToolTip
  1318. InitToolTip();
  1320. // If there is no tooltip defined then add it
  1321. if (m_ToolTip.GetToolCount() == 0)
  1322. {
  1323. CRect rectBtn; 
  1324. GetClientRect(rectBtn);
  1325. m_ToolTip.AddTool(this, lpszText, rectBtn, 1);
  1326. } // if
  1328. // Set text for tooltip
  1329. m_ToolTip.UpdateTipText(lpszText, this, 1);
  1330. m_ToolTip.Activate(bActivate);
  1331. } // End of SetTooltipText
  1333. // This function enables or disables the button tooltip.
  1334. //
  1335. // Parameters:
  1336. // [IN] bActivate
  1337. // If TRUE the tooltip will be activated.
  1338. //
  1339. void CButtonST::ActivateTooltip(BOOL bActivate)
  1340. {
  1341. // If there is no tooltip then do nothing
  1342. if (m_ToolTip.GetToolCount() == 0) return;
  1344. // Activate tooltip
  1345. m_ToolTip.Activate(bActivate);
  1346. } // End of EnableTooltip
  1348. // This function returns if the button is the default button.
  1349. //
  1350. // Return value:
  1351. // TRUE
  1352. // The button is the default button.
  1353. // FALSE
  1354. // The button is not the default button.
  1355. //
  1356. BOOL CButtonST::GetDefault()
  1357. {
  1358. return m_bIsDefault;
  1359. } // End of GetDefault
  1361. // This function enables the transparent mode.
  1362. // Note: this operation is not reversible.
  1363. // DrawTransparent should be called just after the button is created.
  1364. // Do not use trasparent buttons until you really need it (you have a bitmapped
  1365. // background) since each transparent button makes a copy in memory of its background.
  1366. // This may bring unnecessary memory use and execution overload.
  1367. //
  1368. // Parameters:
  1369. // [IN] bRepaint
  1370. // If TRUE the control will be repainted.
  1371. //
  1372. void CButtonST::DrawTransparent(BOOL bRepaint)
  1373. {
  1374. m_bDrawTransparent = TRUE;
  1376. // Restore old bitmap (if any)
  1377. if (m_dcBk.m_hDC != NULL && m_pbmpOldBk != NULL)
  1378. {
  1379. m_dcBk.SelectObject(m_pbmpOldBk);
  1380. } // if
  1382. m_bmpBk.DeleteObject();
  1383. m_dcBk.DeleteDC();
  1385. // Repaint the button
  1386. if (bRepaint) Invalidate();
  1387. } // End of DrawTransparent
  1389. // This function sets the URL that will be opened when the button is clicked.
  1390. //
  1391. // Parameters:
  1392. // [IN] lpszURL
  1393. // Pointer to a null-terminated string that contains the URL.
  1394. // Pass NULL to removed any previously specified URL.
  1395. //
  1396. // Return value:
  1397. // BTNST_OK
  1398. // Function executed successfully.
  1399. //
  1400. DWORD CButtonST::SetURL(LPCTSTR lpszURL)
  1401. {
  1402. // Remove any existing URL
  1403. memset(m_szURL, 0, sizeof(m_szURL));
  1405. if (lpszURL)
  1406. {
  1407. // Store the URL
  1408. _tcsncpy(m_szURL, lpszURL, _MAX_PATH);
  1409. } // if
  1411. return BTNST_OK;
  1412. } // End of SetURL
  1414. // This function associates a menu to the button.
  1415. // The menu will be displayed clicking the button.
  1416. //
  1417. // Parameters:
  1418. // [IN] nMenu
  1419. // ID number of the menu resource.
  1420. // Pass NULL to remove any menu from the button.
  1421. // [IN] hParentWnd
  1422. // Handle to the window that owns the menu.
  1423. // This window receives all messages from the menu.
  1424. // [IN] bRepaint
  1425. // If TRUE the control will be repainted.
  1426. //
  1427. // Return value:
  1428. // BTNST_OK
  1429. // Function executed successfully.
  1430. // BTNST_INVALIDRESOURCE
  1431. // Failed loading the specified resource.
  1432. //
  1433. DWORD CButtonST::SetMenu(UINT nMenu, HWND hParentWnd, BOOL bRepaint)
  1434. {
  1435. HINSTANCE hInstResource = NULL;
  1437. // Destroy any previous menu
  1438. if (m_hMenu)
  1439. {
  1440. ::DestroyMenu(m_hMenu);
  1441. m_hMenu = NULL;
  1442. m_hParentWndMenu = NULL;
  1443. m_bMenuDisplayed = FALSE;
  1444. } // if
  1446. // Load menu
  1447. if (nMenu)
  1448. {
  1449. // Find correct resource handle
  1450. hInstResource = AfxFindResourceHandle(MAKEINTRESOURCE(nMenu), RT_MENU);
  1451. // Load menu resource
  1452. m_hMenu = ::LoadMenu(hInstResource, MAKEINTRESOURCE(nMenu));
  1453. m_hParentWndMenu = hParentWnd;
  1454. // If something wrong
  1455. if (m_hMenu == NULL) return BTNST_INVALIDRESOURCE;
  1456. } // if
  1458. // Repaint the button
  1459. if (bRepaint) Invalidate();
  1461. return BTNST_OK;
  1462. } // End of SetMenu
  1464. // This function is called every time the button background needs to be painted.
  1465. // If the button is in transparent mode this function will NOT be called.
  1466. // This is a virtual function that can be rewritten in CButtonST-derived classes
  1467. // to produce a whole range of buttons not available by default.
  1468. //
  1469. // Parameters:
  1470. // [IN] pDC
  1471. // Pointer to a CDC object that indicates the device context.
  1472. // [IN] pRect
  1473. // Pointer to a CRect object that indicates the bounds of the
  1474. // area to be painted.
  1475. //
  1476. // Return value:
  1477. // BTNST_OK
  1478. // Function executed successfully.
  1479. //
  1480. DWORD CButtonST::OnDrawBackground(CDC* pDC, LPCRECT pRect)
  1481. {
  1482. COLORREF crColor;
  1484. if (m_bMouseOnButton || m_bIsPressed)
  1485. crColor = m_crColors[BTNST_COLOR_BK_IN];
  1486. else
  1487. {
  1488. if (m_bIsFocused)
  1489. crColor = m_crColors[BTNST_COLOR_BK_FOCUS];
  1490. else
  1491. crColor = m_crColors[BTNST_COLOR_BK_OUT];
  1492. } // else
  1494. CBrush brBackground(crColor);
  1496. pDC->FillRect(pRect, &brBackground);
  1498. return BTNST_OK;
  1499. } // End of OnDrawBackground
  1501. // This function is called every time the button border needs to be painted.
  1502. // If the button is in standard (not flat) mode this function will NOT be called.
  1503. // This is a virtual function that can be rewritten in CButtonST-derived classes
  1504. // to produce a whole range of buttons not available by default.
  1505. //
  1506. // Parameters:
  1507. // [IN] pDC
  1508. // Pointer to a CDC object that indicates the device context.
  1509. // [IN] pRect
  1510. // Pointer to a CRect object that indicates the bounds of the
  1511. // area to be painted.
  1512. //
  1513. // Return value:
  1514. // BTNST_OK
  1515. // Function executed successfully.
  1516. //
  1517. DWORD CButtonST::OnDrawBorder(CDC* pDC, LPCRECT pRect)
  1518. {
  1519. if (m_bIsPressed)
  1520. pDC->Draw3dRect(pRect, ::GetSysColor(COLOR_BTNSHADOW), ::GetSysColor(COLOR_BTNHILIGHT));
  1521. else
  1522. pDC->Draw3dRect(pRect, ::GetSysColor(COLOR_BTNHILIGHT), ::GetSysColor(COLOR_BTNSHADOW));
  1524. return BTNST_OK;
  1525. } // End of OnDrawBorder
  1527. #undef BS_TYPEMASK
  1529. void CButtonST::setText(UINT nID)
  1530. {
  1531. CString str;
  1532. str.LoadString(nID);
  1533. SetWindowText(str);
  1534. }