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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPButton.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：56k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPButton.cpp：源码内容
  1. // XTButton.cpp : implementation of the CXTPButton class.
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "math.h"
  24. #include "Common/XTPWinThemeWrapper.h"
  25. #include "Common/XTPColorManager.h"
  26. #include "Common/XTPDrawHelpers.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPOffice2007Image.h"
  30. #include "Common/XTPMarkupRender.h"
  33. #include "XTPButton.h"
  35. #ifdef _DEBUG
  36. #define new DEBUG_NEW
  37. #undef THIS_FILE
  38. static char THIS_FILE[] = __FILE__;
  39. #endif
  41. #ifndef WM_QUERYUISTATE
  42. #define WM_UPDATEUISTATE    0x0128
  43. #define WM_QUERYUISTATE     0x0129
  45. #define UISF_HIDEACCEL      0x2
  46. #define UISF_HIDEFOCUS      0x1
  47. #endif
  49. #define DT_HIDEPREFIX       0x00100000
  52. #define BS_HORZMASK   (BS_LEFT | BS_RIGHT | BS_CENTER)
  53. #define BS_VERTMASK   (BS_TOP | BS_BOTTOM | BS_VCENTER)
  55. #define CBR_CLIENTRECT 0
  56. #define CBR_CHECKBOX   1
  57. #define CBR_RADIOBOX   2
  58. #define CBR_CHECKTEXT  3
  59. #define CBR_RADIOTEXT  4
  60. #define CBR_GROUPTEXT  5
  61. #define CBR_GROUPFRAME 6
  62. #define CBR_PUSHBUTTON 7
  64. /////////////////////////////////////////////////////////////////////////////
  65. // CXTPButton
  66. /////////////////////////////////////////////////////////////////////////////
  69. IMPLEMENT_DYNAMIC(CXTPButton, CButton)
  71. CXTPButton::CXTPButton()
  72. {
  73. m_bHot = FALSE;
  74. m_bPushed = FALSE;
  76. m_bChecked = FALSE;
  78. m_bFlatStyle = FALSE;
  79. m_bUseVisualStyle = TRUE;
  81. m_pButtonTheme = new CXTPButtonTheme();
  82. m_pButtonTheme->RefreshMetrics(this);
  84. m_bEnableMarkup = FALSE;
  85. m_pMarkupContext = NULL;
  86. m_pUIElement = NULL;
  88. m_nPushButtonStyle = 0;
  90. m_nBorderGap = 4;
  91. m_nImageGap = 3;
  93. m_pIcon = 0;
  95. m_nImageAlignment = BS_VCENTER | BS_CENTER;
  96. m_nTextImageRelation = xtpButtonImageBeforeText;
  98. m_nBorderStyle = 0;
  99. m_bShowFocus = TRUE;
  100. }
  102. CXTPButton::~CXTPButton()
  103. {
  104. CMDTARGET_RELEASE(m_pButtonTheme);
  106. XTPMarkupReleaseElement(m_pUIElement);
  107. XTPMarkupReleaseContext(m_pMarkupContext);
  109. CMDTARGET_RELEASE(m_pIcon);
  110. }
  112. BEGIN_MESSAGE_MAP(CXTPButton, CXTPButtonBase)
  113. //{{AFX_MSG_MAP(CXTPButton)
  114. ON_WM_ERASEBKGND()
  115. ON_WM_MOUSEMOVE()
  116. ON_WM_SETFOCUS()
  117. ON_WM_KILLFOCUS()
  118. ON_WM_LBUTTONDOWN()
  119. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  120. ON_WM_CHAR()
  121. ON_WM_KEYDOWN()
  122. ON_WM_SYSCOLORCHANGE()
  123. ON_MESSAGE(WM_GETDLGCODE, OnGetDlgCode)
  124. //}}AFX_MSG_MAP
  125. ON_WM_PAINT()
  126. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  127. ON_MESSAGE(BM_SETSTYLE, OnDefaultAndInvalidate)
  128. ON_MESSAGE(BM_SETCHECK, OnDefaultAndInvalidate)
  129. ON_MESSAGE(WM_CAPTURECHANGED, OnDefaultAndInvalidate)
  130. ON_MESSAGE_VOID(WM_ENABLE, OnInvalidate)
  131. ON_MESSAGE(WM_UPDATEUISTATE, OnUpdateUIState)
  132. ON_MESSAGE(BM_SETSTATE, OnSetState)
  133. ON_MESSAGE(WM_SETTEXT, OnSetText)
  134. //}}AFX_MSG_MAP
  135. END_MESSAGE_MAP()
  137. void CXTPButton::OnMouseMove(UINT nFlags, CPoint point)
  138. {
  139. if (GetButtonStyle() == BS_GROUPBOX)
  140. return;
  142. CXTPButtonBase::OnMouseMove(nFlags, point);
  144. CRect rc;
  145. GetClientRect(&rc);
  147. BOOL bHot = rc.PtInRect(point);
  148. if (bHot != m_bHot)
  149. {
  150. m_bHot = bHot;
  151. RedrawButton();
  153. if (m_bHot)
  154. {
  155. TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, HOVER_DEFAULT};
  156. _TrackMouseEvent(&tme);
  157. }
  158. }
  159. }
  161. void CXTPButton::OnMouseLeave()
  162. {
  163. OnMouseMove(0, CPoint(-1, -1));
  164. }
  167. void CXTPButton::OnLButtonDown(UINT nFlags, CPoint point)
  168. {
  169. if (m_nPushButtonStyle == xtpButtonSplitDropDown)
  170. {
  171. CXTPClientRect rcDropDown(this);
  172. rcDropDown.left = rcDropDown.right - 16 - GetBorderGap();
  174. if (rcDropDown.PtInRect(point))
  175. {
  176. DoDropDown();
  177. return;
  178. }
  179. }
  181. CXTPButtonBase::OnLButtonDown(nFlags, point);
  182. }
  184. LRESULT CXTPButton::OnSetState(WPARAM wParam, LPARAM /*lParam*/)
  185. {
  186. BOOL bVisible = GetStyle() & WS_VISIBLE;
  187. if (bVisible) ModifyStyle(WS_VISIBLE, 0);
  188. Default();
  189. if (bVisible) ModifyStyle(0, WS_VISIBLE);
  191. if (m_bPushed == 2)
  192. return 0;
  194. m_bPushed = (wParam != 0);
  195. RedrawButton();
  197. if (m_bPushed && IsDropDownStyle() && IsPushButton() && (m_nPushButtonStyle != xtpButtonSplitDropDown))
  198. {
  199. DoDropDown();
  200. }
  202. return 0;
  203. }
  205. void CXTPButton::DoDropDown()
  206. {
  207. m_bPushed = 2;
  208. RedrawButton();
  210. OnDropDown();
  212. m_bPushed = 0;
  213. RedrawButton();
  214. }
  216. void CXTPButton::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  217. {
  218. if (IsDropDownStyle() && (nChar == VK_SPACE))
  219. {
  220. DoDropDown();
  221. return;
  222. }
  224. if ((m_nPushButtonStyle == xtpButtonDropDown || m_nPushButtonStyle == xtpButtonDropDownRight) && (nChar == VK_RETURN))
  225. {
  226. DoDropDown();
  227. return;
  228. }
  230. CXTPButtonBase::OnChar(nChar, nRepCnt, nFlags);
  231. }
  233. LRESULT CXTPButton::OnGetDlgCode(WPARAM wParam, LPARAM lParam)
  234. {
  235. LRESULT lCode = CXTPButtonBase::OnGetDlgCode();
  237. if (IsDropDownStyle() && lParam && ((LPMSG)lParam)->message == WM_CHAR && wParam == VK_SPACE)
  238. {
  239. lCode |= DLGC_WANTCHARS;
  240. }
  242. if ((m_nPushButtonStyle == xtpButtonDropDown || m_nPushButtonStyle == xtpButtonDropDownRight)
  243. && lParam && (((LPMSG)lParam)->message == WM_KEYDOWN || ((LPMSG)lParam)->message == WM_CHAR) && wParam == VK_RETURN)
  244. {
  245. lCode |= DLGC_WANTALLKEYS;
  246. }
  248. return lCode;
  249. }
  251. void CXTPButton::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  252. {
  253. if (nChar == VK_SPACE && IsDropDownStyle())
  254. return;
  256. if (nChar == VK_RETURN && (m_nPushButtonStyle == xtpButtonDropDown || m_nPushButtonStyle == xtpButtonDropDownRight))
  257. {
  258. return;
  259. }
  261. CXTPButtonBase::OnKeyDown(nChar, nRepCnt, nFlags);
  262. }
  264. void CXTPButton::OnDropDown()
  265. {
  266. GetParent()->SendMessage(WM_COMMAND,
  267. (WPARAM)MAKELONG(::GetDlgCtrlID(GetSafeHwnd()), CBN_DROPDOWN),
  268. (LPARAM)GetSafeHwnd());
  269. }
  271. void CXTPButton::OnSetFocus(CWnd* pOldWnd)
  272. {
  273. CXTPButtonBase::OnSetFocus(pOldWnd);
  274. RedrawButton();
  275. }
  277. void CXTPButton::OnKillFocus(CWnd* pNewWnd)
  278. {
  279. CXTPButtonBase::OnKillFocus(pNewWnd);
  280. RedrawButton();
  281. }
  283. LRESULT CXTPButton::OnDefaultAndInvalidate(WPARAM, LPARAM)
  284. {
  285. LRESULT lResult = Default();
  286. RedrawButton();
  288. return lResult;
  289. }
  291. void CXTPButton::OnInvalidate()
  292. {
  293. RedrawButton();
  294. }
  296. LRESULT CXTPButton::OnPrintClient(WPARAM wParam, LPARAM lParam)
  297. {
  298. if ((lParam & PRF_CLIENT) == 0)
  299. return Default();
  301. CDC* pDC = CDC::FromHandle((HDC)wParam);
  302. if (pDC) OnDraw(pDC);
  303. return 1;
  304. }
  306. void CXTPButton::OnPaint()
  307. {
  308. CPaintDC dcPaint(this);
  309. OnDraw(&dcPaint);
  310. }
  312. void CXTPButton::OnDraw(CDC* pDC)
  313. {
  314. if ((GetButtonStyle() == BS_GROUPBOX))
  315. {
  316. CFont* pOldFont = pDC->SelectObject(CWnd::GetFont());
  317. pDC->SetBkColor(GetSysColor(COLOR_3DFACE));
  318. pDC->SetBkMode(TRANSPARENT);
  320. DoDraw(pDC);
  322. pDC->SelectObject(pOldFont);
  323. }
  324. else
  325. {
  326. CXTPClientRect rc(this);
  327. CXTPBufferDC memDC(*pDC, rc);
  329. HBRUSH hBrush = (HBRUSH)GetParent()->SendMessage(WM_CTLCOLORBTN, (WPARAM)memDC.GetSafeHdc(), (LPARAM)GetSafeHwnd());
  330. if (hBrush)
  331. {
  332. ::FillRect(memDC.GetSafeHdc(), rc, hBrush);
  333. }
  334. else
  335. {
  336. memDC.FillSolidRect(rc, GetSysColor(COLOR_3DFACE));
  337. }
  339. CFont* pOldFont = memDC.SelectObject(CWnd::GetFont());
  340. memDC.SetBkMode(TRANSPARENT);
  342. DoDraw(&memDC);
  344. memDC.SelectObject(pOldFont);
  345. }
  346. }
  348. void CXTPButton::DoDraw(CDC* pDC)
  349. {
  350. if (IsPushButton())
  351. {
  352. m_pButtonTheme->DrawButtonBackground(pDC, this);
  354. m_pButtonTheme->DrawPushButtonText(pDC, this);
  355. m_pButtonTheme->DrawPushButtonIcon(pDC, this);
  357. if (IsDropDownStyle())
  358. {
  359. m_pButtonTheme->DrawPushButtonDropDown(pDC, this);
  360. }
  362. if (::GetFocus() == m_hWnd && m_bShowFocus)
  363. {
  364. m_pButtonTheme->DrawFocusRect(pDC, this);
  365. }
  366. return;
  367. }
  369. switch (GetButtonStyle())
  370. {
  371. case BS_RADIOBUTTON:
  372. case BS_AUTORADIOBUTTON:
  373. m_pButtonTheme->DrawRadioButtonMark(pDC, this);
  374. m_pButtonTheme->DrawButtonText(pDC, this);
  375. break;
  377. case BS_3STATE:
  378. case BS_AUTO3STATE:
  379. case BS_CHECKBOX:
  380. case BS_AUTOCHECKBOX:
  381. m_pButtonTheme->DrawCheckBoxMark(pDC, this);
  382. m_pButtonTheme->DrawButtonText(pDC, this);
  383. break;
  385. case BS_GROUPBOX:
  386. if (m_nBorderStyle != 2)
  387. {
  388. m_pButtonTheme->DrawGroupBox(pDC, this);
  389. m_pButtonTheme->DrawButtonText(pDC, this);
  390. }
  391. break;
  393. default:
  394. TRACE(_T("Warning: unkown style"));
  395. }
  396. }
  398. LRESULT CXTPButton::OnUpdateUIState(WPARAM wParam, LPARAM lParam)
  399. {
  400. LRESULT lResult = ::DefWindowProc(m_hWnd, WM_UPDATEUISTATE, wParam, lParam);
  401. RedrawButton();
  403. return lResult;
  404. }
  406. LRESULT CXTPButton::OnSetText(WPARAM wParam, LPARAM lParam)
  407. {
  408. BOOL bVisible = GetStyle() & WS_VISIBLE;
  409. if (bVisible) ModifyStyle(WS_VISIBLE, 0);
  411. LRESULT lResult = DefWindowProc(WM_SETTEXT, wParam, lParam);
  413. if (bVisible) ModifyStyle(0, WS_VISIBLE);
  416. InternalTextChanged();
  417. RedrawButton();
  419. return lResult;
  420. }
  422. BOOL CXTPButton::OnEraseBkgnd(CDC* /*pDC*/)
  423. {
  424. return TRUE;
  425. }
  427. void CXTPButton::OnSysColorChange()
  428. {
  429. CXTPButtonBase::OnSysColorChange();
  430. m_pButtonTheme->RefreshMetrics(this);
  431. RedrawButton();
  433. SendMessageToDescendants(WM_SYSCOLORCHANGE, 0, 0L, TRUE, FALSE);
  434. }
  436. //////////////////////////////////////////////////////////////////////////
  438. COLORREF CXTPButton::GetButtonTextColor()
  439. {
  440. return GetSysColor(COLOR_BTNTEXT);
  441. }
  443. COLORREF CXTPButton::GetButtonBackColor()
  444. {
  445. return GetSysColor(COLOR_BTNFACE);
  446. }
  448. BYTE CXTPButton::GetButtonStyle() const
  449. {
  450. BYTE bStyle = BYTE(GetStyle() & 0xF);
  451. return bStyle;
  452. }
  455. CSize CXTPButton::GetImageSize()
  456. {
  457. if (m_pIcon)
  458. return CSize(m_pIcon->GetWidth(), m_pIcon->GetHeight());
  460. return CSize(0, 0);
  461. }
  463. void CXTPButton::DrawImage(CDC* pDC, CRect rc)
  464. {
  465. CXTPImageManagerIcon* pIcon = GetIcon();
  466. if (pIcon)
  467. {
  468. BOOL  bSelected = GetChecked() || IsPushed();
  470. if (!IsWindowEnabled())
  471. {
  472. pIcon->Draw(pDC, rc.TopLeft(), pIcon->GetDisabledIcon(), rc.Size());
  473. }
  474. else if (IsHighlighted() || bSelected)
  475. {
  476. pIcon->Draw(pDC, rc.TopLeft(), GetChecked() ? pIcon->GetCheckedIcon() :
  477. IsPushed() ? pIcon->GetPressedIcon() : pIcon->GetHotIcon(), rc.Size());
  478. }
  479. else
  480. {
  481. pIcon->Draw(pDC, rc.TopLeft(), pIcon->GetIcon(), rc.Size());
  482. }
  483. }
  484. }
  486. BOOL CXTPButton::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  487. {
  488. if (m_pUIElement)
  489. {
  490. if (XTPMarkupRelayMessage(m_pUIElement, message, wParam, lParam, pResult))
  491. return TRUE;
  492. }
  494. return CXTPButtonBase::OnWndMsg(message, wParam, lParam, pResult);
  495. }
  497. int CXTPButton::GetTextAlignment() const
  498. {
  499. DWORD bHorz;
  500. DWORD bVert;
  502. DWORD dwStyle = GetStyle();
  504. bHorz = dwStyle & (BS_LEFT | BS_RIGHT | BS_CENTER);
  505. bVert = dwStyle & (BS_TOP | BS_BOTTOM | BS_VCENTER);
  507. if (!bHorz || !bVert)
  508. {
  509. if (IsPushButton())
  510. {
  511. if (!bHorz)
  512. bHorz = BS_CENTER;
  513. }
  514. else
  515. {
  516. if (!bHorz)
  517. bHorz = BS_LEFT;
  518. }
  520. if (!bVert)
  521. bVert = BS_VCENTER;
  522. }
  524. return bHorz | bVert;
  525. }
  527. CSize CXTPButton::GetGlyphSize(BOOL bCheckBox)
  528. {
  529. CXTPClientRect rcButton(this);
  530. CSize sz(13, 13);
  532. if (m_bUseVisualStyle && m_pButtonTheme->m_themeButton.IsAppThemed())
  533. {
  534. m_pButtonTheme->m_themeButton.GetThemePartSize(NULL,
  535. bCheckBox ? BP_CHECKBOX : BP_RADIOBUTTON,
  536. 1, rcButton, TS_DRAW, &sz);
  537. }
  539. return sz;
  540. }
  542. void CXTPButton::InternalTextChanged()
  543. {
  544. if (m_pMarkupContext)
  545. {
  546. XTPMarkupReleaseElement(m_pUIElement);
  547. m_pUIElement = XTPMarkupParseText(m_pMarkupContext, GetButtonText());
  548. }
  549. }
  551. CString CXTPButton::GetButtonText()
  552. {
  553. CString str;
  554. if (m_hWnd) GetWindowText(str);
  555. return str;
  556. }
  558. void CXTPButton::EnableMarkup(BOOL bEnableMarkup)
  559. {
  560. m_bEnableMarkup = bEnableMarkup;
  562. XTPMarkupReleaseElement(m_pUIElement);
  563. XTPMarkupReleaseContext(m_pMarkupContext);
  565. if (m_bEnableMarkup)
  566. {
  567. m_pMarkupContext = XTPMarkupCreateContext(m_hWnd);
  568. }
  570. InternalTextChanged();
  571. }
  573. BOOL CXTPButton::IsPushButton() const
  574. {
  575. DWORD dwStyle = GetStyle();
  577. switch (GetButtonStyle())
  578. {
  579. case LOBYTE(BS_PUSHBUTTON):
  580. case LOBYTE(BS_DEFPUSHBUTTON):
  581. case LOBYTE(BS_OWNERDRAW):
  582. return TRUE;
  584. default:
  585. if ((dwStyle & BS_PUSHLIKE) == BS_PUSHLIKE)
  586. return TRUE;
  587. break;
  588. }
  590. return FALSE;
  591. }
  594. void CXTPButton::SetTheme(XTPButtonTheme nStyle)
  595. {
  596. CMDTARGET_RELEASE(m_pButtonTheme);
  598. switch (nStyle)
  599. {
  600. case xtpButtonThemeFlat:
  601. m_pButtonTheme = new CXTPButtonFlatTheme();
  602. break;
  603. case xtpButtonThemeUltraFlat:
  604. m_pButtonTheme = new CXTPButtonUltraFlatTheme();
  605. break;
  606. case xtpButtonThemeOffice2000:
  607. m_pButtonTheme = new CXTPButtonOffice2000Theme();
  608. break;
  609. case xtpButtonThemeOfficeXP:
  610. m_pButtonTheme = new CXTPButtonOfficeXPTheme();
  611. break;
  612. case xtpButtonThemeOffice2003:
  613. m_pButtonTheme = new CXTPButtonOffice2003Theme();
  614. break;
  615. case xtpButtonThemeOffice2007:
  616. m_pButtonTheme = new CXTPButtonOffice2007Theme();
  617. break;
  618. default:
  619. m_pButtonTheme = new CXTPButtonTheme();
  620. }
  622. m_bUseVisualStyle = (nStyle == xtpButtonThemeStandard);
  624. m_pButtonTheme->RefreshMetrics(this);
  626. RedrawButton();
  627. }
  629. void CXTPButton::SetUseVisualStyle(BOOL bUseVisualStyle/* = TRUE*/)
  630. {
  631. m_bUseVisualStyle = bUseVisualStyle;
  632. m_pButtonTheme->RefreshMetrics(this);
  633. RedrawButton();
  634. }
  637. BOOL CXTPButton::GetChecked()
  638. {
  639. if (IsPushButton() || !m_hWnd)
  640. {
  641. return m_bChecked;
  642. }
  644. return (BOOL)::SendMessage(m_hWnd, BM_GETCHECK, 0, 0);
  645. }
  647. void CXTPButton::SetChecked(BOOL bChecked)
  648. {
  649. if (IsPushButton() || !m_hWnd)
  650. {
  651. m_bChecked = bChecked;
  652. RedrawButton();
  653. }
  654. else
  655. {
  656. ::SendMessage(m_hWnd, BM_SETCHECK, bChecked, 0);
  657. }
  658. }
  660. BOOL CXTPButton::SetIcon(CSize size, UINT nID, UINT nHotID/*= 0*/, BOOL bRedraw/*= TRUE*/)
  661. {
  662. return CXTPButton::SetIcon(
  663. size, MAKEINTRESOURCE(nID), MAKEINTRESOURCE(nHotID), bRedraw);
  664. }
  666. BOOL CXTPButton::SetIcon(CSize size, LPCTSTR lpszID, LPCTSTR lpszHotID/*= NULL*/, BOOL bRedraw/*= TRUE*/)
  667. {
  668. CXTPImageManagerIconHandle hIcon;
  669. CXTPImageManagerIconHandle hIconHot;
  671. hIcon.CreateIconFromResource(lpszID, size);
  673. // Return false if the icon handle is NULL.
  674. if (hIcon.IsEmpty())
  675. {
  676. TRACE0("Failed to load Icon resource.n");
  677. return FALSE;
  678. }
  680. // If we are using a pushed image as well...
  681. if (lpszHotID)
  682. {
  683. hIconHot.CreateIconFromResource(lpszHotID, size);
  685. // Return false if the icon handle is NULL.
  686. if (hIconHot.IsEmpty())
  687. {
  688. TRACE0("Failed to load Icon resource.n");
  689. return FALSE;
  690. }
  691. }
  693. return CXTPButton::SetIcon(size, hIcon, hIconHot, bRedraw);
  694. }
  696. BOOL CXTPButton::SetIcon(CSize /*size*/, CXTPImageManagerIcon* pIcon, BOOL bRedraw/*= TRUE*/)
  697. {
  698. // Construct the icon manager.
  699. CMDTARGET_RELEASE(m_pIcon);
  701. m_pIcon = pIcon;
  703. // Redraw the button.
  704. if (bRedraw)
  705. RedrawButton();
  707. return TRUE;
  708. }
  710. BOOL CXTPButton::SetIcon(CSize size, const CXTPImageManagerIconHandle& hIcon, const CXTPImageManagerIconHandle& hIconHot, BOOL bRedraw/*= TRUE*/)
  711. {
  712. ASSERT(!hIcon.IsEmpty());
  714. // Save the image size and set the icon
  715. // handles to NULL.
  716. size = size != CSize(0) ? size : hIcon.GetExtent();
  718. CXTPImageManagerIcon* pIcon = new CXTPImageManagerIcon(0, size.cx, size.cy);
  719. pIcon->SetIcon(hIcon);
  721. if (!hIconHot.IsEmpty())
  722. pIcon->SetHotIcon(hIconHot);
  724. return SetIcon(size, pIcon, bRedraw);
  725. }
  728. BOOL CXTPButton::SetIcon(CSize size, HICON hIcon, HICON hIconHot/*= NULL*/, BOOL bRedraw/*= TRUE*/)
  729. {
  730. return SetIcon(size, CXTPImageManagerIconHandle(hIcon), CXTPImageManagerIconHandle(hIconHot), bRedraw);
  731. }
  733. BOOL CXTPButton::SetBitmap(CSize size, UINT nID, BOOL bRedraw/*= TRUE*/)
  734. {
  735. // Free previous resources (if any).
  737. CXTPImageManagerIconHandle hIconHandle;
  739. BOOL bAlphaBitmap = FALSE;
  740. HBITMAP hBitmap = CXTPImageManagerIcon::LoadBitmapFromResource(MAKEINTRESOURCE(nID), &bAlphaBitmap);
  742. if (!hBitmap)
  743. return FALSE;
  745. if (bAlphaBitmap)
  746. {
  747. hIconHandle = hBitmap; // Will call DeleteObject;
  748. }
  749. else
  750. {
  751. CBitmap bmpIcon;
  752. bmpIcon.Attach(hBitmap);
  754. // convert the bitmap to a transparent icon.
  755. HICON hIcon = CXTPTransparentBitmap(bmpIcon).ConvertToIcon();
  757. hIconHandle = hIcon; // Will call DestoyIcon;
  758. }
  760. if (hIconHandle.IsEmpty())
  761. return FALSE;
  763. return CXTPButton::SetIcon(size, hIconHandle, CXTPImageManagerIconHandle(), bRedraw);
  764. }
  766. //////////////////////////////////////////////////////////////////////
  767. // Construction/Destruction
  768. //////////////////////////////////////////////////////////////////////
  770. CXTPButtonTheme::CXTPButtonTheme()
  771. {
  772. m_nBorderWidth = 4;
  773. m_bOffsetHiliteText = TRUE;
  774. m_bFlatGlyphs = FALSE;
  776. m_cxBorder = GetSystemMetrics(SM_CXBORDER);
  777. m_cyBorder = GetSystemMetrics(SM_CYBORDER);
  778. m_cxEdge = GetSystemMetrics(SM_CXEDGE);
  779. m_cyEdge = GetSystemMetrics(SM_CYEDGE);
  781. }
  783. CXTPButtonTheme::~CXTPButtonTheme()
  784. {
  786. }
  788. void CXTPButtonTheme::RefreshMetrics(CXTPButton* /*pButton*/)
  789. {
  790. m_themeButton.OpenTheme(0, L"BUTTON");
  792. RefreshXtremeColors();
  794. // background colors.
  795. m_crBack.SetStandardValue(GetXtremeColor(COLOR_BTNFACE));
  797. // text colors.
  798. m_crText.SetStandardValue(GetXtremeColor(COLOR_BTNTEXT));
  799. m_crTextDisabled.SetStandardValue(GetXtremeColor(COLOR_GRAYTEXT));
  801. // border colors.
  802. m_crBorderHilite.SetStandardValue(GetXtremeColor(COLOR_BTNFACE));
  803. m_crBorderShadow.SetStandardValue(GetXtremeColor(COLOR_3DSHADOW));
  804. m_crBorder3DHilite.SetStandardValue(GetXtremeColor(COLOR_3DHILIGHT));
  805. m_crBorder3DShadow.SetStandardValue(GetXtremeColor(COLOR_3DDKSHADOW));
  806. }
  808. void CXTPButtonTheme::DrawFocusRect(CDC* pDC, CXTPButton* pButton)
  809. {
  810. if ((pButton->SendMessage(WM_QUERYUISTATE) & UISF_HIDEFOCUS) == 0)
  811. {
  812. pDC->SetTextColor(GetXtremeColor(COLOR_BTNTEXT));
  813. CXTPClientRect rcItem(pButton);
  815. rcItem.DeflateRect(m_nBorderWidth, m_nBorderWidth);
  817. pDC->DrawFocusRect(rcItem);
  818. }
  819. }
  824. void CXTPButtonTheme::DrawButtonVisualStyleBackground(CDC* pDC, CXTPButton* pButton)
  825. {
  826. BOOL bPressed = pButton->IsPushed();
  827. BOOL bHot = pButton->IsHighlighted();
  828. BYTE bStyle = pButton->GetButtonStyle();
  829. BOOL bDefault = bStyle == BS_DEFPUSHBUTTON;
  830. BOOL bEnabled = pButton->IsWindowEnabled();
  831. BOOL bChecked = pButton->GetChecked();
  832. CXTPClientRect rc(pButton);
  834. int nState = !bEnabled? PBS_DISABLED: bPressed? PBS_PRESSED: bHot? PBS_HOT: bChecked ? PBS_PRESSED : bDefault? PBS_DEFAULTED: PBS_NORMAL;
  835. m_themeButton.DrawThemeBackground(pDC->GetSafeHdc(), BP_PUSHBUTTON, nState, rc, NULL);
  836. }
  838. void CXTPButtonTheme::DrawButtonBackground(CDC* pDC, CXTPButton* pButton)
  839. {
  840. BOOL bPressed = pButton->IsPushed();
  841. BOOL bHot = pButton->IsHighlighted();
  842. BYTE bStyle = pButton->GetButtonStyle();
  843. BOOL bDefault = bStyle == BS_DEFPUSHBUTTON;
  844. BOOL bChecked = pButton->GetChecked();
  845. CXTPClientRect rc(pButton);
  847. if (pButton->GetFlatStyle() && !bHot && !bPressed && !bChecked)
  848. return;
  850. if (pButton->GetUseVisualStyle() && m_themeButton.IsAppThemed())
  851. {
  852. DrawButtonVisualStyleBackground(pDC, pButton);
  853. return;
  854. }
  856. pDC->FillSolidRect(rc, pButton->GetButtonBackColor());
  858. BOOL bSelected = bPressed || bChecked;
  860. if (bDefault)
  861. {
  862. pDC->Draw3dRect(rc, m_crBorder3DShadow, m_crBorder3DShadow);
  863. rc.DeflateRect(1,1);
  864. }
  866. pDC->Draw3dRect(rc,
  867. bSelected ? m_crBorder3DShadow : m_crBorder3DHilite,
  868. bSelected ? m_crBorder3DHilite : m_crBorder3DShadow);
  870. rc.DeflateRect(1, 1);
  872. pDC->Draw3dRect(rc,
  873. bSelected ? m_crBorderShadow : m_crBorderHilite,
  874. bSelected ? m_crBorderHilite : m_crBorderShadow);
  875. }
  878. COLORREF CXTPButtonTheme::GetTextColor(CXTPButton* pButton)
  879. {
  880. if (!pButton->IsWindowEnabled())
  881. {
  882. return m_crTextDisabled;
  883. }
  885. return pButton->GetButtonTextColor();
  886. }
  888. AFX_INLINE BOOL IsAlignRight (int nAlign) { return (nAlign & BS_HORZMASK) == BS_RIGHT;}
  889. AFX_INLINE BOOL IsAlignCenter (int nAlign) { return (nAlign & BS_HORZMASK) == BS_CENTER;}
  890. AFX_INLINE BOOL IsAlignTop (int nAlign) { return (nAlign & BS_VERTMASK) == BS_TOP;}
  891. AFX_INLINE BOOL IsAlignBottom (int nAlign) { return (nAlign & BS_VERTMASK) == BS_BOTTOM;}
  892. AFX_INLINE BOOL IsAlignMiddle (int nAlign) { return (nAlign & BS_VERTMASK) == BS_VCENTER;}
  895. void CXTPButtonTheme::DrawButtonText(CDC* pDC, CXTPButton* pButton)
  896. {
  897. pDC->SetTextColor(pButton->IsWindowEnabled() ?
  898. pButton->GetButtonTextColor() : m_crTextDisabled);
  900. static const BYTE buttonsStyles[] =
  901. {
  902. CBR_PUSHBUTTON,
  903. CBR_PUSHBUTTON,
  904. CBR_CHECKTEXT,
  905. CBR_CHECKTEXT,
  906. CBR_RADIOTEXT,
  907. CBR_CHECKTEXT,
  908. CBR_CHECKTEXT,
  909. CBR_GROUPTEXT,
  910. CBR_CLIENTRECT,
  911. CBR_RADIOTEXT,
  912. CBR_CLIENTRECT,
  913. CBR_PUSHBUTTON,
  914. };
  916. RECT    rc;
  917. int     x, y, cx = 0, cy = 0;
  919. CString strText;
  920. UINT dsFlags = DT_SINGLELINE | DT_LEFT | DT_TOP | DT_NOCLIP;
  921. BYTE bStyle = pButton->GetButtonStyle();
  923. DWORD dwStyle = pButton->GetStyle();
  925. BOOL pbfPush = pButton->IsPushButton();
  926. if (pbfPush)
  927. {
  928. CalcRect(pDC, pButton, &rc, CBR_PUSHBUTTON);
  929. }
  930. else
  931. {
  932. CalcRect(pDC, pButton, &rc, buttonsStyles[bStyle]);
  933. }
  935. // Alignment
  936. strText = pButton->GetButtonText();
  937. UINT wAlignment = pButton->GetTextAlignment();
  939. HGDIOBJ hImage = 0;
  941. if (pButton->GetStyle() & BS_BITMAP)
  942. {
  943. hImage = (HGDIOBJ)pButton->SendMessage(BM_GETIMAGE, IMAGE_BITMAP);
  944. if (!hImage)
  945. return;
  947. BITMAP bmp;
  948. GetObject(hImage, sizeof(BITMAP), &bmp);
  949. cx = bmp.bmWidth;
  950. cy = bmp.bmHeight;
  951. }
  952. else if (pButton->GetStyle() & BS_ICON)
  953. {
  954. hImage = (HGDIOBJ)pButton->SendMessage(BM_GETIMAGE, IMAGE_ICON);
  955. if (!hImage)
  956. return;
  958. cx = cy = 16;
  959. }
  960. else
  961. {
  962. // Text button
  963. if (strText.IsEmpty())
  964. return;
  966. if (pButton->GetMarkupUIElement())
  967. {
  968. XTPMarkupSetDefaultFont(pButton->GetMarkupContext(), (HFONT)pButton->SendMessage(WM_GETFONT), COLORREF_NULL);
  970. CSize sz = XTPMarkupMeasureElement(pButton->GetMarkupUIElement(), rc.right - rc.left, rc.bottom - rc.top);
  972. cx = sz.cx;
  973. cy = sz.cy;
  975. }
  976. else
  977. {
  978. if (pButton->GetStyle() & BS_MULTILINE)
  979. {
  980. dsFlags |= DT_WORDBREAK | DT_EDITCONTROL;
  981. dsFlags &= ~DT_SINGLELINE;
  982. }
  984. CRect rcText(0, 0, rc.right - rc.left, 0);
  985. pDC->DrawText(strText, rcText, dsFlags | DT_CALCRECT);
  987. cx = rcText.Width();
  988. cy = rcText.Height();
  989. }
  990. }
  992. CRect rcText(rc);
  993. if (pbfPush && ((pButton->GetStyle() & BS_MULTILINE) == 0)) rcText.DeflateRect(m_cxBorder, m_cyBorder);
  995. // Horizontal
  996. switch (wAlignment & BS_HORZMASK)
  997. {
  998. case BS_LEFT:
  999. x = rc.left + (pbfPush ? m_cxBorder : 0);
  1000. break;
  1002. case BS_RIGHT:
  1003. x = rc.right - cx -  (pbfPush ? m_cxBorder : 0);
  1004. dsFlags |= DT_RIGHT;
  1005. break;
  1007. default:
  1008. x = (rc.left + rc.right - cx) / 2;
  1009. dsFlags |= DT_CENTER;
  1010. break;
  1011. }
  1013. // Vertical
  1014. switch (wAlignment & BS_VERTMASK)
  1015. {
  1016. case BS_TOP:
  1017. y = rc.top + (pbfPush ? m_cyBorder : 0);
  1018. break;
  1020. case BS_BOTTOM:
  1021. y = rc.bottom - cy - (pbfPush ? m_cyBorder : 0);
  1022. dsFlags |= DT_BOTTOM;
  1023. break;
  1025. default:
  1026. y = (rc.top + rc.bottom - cy) / 2;
  1027. dsFlags |= DT_VCENTER;
  1028. break;
  1029. }
  1031. if (dwStyle & BS_BITMAP)
  1032. {
  1033. pDC->DrawState(CPoint(x, y), CSize(cx, cy), (HBITMAP)hImage, DSS_NORMAL, 0);
  1034. }
  1035. else if (dwStyle & BS_ICON)
  1036. {
  1037. pDC->DrawState(CPoint(x, y), CSize(cx, cy), (HICON)hImage, DSS_NORMAL, (HBRUSH)0);
  1038. }
  1039. else if (bStyle !=  LOBYTE(BS_USERBUTTON))
  1040. {
  1041. if (pButton->GetMarkupUIElement())
  1042. {
  1043. XTPMarkupSetDefaultFont(pButton->GetMarkupContext(), NULL, pDC->GetTextColor());
  1045. XTPMarkupRenderElement(pButton->GetMarkupUIElement(), pDC->GetSafeHdc(), CRect(x, y, x + cx, y + cy));
  1046. }
  1047. else
  1048. {
  1049. if (pButton->GetExStyle() & WS_EX_RTLREADING)
  1050. dsFlags |= DT_RTLREADING;
  1052. if (pButton->SendMessage(WM_QUERYUISTATE) & UISF_HIDEACCEL)
  1053. {
  1054. dsFlags |= DT_HIDEPREFIX;
  1055. }
  1057. if (dwStyle & BS_MULTILINE)
  1058. {
  1059. pDC->DrawText(strText, CRect(x, y, x + cx, y + cy), dsFlags | DT_NOCLIP);
  1060. }
  1061. else
  1062. {
  1063. pDC->DrawText(strText, rcText, dsFlags);
  1064. }
  1065. }
  1066. }
  1068. if (::GetFocus() == pButton->m_hWnd && pButton->GetShowFocus())
  1069. {
  1070. if ((pButton->SendMessage(WM_QUERYUISTATE) & UISF_HIDEFOCUS) == 0)
  1071. {
  1072. if (!pbfPush)
  1073. {
  1075. RECT rcClient;
  1076. pButton->GetClientRect(&rcClient);
  1078. if (bStyle == LOBYTE(BS_USERBUTTON))
  1079. CopyRect(&rc, &rcClient);
  1080. else
  1081. {
  1082. // Try to leave a border all around text.  That causes
  1083. // focus to hug text.
  1084. rc.top = max(rcClient.top, y - m_cyBorder);
  1085. rc.bottom = min(rcClient.bottom, rc.top + m_cyEdge + cy);
  1087. rc.left = max(rcClient.left, x-m_cxBorder);
  1088. rc.right = min(rcClient.right, rc.left + m_cxEdge + cx);
  1089. }
  1090. }
  1091. else
  1092. InflateRect(&rc, -m_cxBorder, -m_cyBorder);
  1094. pDC->SetTextColor(GetXtremeColor(COLOR_BTNTEXT));
  1095. pDC->SetBkColor(GetXtremeColor(COLOR_WINDOW));
  1097. // Are back & fore colors set properly?
  1098. ::DrawFocusRect(pDC->GetSafeHdc(), &rc);
  1099. }
  1100. }
  1101. }
  1103. void CXTPButtonTheme::CalcRect(CDC* pDC, CXTPButton* pButton, LPRECT lprc, int code)
  1104. {
  1105. int dy;
  1106. UINT align;
  1107. CSize extent;
  1109. pButton->GetClientRect(lprc);
  1111. align = pButton->GetTextAlignment();
  1113. switch (code)
  1114. {
  1115. case CBR_PUSHBUTTON:
  1116. // Subtract out raised edge all around
  1117. InflateRect(lprc, -m_cxEdge, -m_cyEdge);
  1118. break;
  1120. case CBR_CHECKBOX:
  1121. case CBR_RADIOBOX:
  1122. {
  1123. CSize szGlyph = pButton->GetGlyphSize(code == CBR_CHECKBOX);
  1125. switch (align & BS_VERTMASK)
  1126. {
  1127. case BS_VCENTER:
  1128. lprc->top = (lprc->top + lprc->bottom - szGlyph.cy) / 2;
  1129. break;
  1131. case BS_TOP:
  1132. case BS_BOTTOM:
  1133. {
  1134. extent = pDC->GetTextExtent(_T(" "), 1);
  1135. dy = extent.cy + extent.cy/4;
  1137. // Save vertical extent
  1138. extent.cx = dy;
  1140. // Get centered amount
  1142. dy = (dy - szGlyph.cy) / 2;
  1143. if ((align & BS_VERTMASK) == BS_TOP)
  1144. lprc->top += dy;
  1145. else
  1146. lprc->top = lprc->bottom - extent.cx + dy;
  1147. break;
  1148. }
  1149. }
  1150. lprc->bottom = lprc->top + szGlyph.cy;
  1152. if (pButton->GetStyle() & BS_RIGHTBUTTON)
  1153. lprc->left = lprc->right - szGlyph.cx;
  1154. else
  1155. lprc->right = lprc->left + szGlyph.cx;
  1156. }
  1157. break;
  1159. case CBR_CHECKTEXT:
  1160. case CBR_RADIOTEXT:
  1161. {
  1162. int nOffset = pButton->GetGlyphSize(code == CBR_CHECKBOX).cx + 3;
  1163. if (pButton->GetStyle() & BS_RIGHTBUTTON)
  1164. {
  1165. lprc->right -= nOffset;
  1166. }
  1167. else
  1168. {
  1169. lprc->left += nOffset;
  1170. }
  1171. }
  1172. break;
  1174. case CBR_GROUPTEXT:
  1175. {
  1176. CString strText = pButton->GetButtonText();
  1177. XTPDrawHelpers()->StripMnemonics(strText);
  1179. if (strText.IsEmpty())
  1180. {
  1181. SetRectEmpty(lprc);
  1182. break;
  1183. }
  1185. extent = pDC->GetTextExtent(strText);
  1187. extent.cx += m_cxEdge * 2;
  1189. // Left Align. TODO!
  1190. if (pButton->GetBorderStyle() == 1)
  1191. {
  1192. if (pButton->GetTextAlignment() & BS_RIGHT)
  1193. {
  1194. lprc->left = lprc->right - (int)(extent.cx);
  1195. }
  1196. else
  1197. lprc->right = lprc->left + (int)(extent.cx);
  1198. }
  1199. else if (pButton->GetTextAlignment() & BS_RIGHT)
  1200. {
  1201. lprc->right -= 6 + m_cxBorder;
  1202. lprc->left += lprc->right - (int)(extent.cx);
  1203. }
  1204. else
  1205. {
  1206. lprc->left += 8 + m_cxBorder;
  1207. lprc->right = lprc->left + (int)(extent.cx);
  1208. }
  1210. lprc->bottom = lprc->top + extent.cy;
  1211. }
  1212. break;
  1214. case CBR_GROUPFRAME:
  1215. extent = pDC->GetTextExtent(_T(" "), 1);
  1216. lprc->top += extent.cy / 2;
  1217. break;
  1218. }
  1219. }
  1221. void CXTPButtonTheme::CalcRects(CDC* pDC, CXTPButton* pButton, CRect* pButtonText, UINT* pDrawFlags, CRect* pButtonIcon)
  1222. {
  1223. CString strText = pButton->GetButtonText();
  1225. UINT dsFlags = DT_SINGLELINE | DT_LEFT | DT_TOP | DT_NOCLIP;
  1227. if (pButton->GetExStyle() & WS_EX_RTLREADING)
  1228. dsFlags |= DT_RTLREADING;
  1230. if (pButton->GetStyle() & BS_MULTILINE)
  1231. {
  1232. dsFlags |= DT_WORDBREAK | DT_EDITCONTROL;
  1233. dsFlags &= ~DT_SINGLELINE;
  1234. }
  1236. CRect rcItem;
  1237. pButton->GetClientRect(rcItem);
  1238. rcItem.DeflateRect(pButton->GetBorderGap(), pButton->GetBorderGap());
  1240. if (pButton->IsDropDownStyle())
  1241. {
  1242. rcItem.right -= 12 + (pButton->GetPushButtonStyle() == xtpButtonSplitDropDown ?
  1243. 2 : 1) * pButton->GetBorderGap() ;
  1244. }
  1246. int nTextImageRelation = pButton->GetTextImageRelation();
  1247. int nTextAlign = pButton->GetTextAlignment();
  1248. int nImageAlign = pButton->GetImageAlignment();
  1249. CSize sizeImage = pButton->GetImageSize();
  1251. if (sizeImage.cx == 0 || strText.IsEmpty())
  1252. nTextImageRelation = xtpButtonOverlay;
  1254. CSize sizeText = CSize(rcItem.Width(), 0);
  1256. switch (nTextImageRelation)
  1257. {
  1258. case xtpButtonImageBeforeText:
  1259. case xtpButtonTextBeforeImage:
  1260. sizeImage.cx += pButton->GetImageGap();
  1261. sizeText.cx -= sizeImage.cx;
  1262. break;
  1263. case xtpButtonImageAboveText:
  1264. case xtpButtonTextAboveImage:
  1265. sizeImage.cy += pButton->GetImageGap();
  1266. break;
  1267. }
  1269. if (!strText.IsEmpty())
  1270. {
  1271. if (pButton->GetMarkupUIElement())
  1272. {
  1273. XTPMarkupSetDefaultFont(pButton->GetMarkupContext(), (HFONT)pButton->SendMessage(WM_GETFONT), (COLORREF)-1);
  1275. CSize szDesiredSize = XTPMarkupMeasureElement(pButton->GetMarkupUIElement(), sizeText.cx, rcItem.Height());
  1277. sizeText = CSize(min(sizeText.cx, szDesiredSize.cx), szDesiredSize.cy);
  1278. }
  1279. else
  1280. {
  1281. CRect rcTextCalc(0, 0, sizeText.cx, 0);
  1282. pDC->DrawText(strText, rcTextCalc, dsFlags | DT_CALCRECT);
  1283. sizeText = CSize(min(sizeText.cx, rcTextCalc.Width()), rcTextCalc.Height());
  1284. }
  1285. }
  1286. else
  1287. {
  1288. sizeText = CSize(0, 0);
  1289. }
  1291. if (nTextImageRelation == xtpButtonOverlay && pButtonText) sizeImage = CSize(0, 0);
  1292. if (nTextImageRelation == xtpButtonOverlay && pButtonIcon) sizeText = CSize(0, 0);
  1294. CRect rcText(rcItem);
  1295. CPoint ptImage(rcItem.TopLeft());
  1297. ptImage.x = IsAlignRight(nImageAlign) ? rcItem.right - sizeImage.cx :
  1298. IsAlignCenter(nImageAlign) ? (rcItem.left + rcItem.right - sizeImage.cx) /2 : rcItem.left;
  1300. ptImage.y = IsAlignBottom(nImageAlign) ? rcItem.bottom - sizeImage.cy :
  1301. IsAlignMiddle(nImageAlign) ? (rcItem.top + rcItem.bottom - sizeImage.cy) / 2 : rcItem.top;
  1303. rcText.left = IsAlignRight(nTextAlign) ? rcText.right - sizeText.cx :
  1304. IsAlignCenter(nTextAlign) ? (rcText.left + rcText.right - sizeText.cx) / 2 : rcItem.left;
  1306. dsFlags |= IsAlignRight(nTextAlign) ? DT_RIGHT: IsAlignCenter(nTextAlign) ? DT_CENTER : DT_LEFT;
  1308. rcText.top = IsAlignBottom(nTextAlign) ? rcText.bottom - sizeText.cy :
  1309. IsAlignMiddle(nTextAlign) ? (rcText.top + rcText.bottom - sizeText.cy) / 2 : rcItem.top;
  1312. switch (nTextImageRelation)
  1313. {
  1314. case xtpButtonImageBeforeText:
  1315. ptImage.x = IsAlignRight(nImageAlign) ?
  1316. rcItem.right - (sizeImage.cx + sizeText.cx):
  1317. IsAlignCenter(nImageAlign) ?
  1318. (rcItem.left + rcItem.right - (sizeImage.cx + sizeText.cx)) /2 :
  1319. rcItem.left;
  1321. rcText.left = max(rcText.left, ptImage.x + sizeImage.cx);
  1322. break;
  1324. case xtpButtonImageAboveText:
  1325. ptImage.y = IsAlignBottom(nImageAlign) ?
  1326. rcItem.bottom - (sizeImage.cy + sizeText.cy):
  1327. IsAlignMiddle(nImageAlign) ?
  1328. (rcItem.top + rcItem.bottom - (sizeImage.cy + sizeText.cy)) /2 :
  1329. rcItem.top;
  1331. rcText.top = max(rcText.top, ptImage.y + sizeImage.cy);
  1332. break;
  1334. case xtpButtonTextBeforeImage:
  1335. ptImage.x = pButton->GetImageGap() +
  1336. (IsAlignRight(nImageAlign) ?
  1337. rcItem.right - sizeImage.cx :
  1338. IsAlignCenter(nImageAlign) ?
  1339. (rcItem.left + rcItem.right + (-sizeImage.cx + sizeText.cx)) /2 :
  1340. rcItem.left + sizeText.cx);
  1342. if (rcText.left + sizeText.cx + pButton->GetImageGap() > ptImage.x)
  1343. rcText.left = ptImage.x - sizeText.cx - pButton->GetImageGap();
  1344. break;
  1346. case xtpButtonTextAboveImage:
  1347. ptImage.y = pButton->GetImageGap() +
  1348. (IsAlignBottom(nImageAlign) ?
  1349. rcItem.bottom - sizeImage.cy :
  1350. IsAlignMiddle(nImageAlign) ?
  1351. (rcItem.top + rcItem.bottom + (-sizeImage.cy + sizeText.cy)) /2 :
  1352. rcItem.top + sizeText.cy);
  1354. if (rcText.top + sizeText.cy + pButton->GetImageGap() > ptImage.y)
  1355. rcText.top = ptImage.y - sizeText.cy - pButton->GetImageGap();
  1356. break;
  1357. }
  1360. rcText.right = rcText.left + sizeText.cx;
  1361. rcText.bottom = rcText.top + sizeText.cy;
  1363. if (pButtonText) *pButtonText = rcText;
  1364. if (pButtonIcon) *pButtonIcon = CRect(ptImage, sizeImage);
  1365. if (pDrawFlags) *pDrawFlags = dsFlags;
  1366. }
  1368. BOOL CXTPButtonTheme::IsVisualThemeUsed(CXTPButton* pButton)
  1369. {
  1370. return (m_themeButton.IsAppThemed() && pButton->GetUseVisualStyle());
  1371. }
  1373. void CXTPButtonTheme::DrawPushButtonDropDown(CDC* pDC, CXTPButton* pButton)
  1374. {
  1375. CRect rcItem;
  1376. pButton->GetClientRect(rcItem);
  1377. rcItem.DeflateRect(pButton->GetBorderGap(), pButton->GetBorderGap());
  1379. CString strText = pButton->GetButtonText();
  1381. BOOL bEmpty = strText.IsEmpty() && pButton->GetImageSize() == CSize(0, 0);
  1383. if (!bEmpty)
  1384. rcItem.left = rcItem.right - 16;
  1386. BOOL  bSelected = pButton->GetChecked() || pButton->IsPushed();
  1387. if (bSelected && (m_bOffsetHiliteText || IsVisualThemeUsed(pButton)))
  1388. rcItem.OffsetRect(1, 1);
  1390. CPoint ptCenter = rcItem.CenterPoint();
  1391. BOOL bEnabled = pButton->IsWindowEnabled();
  1393. if (pButton->GetPushButtonStyle() == xtpButtonDropDown)
  1394. {
  1395. XTPDrawHelpers()->Triangle(pDC, CPoint(ptCenter.x - 4, ptCenter.y - 2),
  1396. CPoint(ptCenter.x + 4, ptCenter.y - 2),CPoint(ptCenter.x, ptCenter.y + 2), !bEnabled ? GetXtremeColor(COLOR_GRAYTEXT) : 0);
  1397. }
  1398. if (pButton->GetPushButtonStyle() == xtpButtonDropDownRight)
  1399. {
  1400. XTPDrawHelpers()->Triangle(pDC, CPoint(ptCenter.x - 2, ptCenter.y - 4),
  1401. CPoint(ptCenter.x - 2, ptCenter.y + 4),CPoint(ptCenter.x + 2, ptCenter.y ), !bEnabled ? GetXtremeColor(COLOR_GRAYTEXT) : 0);
  1402. }
  1404. if (pButton->GetPushButtonStyle() == xtpButtonSplitDropDown)
  1405. {
  1406. ptCenter.x += 1;
  1407. XTPDrawHelpers()->Triangle(pDC, CPoint(ptCenter.x - 4, ptCenter.y - 2),
  1408. CPoint(ptCenter.x + 4, ptCenter.y - 2),CPoint(ptCenter.x, ptCenter.y + 2), !bEnabled ? GetXtremeColor(COLOR_GRAYTEXT) : 0);
  1410. COLORREF crBorderShadow = !bEnabled ? GetXtremeColor(COLOR_GRAYTEXT) : IsVisualThemeUsed(pButton) ?  GetSysColor(COLOR_BTNSHADOW) : m_crBorderShadow;
  1412. pDC->FillSolidRect(rcItem.left, rcItem.top, 1, rcItem.Height(), crBorderShadow);
  1413. pDC->FillSolidRect(rcItem.left + 1, rcItem.top, 1, rcItem.Height(), GetSysColor(COLOR_BTNHIGHLIGHT));
  1414. }
  1415. }
  1418. void CXTPButtonTheme::DrawPushButtonText(CDC* pDC, CXTPButton* pButton)
  1419. {
  1420. CString strText = pButton->GetButtonText();
  1422. // if the string is empty just return.
  1423. if (strText.IsEmpty())
  1424. return;
  1426. CRect rcText;
  1427. UINT dsFlags;
  1428. CalcRects(pDC, pButton, &rcText, &dsFlags, NULL);
  1430. BOOL  bSelected = pButton->GetChecked() || pButton->IsPushed();
  1432. if (bSelected && (m_bOffsetHiliteText || (IsVisualThemeUsed(pButton))))
  1433. rcText.OffsetRect(1, 1);
  1435. COLORREF clrText = GetTextColor(pButton);
  1436. pDC->SetTextColor(clrText);
  1438. if (pButton->GetMarkupUIElement())
  1439. {
  1440. XTPMarkupSetDefaultFont(pButton->GetMarkupContext(), NULL, clrText);
  1442. XTPMarkupRenderElement(pButton->GetMarkupUIElement(), pDC->GetSafeHdc(), rcText);
  1444. }
  1445. else
  1446. {
  1447. if (pButton->SendMessage(WM_QUERYUISTATE) & UISF_HIDEACCEL)
  1448. {
  1449. dsFlags |= DT_HIDEPREFIX;
  1450. }
  1451. pDC->DrawText(strText, rcText, dsFlags);
  1452. }
  1453. }
  1455. void CXTPButtonTheme::DrawPushButtonIcon(CDC* pDC, CXTPButton* pButton)
  1456. {
  1457. CSize sz = pButton->GetImageSize();
  1458. if (sz == CSize(0, 0))
  1459. return;
  1461. CRect rcImage;
  1462. CalcRects(pDC, pButton, NULL, NULL, &rcImage);
  1464. CPoint pt = rcImage.TopLeft();
  1466. BOOL  bSelected = pButton->GetChecked() || pButton->IsPushed();
  1468. if (bSelected && (m_bOffsetHiliteText || (IsVisualThemeUsed(pButton))))
  1469. pt.Offset(1, 1);
  1471. pButton->DrawImage(pDC, CRect(pt, sz));
  1472. }
  1474. void CXTPButtonTheme::DrawCheckBoxMark(CDC* pDC, CXTPButton* pButton)
  1475. {
  1476. BOOL bPressed = pButton->IsPushed();
  1477. BOOL bHot = pButton->IsHighlighted();
  1478. BYTE bStyle = pButton->GetButtonStyle();
  1479. BOOL bEnabled = pButton->IsWindowEnabled();
  1480. BOOL bChecked = pButton->GetChecked();
  1482. CRect rcRadio;
  1483. CalcRect(pDC, pButton, &rcRadio, CBR_CHECKBOX);
  1485. if (IsVisualThemeUsed(pButton))
  1486. {
  1487. int nState = !bEnabled? RBS_UNCHECKEDDISABLED: bPressed? RBS_UNCHECKEDPRESSED: bHot? RBS_UNCHECKEDHOT: RBS_UNCHECKEDNORMAL;
  1488. if (bChecked)
  1489. nState += 4;
  1490. if ((bChecked == BST_INDETERMINATE) && (bStyle == BS_AUTO3STATE || bStyle == BS_3STATE))
  1491. nState += 4;
  1493. m_themeButton.DrawThemeBackground(pDC->GetSafeHdc(), BP_CHECKBOX, nState, rcRadio, NULL);
  1494. return;
  1495. }
  1497. int nButton = ((bChecked == BST_INDETERMINATE) && (bStyle == BS_AUTO3STATE || bStyle == BS_3STATE))
  1498. ? DFCS_BUTTON3STATE : DFCS_BUTTONCHECK;
  1500. DrawFrameControl(pDC->GetSafeHdc(), rcRadio, DFC_BUTTON, nButton | (m_bFlatGlyphs ? DFCS_FLAT : 0) |
  1501. (bChecked ? DFCS_CHECKED : 0) | (bPressed ? DFCS_PUSHED : 0) | (bEnabled ? 0 : DFCS_INACTIVE));
  1502. }
  1504. void CXTPButtonTheme::DrawRadioButtonMark(CDC* pDC, CXTPButton* pButton)
  1505. {
  1506. BOOL bPressed = pButton->IsPushed();
  1507. BOOL bHot = pButton->IsHighlighted();
  1508. BOOL bEnabled = pButton->IsWindowEnabled();
  1509. BOOL bChecked = pButton->GetChecked();
  1511. CRect rcRadio;
  1512. CalcRect(pDC, pButton, &rcRadio, CBR_RADIOBOX);
  1514. if (IsVisualThemeUsed(pButton))
  1515. {
  1516. int nState = !bEnabled? RBS_UNCHECKEDDISABLED: bPressed? RBS_UNCHECKEDPRESSED: bHot? RBS_UNCHECKEDHOT: RBS_UNCHECKEDNORMAL;
  1517. if (bChecked) nState += 4;
  1519. m_themeButton.DrawThemeBackground(pDC->GetSafeHdc(), BP_RADIOBUTTON, nState, rcRadio, NULL);
  1520. return;
  1521. }
  1523. DrawFrameControl(pDC->GetSafeHdc(), rcRadio, DFC_BUTTON, DFCS_BUTTONRADIO | (m_bFlatGlyphs ? DFCS_FLAT : 0) |
  1524. (bChecked ? DFCS_CHECKED : 0) | (bPressed ? DFCS_PUSHED : 0) | (bEnabled ? 0 : DFCS_INACTIVE));
  1526. }
  1528. void CXTPButtonTheme::DrawGroupBox(CDC* pDC, CXTPButton* pButton)
  1529. {
  1530. BOOL bEnabled = pButton->IsWindowEnabled();
  1532. int nState = !bEnabled? GBS_DISABLED: GBS_NORMAL;
  1533. CRect rcGroupBox;
  1534. CalcRect(pDC, pButton, &rcGroupBox, CBR_GROUPFRAME);
  1536. CRect rcGrouText;
  1537. CalcRect(pDC, pButton, &rcGrouText, CBR_GROUPTEXT);
  1539. if (pButton->GetTextAlignment() & BS_RIGHT)
  1540. rcGrouText.OffsetRect(+m_cxEdge, 0);
  1541. else
  1542. rcGrouText.OffsetRect(-m_cxEdge, 0);
  1544. pDC->ExcludeClipRect(&rcGrouText);
  1546. if (pButton->GetBorderStyle() == 1)
  1547. {
  1548. if (IsVisualThemeUsed(pButton))
  1549. {
  1550. COLORREF clrLine = GetSysColor(COLOR_3DSHADOW);
  1551. m_themeButton.GetThemeColor(BP_GROUPBOX, GBS_NORMAL, TMT_BORDERCOLORHINT, &clrLine);
  1552. pDC->FillSolidRect(rcGroupBox.left, rcGroupBox.top, rcGroupBox.Width(), 1, clrLine);
  1553. }
  1554. else
  1555. {
  1556. DrawEdge(pDC->GetSafeHdc(), &rcGroupBox, EDGE_ETCHED, BF_TOP | (m_bFlatGlyphs ? BF_FLAT | BF_MONO : 0) );
  1557. }
  1559. }
  1560. else
  1561. {
  1562. if (IsVisualThemeUsed(pButton))
  1563. {
  1564. m_themeButton.DrawThemeBackground(pDC->GetSafeHdc(), BP_GROUPBOX, nState, rcGroupBox, NULL);
  1565. }
  1566. else
  1567. {
  1568. DrawEdge(pDC->GetSafeHdc(), &rcGroupBox, EDGE_ETCHED, BF_RECT |
  1569. (m_bFlatGlyphs ? BF_FLAT | BF_MONO : 0));
  1570. }
  1571. }
  1573. pDC->SelectClipRgn(NULL);
  1574. }
  1579. //////////////////////////////////////////////////////////////////////////
  1580. // CXTPButtonFlatTheme
  1582. CXTPButtonFlatTheme::CXTPButtonFlatTheme()
  1583. {
  1584. m_bFlatGlyphs = TRUE;
  1585. m_nBorderWidth = 4;
  1586. }
  1588. void CXTPButtonFlatTheme::DrawButtonBackground(CDC* pDC, CXTPButton* pButton)
  1589. {
  1590. BOOL bPressed = pButton->IsPushed();
  1591. BOOL bHot = pButton->IsHighlighted();
  1592. BYTE bStyle = pButton->GetButtonStyle();
  1593. BOOL bDefault = bStyle == BS_DEFPUSHBUTTON;
  1594. BOOL bChecked = pButton->GetChecked();
  1595. CXTPClientRect rc(pButton);
  1597. if (pButton->GetFlatStyle() && !bHot && !bPressed && !bChecked)
  1598. return;
  1600. if (pButton->GetUseVisualStyle() && m_themeButton.IsAppThemed())
  1601. {
  1602. DrawButtonVisualStyleBackground(pDC, pButton);
  1603. return;
  1604. }
  1606. pDC->FillSolidRect(rc, pButton->GetButtonBackColor());
  1608. COLORREF clrBorder = GetXtremeColor(COLOR_WINDOWFRAME);
  1610. if (bDefault)
  1611. {
  1612. pDC->Draw3dRect(rc, clrBorder, clrBorder);
  1613. rc.DeflateRect(1,1);
  1614. }
  1616. pDC->Draw3dRect(rc, clrBorder, clrBorder);
  1618. rc.DeflateRect(1, 1);
  1619. pDC->Draw3dRect(rc, GetXtremeColor(COLOR_WINDOW), GetXtremeColor(COLOR_WINDOW));
  1621. }
  1624. //////////////////////////////////////////////////////////////////////////
  1625. //
  1627. CXTPButtonUltraFlatTheme::CXTPButtonUltraFlatTheme()
  1628. {
  1629. m_bFlatGlyphs = TRUE;
  1630. m_nBorderWidth = 3;
  1631. m_bHiglightButtons = TRUE;
  1633. }
  1635. void CXTPButtonUltraFlatTheme::RefreshMetrics(CXTPButton* pButton)
  1636. {
  1637. CXTPButtonTheme::RefreshMetrics(pButton);
  1639. COLORREF clrWindow = GetXtremeColor(COLOR_WINDOW);
  1640. COLORREF clrToolBar = GetXtremeColor(XPCOLOR_TOOLBAR_FACE);
  1641. COLORREF clrFace = pButton->GetButtonBackColor();
  1643. m_crBack.SetStandardValue(clrFace);
  1645. COLORREF clrPushed = GetXtremeColor(COLOR_3DSHADOW);
  1646. clrPushed = XTPColorManager()->LightColor(clrPushed,
  1647. clrFace, 0x32);
  1648. m_crBackPushed.SetStandardValue(clrPushed);
  1650. COLORREF clrHighlight = clrFace;
  1651. clrHighlight = XTPColorManager()->LightColor(clrHighlight, clrWindow, 0x1E);
  1652. m_crBackHilite.SetStandardValue(clrHighlight);
  1654. COLORREF clrChecked =
  1655. RGB(GetRValue(clrWindow) * 40 / 100 + GetRValue(clrHighlight) * 10 / 100 + GetRValue(clrToolBar) * 50 / 100,
  1656. GetGValue(clrWindow) * 40 / 100 + GetGValue(clrHighlight) * 10 / 100 + GetGValue(clrToolBar) * 50 / 100,
  1657. GetBValue(clrWindow) * 40 / 100 + GetBValue(clrHighlight) * 10 / 100 + GetBValue(clrToolBar) * 50 / 100);
  1660. m_crBackChecked.SetStandardValue(clrChecked);
  1662. m_crBorderShadow.SetStandardValue(GetXtremeColor(COLOR_3DSHADOW));
  1663. m_crBorderHilite.SetStandardValue(GetXtremeColor(COLOR_3DSHADOW));
  1665. COLORREF clrText = pButton->GetButtonTextColor();
  1666. m_crText.SetStandardValue(clrText);
  1667. m_crTextHilite.SetStandardValue(clrText);
  1668. m_crTextPushed.SetStandardValue(clrText);
  1669. }
  1671. void CXTPButtonUltraFlatTheme::DrawButtonBackground(CDC* pDC, CXTPButton* pButton)
  1672. {
  1673. BOOL bPressed = pButton->IsPushed();
  1674. BOOL bHot = pButton->IsHighlighted();
  1675. BYTE bStyle = pButton->GetButtonStyle();
  1676. BOOL bDefault = bStyle == BS_DEFPUSHBUTTON;
  1677. BOOL bChecked = pButton->GetChecked();
  1678. CXTPClientRect rc(pButton);
  1680. if (pButton->GetFlatStyle() && !bHot && !bPressed && !bChecked)
  1681. return;
  1683. if (pButton->GetUseVisualStyle() && m_themeButton.IsAppThemed())
  1684. {
  1685. DrawButtonVisualStyleBackground(pDC, pButton);
  1686. return;
  1687. }
  1689. if (bDefault)
  1690. {
  1691. pDC->Draw3dRect(rc, m_crBorderShadow, m_crBorderShadow);
  1692. rc.DeflateRect(1,1);
  1693. }
  1695. if (bHot || bPressed || bChecked)
  1696. {
  1697. pDC->FillSolidRect(rc, bPressed ? m_crBackPushed :
  1698. bChecked ? (bHot ? m_crBackPushed : m_crBackChecked) : m_crBackHilite);
  1700. pDC->Draw3dRect(rc, m_crBorderHilite,
  1701. m_crBorderHilite);
  1702. }
  1703. else
  1704. {
  1705. pDC->FillSolidRect(rc, pButton->GetButtonBackColor());
  1707. pDC->Draw3dRect(rc, m_crBorderShadow, m_crBorderShadow);
  1708. }
  1709. }
  1711. void CXTPButtonUltraFlatTheme::DrawGroupBox(CDC* pDC, CXTPButton* pButton)
  1712. {
  1713. if (IsVisualThemeUsed(pButton))
  1714. {
  1715. CXTPButtonTheme::DrawGroupBox(pDC, pButton);
  1716. return;
  1717. }
  1719. CRect rcGroupBox;
  1720. CalcRect(pDC, pButton, &rcGroupBox, CBR_GROUPFRAME);
  1722. CRect rcGrouText;
  1723. CalcRect(pDC, pButton, &rcGrouText, CBR_GROUPTEXT);
  1725. if (pButton->GetTextAlignment() & BS_RIGHT)
  1726. rcGrouText.OffsetRect(+m_cxEdge, 0);
  1727. else
  1728. rcGrouText.OffsetRect(-m_cxEdge, 0);
  1730. pDC->ExcludeClipRect(&rcGrouText);
  1732. if (pButton->GetBorderStyle() == 1)
  1733. {
  1734. pDC->FillSolidRect(rcGroupBox.left, rcGroupBox.top, rcGroupBox.Width(), 1, m_crBorderShadow);
  1735. }
  1736. else
  1737. {
  1738. pDC->Draw3dRect(&rcGroupBox, m_crBorderShadow, m_crBorderShadow);
  1739. }
  1741. pDC->SelectClipRgn(NULL);
  1742. }
  1745. void CXTPButtonUltraFlatTheme::DrawCheckBoxMark(CDC* pDC, CXTPButton* pButton)
  1746. {
  1747. if (IsVisualThemeUsed(pButton))
  1748. {
  1749. CXTPButtonTheme::DrawCheckBoxMark(pDC, pButton);
  1750. return;
  1751. }
  1753. BOOL bPressed = pButton->IsPushed();
  1754. BOOL bSelected = pButton->IsHighlighted();
  1755. BOOL bEnabled = pButton->IsWindowEnabled();
  1756. BOOL bChecked = pButton->GetChecked();
  1757. CXTPClientRect rCXTPButton(pButton);
  1760. CRect rc;
  1761. CalcRect(pDC, pButton, &rc, CBR_CHECKBOX);
  1763. if (!bEnabled)
  1764. {
  1765. pDC->FillSolidRect(rc, GetXtremeColor(COLOR_3DFACE));
  1766. pDC->Draw3dRect(rc, GetXtremeColor(XPCOLOR_GRAYTEXT), GetXtremeColor(XPCOLOR_GRAYTEXT));
  1767. }
  1768. else
  1769. {
  1770. if (!m_bHiglightButtons)
  1771. {
  1772. pDC->FillSolidRect(rc, bSelected && bPressed ?
  1773. GetXtremeColor(COLOR_3DFACE) : GetXtremeColor(COLOR_WINDOW));
  1775. }
  1776. else
  1777. {
  1778. pDC->FillSolidRect(rc, bSelected && bPressed ?
  1779. m_crBackPushed : bPressed || bSelected ? m_crBackHilite : GetXtremeColor(COLOR_WINDOW));
  1780. }
  1781. COLORREF clrBorder = bSelected || bPressed ? m_crBorderHilite : m_crBorderShadow;
  1783. pDC->Draw3dRect(rc, clrBorder, clrBorder);
  1784. }
  1786. if (bChecked)
  1787. {
  1788. CPoint pt = rc.CenterPoint();
  1789. CXTPPenDC pen(pDC->GetSafeHdc(), GetXtremeColor(!bEnabled || bChecked == 2 ? XPCOLOR_GRAYTEXT : COLOR_BTNTEXT));
  1791. if (CXTPDrawHelpers::IsContextRTL(pDC))  // Revert Check Box
  1792. {
  1793. for (int i = 0; i < 3; i++)
  1794. {
  1795. pDC->MoveTo(pt.x + 3, pt.y - 1 + i);
  1796. pDC->LineTo(pt.x + 1, pt.y + 1 + i);
  1797. pDC->LineTo(pt.x - 4, pt.y - 4 + i);
  1798. }
  1799. }
  1800. else
  1801. {
  1802. for (int i = 0; i < 3; i++)
  1803. {
  1804. pDC->MoveTo(pt.x - 3, pt.y - 1 + i);
  1805. pDC->LineTo(pt.x - 1, pt.y + 1 + i);
  1806. pDC->LineTo(pt.x + 4, pt.y - 4 + i);
  1807. }
  1808. }
  1809. }
  1810. }
  1812. AFX_INLINE COLORREF Mix(CDC* pDC, int x, int y, COLORREF clrBorder, COLORREF clrFace, double a)
  1813. {
  1814. COLORREF clr = clrFace;
  1816. if (a < 0)
  1817. a = -a;
  1818. else
  1819. {
  1820. clr = pDC->GetPixel(x, y);
  1821. }
  1822. int r = int(GetRValue(clrBorder) + a * double(GetRValue(clr) -  GetRValue(clrBorder)));
  1823. int g = int(GetGValue(clrBorder) + a * double(GetGValue(clr) -  GetGValue(clrBorder)));
  1824. int b = int(GetBValue(clrBorder) + a * double(GetBValue(clr) -  GetBValue(clrBorder)));
  1826. return RGB(r, g, b);
  1827. }
  1829. void CXTPButtonTheme::AlphaEllipse(CDC* pDC, CRect rc, COLORREF clrBorder, COLORREF clrFace)
  1830. {
  1831. ASSERT(rc.Width() == rc.Height());
  1832. double x0 = double(rc.left + rc.right - 1) / 2;
  1833. double y0 = double(rc.top + rc.bottom - 1) / 2;
  1834. double radius = double(rc.right - rc.left - 1) / 2 - 0.25;
  1836. for (int x = rc.left; x < rc.right; x++)
  1837. for (int y = rc.top; y < rc.bottom; y++)
  1838. {
  1839. double distance = sqrt(pow(x0 - x, 2) + pow(y0 - y, 2));
  1841. if (distance >= radius - 1 && distance <= radius + 1)
  1842. {
  1843. pDC->SetPixel(x, y, Mix(pDC, x, y, clrBorder, clrFace, distance - radius));
  1844. }
  1845. else if (distance < radius - 1)
  1846. {
  1847. pDC->SetPixel(x, y, clrFace);
  1848. }
  1849. }
  1850. }
  1853. void CXTPButtonUltraFlatTheme::DrawRadioButtonMark(CDC* pDC, CXTPButton* pButton)
  1854. {
  1855. if (IsVisualThemeUsed(pButton))
  1856. {
  1857. CXTPButtonTheme::DrawRadioButtonMark(pDC, pButton);
  1858. return;
  1859. }
  1861. BOOL bPressed = pButton->IsPushed();
  1862. BOOL bSelected = pButton->IsHighlighted();
  1863. BOOL bEnabled = pButton->IsWindowEnabled();
  1864. BOOL bChecked = pButton->GetChecked();
  1865. CXTPClientRect rCXTPButton(pButton);
  1867. CRect rc;
  1868. CalcRect(pDC, pButton, &rc, CBR_RADIOBOX);
  1870. if (!bEnabled)
  1871. {
  1872. AlphaEllipse(pDC, rc, GetXtremeColor(XPCOLOR_GRAYTEXT), GetXtremeColor(XPCOLOR_3DFACE));
  1873. }
  1874. else
  1875. {
  1876. if (!m_bHiglightButtons)
  1877. {
  1878. AlphaEllipse(pDC, rc, m_crBorderShadow, bSelected && bPressed ? GetXtremeColor(COLOR_3DFACE) :
  1879. GetXtremeColor(COLOR_WINDOW));
  1880. }
  1881. else
  1882. {
  1883. AlphaEllipse(pDC, rc, bSelected || bPressed ? m_crBorderHilite : m_crBorderShadow,
  1884. bSelected && bPressed ? m_crBackPushed :
  1885. bPressed || bSelected ? m_crBackHilite : GetXtremeColor(COLOR_WINDOW));
  1886. }
  1887. }
  1889. if (bChecked)
  1890. {
  1891. COLORREF clrFace = GetXtremeColor(!bEnabled || bChecked == 2 ? XPCOLOR_GRAYTEXT : COLOR_BTNTEXT);
  1892. AlphaEllipse(pDC, CRect(rc.left + 4, rc.top + 4, rc.left + 9, rc.top + 9), clrFace, clrFace);
  1893. }
  1895. }
  1897. //////////////////////////////////////////////////////////////////////////
  1898. //
  1900. CXTPButtonOffice2000Theme::CXTPButtonOffice2000Theme()
  1901. {
  1902. m_nBorderWidth = 2;
  1904. m_bHiglightButtons = FALSE;
  1905. }
  1907. void CXTPButtonOffice2000Theme::DrawButtonBackground(CDC* pDC, CXTPButton* pButton)
  1908. {
  1909. BOOL bPressed = pButton->IsPushed();
  1910. BOOL bHot = pButton->IsHighlighted();
  1911. BOOL bChecked = pButton->GetChecked();
  1912. CXTPClientRect rc(pButton);
  1914. if (pButton->GetFlatStyle() && !bHot && !bPressed && !bChecked)
  1915. return;
  1917. if (pButton->GetUseVisualStyle() && m_themeButton.IsAppThemed())
  1918. {
  1919. DrawButtonVisualStyleBackground(pDC, pButton);
  1920. return;
  1921. }
  1923. pDC->FillSolidRect(rc, pButton->GetButtonBackColor());
  1925. BOOL bSelected = bPressed || bChecked;
  1927. pDC->Draw3dRect(rc,
  1928. bSelected ? m_crBorderShadow : m_crBorder3DHilite,
  1929. bSelected ? m_crBorder3DHilite : m_crBorderShadow);
  1931. }
  1933. //////////////////////////////////////////////////////////////////////////
  1934. // CXTPButtonOffice2007Theme
  1936. CXTPButtonOffice2007Theme::CXTPButtonOffice2007Theme()
  1937. {
  1938. m_nBorderWidth = 2;
  1939. m_bHiglightButtons = TRUE;
  1940. }
  1943. void CXTPButtonOffice2007Theme::RefreshMetrics(CXTPButton* pButton)
  1944. {
  1945. CXTPButtonUltraFlatTheme::RefreshMetrics(pButton);
  1947. m_crBorderShadow.SetStandardValue(XTPOffice2007Images()->GetImageColor(_T("Controls"), _T("GroupBoxFrame")));
  1948. }
  1950. void CXTPButtonOffice2007Theme::DrawCheckBoxMark(CDC* pDC, CXTPButton* pButton)
  1951. {
  1952. if (IsVisualThemeUsed(pButton))
  1953. {
  1954. CXTPButtonTheme::DrawCheckBoxMark(pDC, pButton);
  1955. return;
  1956. }
  1958. CXTPOffice2007Image* pImage = XTPOffice2007Images()->LoadFile(_T("TOOLBARBUTTONCHECKBOX"));
  1960. ASSERT(pImage);
  1961. if (!pImage)
  1962. {
  1963. CXTPButtonTheme::DrawCheckBoxMark(pDC, pButton);
  1964. return;
  1965. }
  1967. BOOL bPressed = pButton->IsPushed();
  1968. BOOL bSelected = pButton->IsHighlighted();
  1969. BOOL bEnabled = pButton->IsWindowEnabled();
  1970. BOOL bChecked = pButton->GetChecked();
  1971. CXTPClientRect rCXTPButton(pButton);
  1974. CRect rc;
  1975. CalcRect(pDC, pButton, &rc, CBR_CHECKBOX);
  1978. int nState = 0;
  1979. if (!bEnabled)
  1980. nState = 3;
  1981. else if (bSelected && bPressed)
  1982. nState = 2;
  1983. else if (bSelected)
  1984. nState = 1;
  1986. if (bChecked == 1)
  1987. nState += 4;
  1989. if (bChecked == 2)
  1990. nState += 8;
  1992. pImage->DrawImage(pDC, rc, pImage->GetSource(nState, 12), CRect(0, 0, 0, 0));
  1993. }
  1995. void CXTPButtonOffice2007Theme::DrawRadioButtonMark(CDC* pDC, CXTPButton* pButton)
  1996. {
  1997. if (IsVisualThemeUsed(pButton))
  1998. {
  1999. CXTPButtonTheme::DrawRadioButtonMark(pDC, pButton);
  2000. return;
  2001. }
  2003. CXTPOffice2007Image* pImage = XTPOffice2007Images()->LoadFile(_T("TOOLBARBUTTONRADIOBUTTON"));
  2005. ASSERT(pImage);
  2006. if (!pImage)
  2007. {
  2008. CXTPButtonTheme::DrawRadioButtonMark(pDC, pButton);
  2009. return;
  2010. }
  2012. CRect rc;
  2013. CalcRect(pDC, pButton, &rc, CBR_RADIOBOX);
  2016. BOOL bPressed = pButton->IsPushed();
  2017. BOOL bSelected = pButton->IsHighlighted();
  2018. BOOL bEnabled = pButton->IsWindowEnabled();
  2019. BOOL bChecked = pButton->GetChecked();
  2021. int nState = 0;
  2022. if (!bEnabled)
  2023. nState = 3;
  2024. else if (bSelected && bPressed)
  2025. nState = 2;
  2026. else if (bSelected)
  2027. nState = 1;
  2029. if (bChecked)
  2030. nState += 4;
  2032. pImage->DrawImage(pDC, rc, pImage->GetSource(nState, 8), CRect(0, 0, 0, 0));
  2033. }
  2035. void CXTPButtonOffice2007Theme::DrawButtonBackground(CDC* pDC, CXTPButton* pButton)
  2036. {
  2037. BOOL bPressed = pButton->IsPushed();
  2038. BOOL bSelected = pButton->IsHighlighted();
  2039. BYTE bStyle = pButton->GetButtonStyle();
  2040. BOOL bDefault = bStyle == BS_DEFPUSHBUTTON;
  2041. BOOL bEnabled = pButton->IsWindowEnabled();
  2042. BOOL bChecked = pButton->GetChecked();
  2043. CXTPClientRect rc(pButton);
  2045. if (pButton->GetFlatStyle() && !bSelected && !bPressed && !bChecked)
  2046. return;
  2048. if (pButton->GetUseVisualStyle() && m_themeButton.IsAppThemed())
  2049. {
  2050. DrawButtonVisualStyleBackground(pDC, pButton);
  2051. return;
  2052. }
  2054. CXTPOffice2007Image* pImage = XTPOffice2007Images()->LoadFile(_T("PUSHBUTTON"));
  2056. ASSERT(pImage);
  2057. if (!pImage)
  2058. {
  2059. CXTPButtonTheme::DrawButtonBackground(pDC, pButton);
  2060. return;
  2061. }
  2063. int nState = bDefault ? 4 : 0;
  2065. if (!bEnabled)
  2066. {
  2067. nState = 3;
  2068. }
  2069. else if (bChecked && !bSelected && !bPressed) nState = 2;
  2070. else if (bChecked && bSelected && !bPressed) nState = 1;
  2071. else if ((bSelected && bPressed) || pButton->IsPushed()) nState = 2;
  2072. else if (bSelected || bPressed) nState = 1;
  2074. if (nState != -1)
  2075. {
  2076. pImage->DrawImage(pDC, rc, pImage->GetSource(nState, 5), CRect(3, 3, 3, 3), 0xFF00FF);
  2077. }
  2079. }
  2081. //////////////////////////////////////////////////////////////////////////
  2082. // CXTPButtonOfficeXPTheme
  2084. CXTPButtonOfficeXPTheme::CXTPButtonOfficeXPTheme()
  2085. {
  2086. m_nBorderWidth = 2;
  2087. m_bOffsetHiliteText = FALSE;
  2088. }
  2090. void CXTPButtonOfficeXPTheme::RefreshMetrics(CXTPButton* pButton)
  2091. {
  2092. CXTPButtonUltraFlatTheme::RefreshMetrics(pButton);
  2094. m_crBack.SetStandardValue(GetXtremeColor(XPCOLOR_TOOLBAR_FACE));
  2095. m_crBackPushed.SetStandardValue(GetXtremeColor(XPCOLOR_HIGHLIGHT_PUSHED));
  2096. m_crBackHilite.SetStandardValue(GetXtremeColor(XPCOLOR_HIGHLIGHT));
  2097. m_crBorderShadow.SetStandardValue(GetXtremeColor(COLOR_3DSHADOW));
  2098. m_crBorderHilite.SetStandardValue(GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER));
  2099. m_crText.SetStandardValue(GetXtremeColor(XPCOLOR_TOOLBAR_TEXT));
  2100. m_crTextHilite.SetStandardValue(GetXtremeColor(XPCOLOR_HIGHLIGHT_TEXT));
  2101. m_crTextPushed.SetStandardValue(GetXtremeColor(XPCOLOR_PUSHED_TEXT));
  2102. m_crBackChecked.SetStandardValue(GetXtremeColor(XPCOLOR_HIGHLIGHT_CHECKED));
  2103. }
  2105. void CXTPButtonOfficeXPTheme::DrawButtonBackground(CDC* pDC, CXTPButton* pButton)
  2106. {
  2107. BOOL bPressed = pButton->IsPushed();
  2108. BOOL bHot = pButton->IsHighlighted();
  2109. BOOL bChecked = pButton->GetChecked();
  2110. CXTPClientRect rc(pButton);
  2112. if (pButton->GetFlatStyle() && !bHot && !bPressed && !bChecked)
  2113. return;
  2115. if (pButton->GetUseVisualStyle() && m_themeButton.IsAppThemed())
  2116. {
  2117. DrawButtonVisualStyleBackground(pDC, pButton);
  2118. return;
  2119. }
  2121. if (bHot || bPressed || bChecked)
  2122. {
  2123. pDC->FillSolidRect(rc, bPressed ? m_crBackPushed :
  2124. bChecked ? (bHot ? m_crBackPushed : m_crBackChecked) : m_crBackHilite);
  2126. pDC->Draw3dRect(rc, m_crBorderHilite,
  2127. m_crBorderHilite);
  2128. }
  2129. else
  2130. {
  2131. pDC->FillSolidRect(rc, m_crBack);
  2133. pDC->Draw3dRect(rc, m_crBorderShadow, m_crBorderShadow);
  2134. }
  2135. }
  2139. //////////////////////////////////////////////////////////////////////////
  2140. //
  2142. //////////////////////////////////////////////////////////////////////////
  2143. // CXTPButtonOffice2003Theme
  2145. CXTPButtonOffice2003Theme::CXTPButtonOffice2003Theme()
  2146. {
  2147. m_bLunaTheme = FALSE;
  2148. }
  2151. void CXTPButtonOffice2003Theme::RefreshMetrics(CXTPButton* pButton)
  2152. {
  2153. CXTPButtonOfficeXPTheme::RefreshMetrics(pButton);
  2155. XTPCurrentSystemTheme systemTheme = XTPColorManager()->GetCurrentSystemTheme();
  2157. if (systemTheme != xtpSystemThemeUnknown)
  2158. {
  2159. m_crBackHilite.SetStandardValue(RGB(255, 238, 194));
  2160. m_crBackPushed.SetStandardValue(RGB(254, 128, 62));
  2161. m_crBackChecked.SetStandardValue(RGB(255, 192, 111));
  2162. m_crText.SetStandardValue(0);
  2163. m_crTextHilite.SetStandardValue(0);
  2164. m_crTextPushed.SetStandardValue(0);
  2165. }
  2167. switch (systemTheme)
  2168. {
  2169. case xtpSystemThemeBlue:
  2170. m_crBack.SetStandardValue(RGB(169, 199, 240));
  2171. m_crBorderShadow.SetStandardValue(RGB(127, 157, 185));
  2172. m_crBorderHilite.SetStandardValue(RGB(0, 0, 128));
  2173. break;
  2175. case xtpSystemThemeOlive:
  2176. m_crBack.SetStandardValue(RGB(197, 212, 159));
  2177. m_crBorderShadow.SetStandardValue(RGB(164, 185, 127));
  2178. m_crBorderHilite.SetStandardValue(RGB(63, 93, 56));
  2179. break;
  2181. case xtpSystemThemeSilver:
  2182. m_crBack.SetStandardValue(RGB(192, 192, 211));
  2183. m_crBorderShadow.SetStandardValue(RGB(165, 172, 178));
  2184. m_crBorderHilite.SetStandardValue(RGB(75, 75, 11));
  2185. break;
  2186. }
  2188. m_bLunaTheme = systemTheme != xtpSystemThemeUnknown;
  2189. }
  2191. void CXTPButtonOffice2003Theme::DrawButtonBackground(CDC* pDC, CXTPButton* pButton)
  2192. {
  2193. if (!m_bLunaTheme)
  2194. {
  2195. CXTPButtonOfficeXPTheme::DrawButtonBackground(pDC, pButton);
  2196. return;
  2197. }
  2198. BOOL bPressed = pButton->IsPushed();
  2199. BOOL bHot = pButton->IsHighlighted();
  2200. BOOL bChecked = pButton->GetChecked();
  2201. CXTPClientRect rc(pButton);
  2203. if (pButton->GetFlatStyle() && !bHot && !bPressed && !bChecked)
  2204. return;
  2206. if (pButton->GetUseVisualStyle() && m_themeButton.IsAppThemed())
  2207. {
  2208. DrawButtonVisualStyleBackground(pDC, pButton);
  2209. return;
  2210. }
  2212. if (bHot || bPressed || bChecked)
  2213. {
  2214. if (bPressed)
  2215. {
  2216. XTPDrawHelpers()->GradientFill(pDC, &rc,
  2217. XTPColorManager()->grcLunaPushed, FALSE);
  2218. }
  2219. else if (bHot)
  2220. {
  2221. XTPDrawHelpers()->GradientFill(pDC, &rc,
  2222. XTPColorManager()->grcLunaSelected, FALSE);
  2223. }
  2224. else if (bChecked)
  2225. {
  2226. XTPDrawHelpers()->GradientFill(pDC, &rc,
  2227. XTPColorManager()->grcLunaChecked, FALSE);
  2228. }
  2230. pDC->Draw3dRect(rc, m_crBorderHilite,
  2231. m_crBorderHilite);
  2233. }
  2234. else
  2235. {
  2236. pDC->FillSolidRect(rc, m_crBack);
  2237. pDC->Draw3dRect(rc, m_crBorderShadow, m_crBorderShadow);
  2238. }
  2239. }