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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupButton.cpp：源码内容
  1. // XTPMarkupButton.cpp: implementation of the CXTPMarkupButton class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO 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"
  23. #include "Common/XTPWinThemeWrapper.h"
  24. #include "Common/XTPDrawHelpers.h"
  26. #include "XTPMarkupButton.h"
  27. #include "XTPMarkupDrawingContext.h"
  29. #ifdef _DEBUG
  30. #undef THIS_FILE
  31. static char THIS_FILE[]=__FILE__;
  32. #define new DEBUG_NEW
  33. #endif
  35. //////////////////////////////////////////////////////////////////////////
  36. // CXTPMarkupButtonBase
  38. CXTPMarkupRoutedEvent* CXTPMarkupButtonBase::m_pClickEvent = NULL;
  39. CXTPMarkupDependencyProperty* CXTPMarkupButtonBase::m_pIsPressedProperty = NULL;
  41. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupButtonBase, CXTPMarkupContentControl)
  43. void CXTPMarkupButtonBase::RegisterMarkupClass()
  44. {
  45. m_pClickEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"Click", CXTPMarkupRoutedEvent::routingBubble, MARKUP_TYPE(CXTPMarkupButtonBase));
  46. m_pIsPressedProperty = CXTPMarkupDependencyProperty::Register(L"IsPressed", MARKUP_TYPE(CXTPMarkupBool), MARKUP_TYPE(CXTPMarkupButtonBase),
  47. new CXTPMarkupPropertyMetadata(CXTPMarkupBool::CreateFalseValue(), CXTPMarkupPropertyMetadata::flagAffectsArrange));
  48. }
  50. CXTPMarkupButtonBase::CXTPMarkupButtonBase()
  51. {
  52. m_bPushed = FALSE;
  53. m_bMouseOver = FALSE;
  55. SetValue(m_pFocusableProperty, CXTPMarkupBool::CreateTrueValue());
  56. }
  58. void CXTPMarkupButtonBase::OnMouseLeave(CXTPMarkupMouseEventArgs* e)
  59. {
  60. m_bMouseOver = FALSE;
  62. if (m_bPushed)
  63. {
  64. SetValue(m_pIsPressedProperty, NULL);
  65. }
  66. else
  67. {
  68. CXTPMarkupContentControl::OnMouseLeave(e);
  69. InvalidateVisual();
  70. }
  71. }
  73. void CXTPMarkupButtonBase::OnMouseEnter(CXTPMarkupMouseEventArgs* e)
  74. {
  75. m_bMouseOver = TRUE;
  77. if (m_bPushed)
  78. {
  79. SetValue(m_pIsPressedProperty, CXTPMarkupBool::CreateTrueValue());
  80. }
  81. else
  82. {
  83. CXTPMarkupContentControl::OnMouseEnter(e);
  84. InvalidateVisual();
  85. }
  86. }
  88. void CXTPMarkupButtonBase::OnLostMouseCapture(CXTPMarkupMouseEventArgs* /*e*/)
  89. {
  90. SetPressed(FALSE);
  91. }
  93. void CXTPMarkupButtonBase::SetPressed(BOOL bPressed)
  94. {
  95. if (!bPressed && m_bPushed)
  96. {
  97. m_bPushed = FALSE;
  98. SetValue(m_pIsPressedProperty, NULL);
  100. if (!m_bMouseOver && IsMouseOver())
  101. {
  102. SetValue(m_pIsMouseOverProperty, NULL);
  103. InvalidateVisual();
  104. }
  105. }
  106. else if (bPressed && !m_bPushed)
  107. {
  108. m_bPushed = TRUE;
  109. SetValue(m_pIsPressedProperty, CXTPMarkupBool::CreateTrueValue());
  110. }
  111. }
  113. void CXTPMarkupButtonBase::OnMouseLeftButtonUp(CXTPMarkupMouseButtonEventArgs* e)
  114. {
  115. if (m_bPushed)
  116. {
  117. ReleaseMouseCapture();
  119. SetPressed(FALSE);
  121. if (m_bMouseOver)
  122. {
  123. OnClick();
  124. }
  126. e->SetHandled();
  127. }
  128. }
  130. void CXTPMarkupButtonBase::OnMouseLeftButtonDown(CXTPMarkupMouseButtonEventArgs* e)
  131. {
  132. Focus();
  134. SetPressed(TRUE);
  136. e->SetHandled();
  138. CaptureMouse();
  139. }
  141. void CXTPMarkupButtonBase::OnClick()
  142. {
  143. CXTPMarkupRoutedEventArgs e(m_pClickEvent, this);
  144. RaiseEvent(&e);
  145. }
  148. //////////////////////////////////////////////////////////////////////////
  149. // CXTPMarkupButton
  151. CXTPMarkupButton::CXTPMarkupButton()
  152. {
  153. }
  155. CXTPMarkupButton::~CXTPMarkupButton()
  156. {
  157. }
  159. IMPLEMENT_MARKUPCLASS(L"Button", CXTPMarkupButton, CXTPMarkupButtonBase)
  161. void CXTPMarkupButton::RegisterMarkupClass()
  162. {
  163. }
  165. CSize CXTPMarkupButton::ArrangeOverride(CSize szFinalSize)
  166. {
  167. CXTPMarkupUIElement* pContent = GetContent();
  168. if (pContent != NULL)
  169. {
  170. CRect rt(0, 0, szFinalSize.cx, szFinalSize.cy);
  172. if (IsPressed() && (!m_themeButton.IsAppThemed() || GetValue(m_pBackgroundProperty) != NULL))
  173. {
  174. rt.OffsetRect(1, 1);
  175. }
  177. CRect finalRect = CXTPMarkupThickness::HelperDeflateRect(rt, GetPadding());
  178. finalRect.DeflateRect(4, 4);
  179. pContent->Arrange(finalRect);
  180. }
  181. return szFinalSize;
  182. }
  184. CSize CXTPMarkupButton::MeasureOverride(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize)
  185. {
  186. m_themeButton.OpenTheme(0, L"BUTTON");
  188. CSize size3 = GetPadding()->Size();
  189. size3.cx += 8;
  190. size3.cy += 8;
  192. CXTPMarkupUIElement* pContent = GetContent();
  193. if (pContent != NULL)
  194. {
  195. CSize availableSize(max(0, szAvailableSize.cx - size3.cx), max(0, szAvailableSize.cy - size3.cy));
  196. pContent->Measure(pDC, availableSize);
  198. CSize desiredSize = pContent->GetDesiredSize();
  200. return CSize(desiredSize.cx + size3.cx, desiredSize.cy + size3.cy);
  201. }
  203. return size3;
  204. }
  207. void CXTPMarkupButton::OnRender(CXTPMarkupDrawingContext* pDC)
  208. {
  209. BOOL bPressed = IsPressed();
  210. BOOL bHot = IsMouseOver();
  211. BOOL bDefault = FALSE;
  212. BOOL bEnabled = TRUE;
  213. BOOL bChecked = FALSE;
  214. CRect rc(0, 0, GetRenderSize().cx, GetRenderSize().cy);
  216. CXTPMarkupBrush* pBackground = MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pBackgroundProperty));
  218. if (pBackground == NULL && m_themeButton.IsAppThemed())
  219. {
  220. int nState = !bEnabled? PBS_DISABLED: bPressed? PBS_PRESSED: bHot? PBS_HOT: bChecked ? PBS_PRESSED : bDefault? PBS_DEFAULTED: PBS_NORMAL;
  221. m_themeButton.DrawThemeBackground(pDC->GetSafeHdc(), BP_PUSHBUTTON, nState, rc, NULL);
  222. }
  223. else
  224. {
  225. COLORREF clrLight, clrDark, clrDarkDark, clrBackground;
  227. if (pBackground)
  228. {
  229. clrBackground = pBackground->GetHintColor();
  230. DWORD dwHSLBackground = CXTPDrawHelpers::RGBtoHSL(clrBackground);
  232. DWORD dwL = GetBValue(dwHSLBackground);
  234. DWORD dwLight = (dwL + 240) / 2;
  236. clrLight = CXTPDrawHelpers::HSLtoRGB(RGB(GetRValue(dwHSLBackground), GetGValue(dwHSLBackground), dwLight));
  238. DWORD dwDark = MulDiv(dwL, 2, 3);
  240. clrDark = CXTPDrawHelpers::HSLtoRGB(RGB(GetRValue(dwHSLBackground), GetGValue(dwHSLBackground), dwDark));
  241. clrDarkDark = RGB(GetRValue(clrDark) / 2, GetGValue(clrDark) / 2, GetBValue(clrDark) / 2);
  243. pDC->DrawRectangle(pBackground, rc);
  244. }
  245. else
  246. {
  247. clrBackground = GetSysColor(COLOR_3DFACE);
  248. clrLight = GetSysColor(COLOR_WINDOW);
  249. clrDark = GetSysColor(COLOR_BTNSHADOW);
  250. clrDarkDark = GetSysColor(COLOR_3DDKSHADOW);
  252. CXTPMarkupSolidColorBrush brushBackground(clrBackground);
  253. pDC->DrawRectangle(&brushBackground, rc);
  254. }
  256. CXTPMarkupSolidColorBrush brushDark(clrDark);
  258. if (bPressed)
  259. {
  260. CXTPMarkupSolidColorBrush brushFrame(GetSysColor(COLOR_WINDOWFRAME));
  262. pDC->DrawFrame(&brushFrame, rc);
  263. rc.DeflateRect(1, 1);
  264. pDC->DrawFrame(&brushDark, rc);
  265. }
  266. else
  267. {
  268. CXTPMarkupSolidColorBrush brushLight(clrLight);
  269. CXTPMarkupSolidColorBrush brushDarkDark(clrDarkDark);
  271. pDC->DrawRectangle(&brushLight, CRect(rc.left, rc.top, rc.right, 1));
  272. pDC->DrawRectangle(&brushLight, CRect(rc.left, rc.top, rc.left + 1, rc.bottom));
  274. pDC->DrawRectangle(&brushDark, CRect(rc.left + 1, rc.bottom - 2, rc.right - 1, rc.bottom - 1));
  275. pDC->DrawRectangle(&brushDark, CRect(rc.right - 2, rc.top + 1, rc.right - 1, rc.bottom - 1));
  277. pDC->DrawRectangle(&brushDarkDark, CRect(rc.left, rc.bottom - 1, rc.right - 1, rc.bottom));
  278. pDC->DrawRectangle(&brushDarkDark, CRect(rc.right - 1, rc.top, rc.right, rc.bottom));
  279. }
  280. }
  281. }
  283. void CXTPMarkupButton::OnRenderFocusVisual(CXTPMarkupDrawingContext* drawingContext)
  284. {
  285. CRect rc(0, 0, GetRenderSize().cx, GetRenderSize().cy);
  287. rc.DeflateRect(3, 3);
  289. SetTextColor(drawingContext->GetSafeHdc(), 0xFFFFFF);
  290. SetBkColor(drawingContext->GetSafeHdc(), 0);
  291. DrawFocusRect(drawingContext->GetSafeHdc(), rc);
  292. }
  294. //////////////////////////////////////////////////////////////////////////
  295. // CXTPMarkupToggleButton
  297. CXTPMarkupDependencyProperty* CXTPMarkupToggleButton::m_pIsThreeStateProperty = NULL;
  298. CXTPMarkupDependencyProperty* CXTPMarkupToggleButton::m_pIsCheckedProperty = NULL;
  299. CXTPMarkupRoutedEvent* CXTPMarkupToggleButton::m_pCheckedEvent = NULL;
  300. CXTPMarkupRoutedEvent* CXTPMarkupToggleButton::m_pUncheckedEvent = NULL;
  301. CXTPMarkupRoutedEvent* CXTPMarkupToggleButton::m_pIndeterminateEvent = NULL;
  304. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupToggleButton, CXTPMarkupButtonBase)
  306. void CXTPMarkupToggleButton::RegisterMarkupClass()
  307. {
  308. m_pCheckedEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"Checked", CXTPMarkupRoutedEvent::routingBubble, MARKUP_TYPE(CXTPMarkupToggleButton));
  309. m_pUncheckedEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"Unchecked", CXTPMarkupRoutedEvent::routingBubble, MARKUP_TYPE(CXTPMarkupToggleButton));
  310. m_pIndeterminateEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"Indeterminate", CXTPMarkupRoutedEvent::routingBubble, MARKUP_TYPE(CXTPMarkupToggleButton));
  312. m_pIsCheckedProperty = CXTPMarkupDependencyProperty::Register(L"IsChecked", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupToggleButton),
  313. new CXTPMarkupPropertyMetadata(CXTPMarkupEnum::CreateValue(0), &CXTPMarkupToggleButton::ConvertIsChecked, &CXTPMarkupToggleButton::OnIsCheckedChanged, CXTPMarkupPropertyMetadata::flagAffectsRender));
  315. m_pIsThreeStateProperty = CXTPMarkupDependencyProperty::Register(L"IsThreeState", MARKUP_TYPE(CXTPMarkupBool), MARKUP_TYPE(CXTPMarkupToggleButton),
  316. new CXTPMarkupPropertyMetadata(CXTPMarkupBool::CreateFalseValue(), CXTPMarkupPropertyMetadata::flagAffectsRender));
  317. }
  319. CXTPMarkupObject* CXTPMarkupToggleButton::ConvertIsChecked(CXTPMarkupContext* /*pContext*/, CXTPMarkupObject* pObject)
  320. {
  321. if (IsStringObject(pObject))
  322. {
  323. if (_wcsicmp(*((CXTPMarkupString*)pObject), L"True") == 0)
  324. {
  325. return CXTPMarkupEnum::CreateValue(BST_CHECKED);
  326. }
  328. if (_wcsicmp(*((CXTPMarkupString*)pObject), L"False") == 0)
  329. {
  330. return CXTPMarkupEnum::CreateValue(BST_UNCHECKED);
  331. }
  333. if (_wcsicmp(*((CXTPMarkupString*)pObject), L"") == 0)
  334. {
  335. return CXTPMarkupEnum::CreateValue(BST_INDETERMINATE);
  336. }
  337. }
  338. return NULL;
  339. }
  341. void CXTPMarkupToggleButton::OnClick()
  342. {
  343. OnToggle();
  344. CXTPMarkupButtonBase::OnClick();
  345. }
  347. void CXTPMarkupToggleButton::OnToggle()
  348. {
  349. if (GetChecked() == BST_CHECKED)
  350. {
  351. SetChecked(IsThreeState() ? BST_INDETERMINATE : BST_UNCHECKED);
  352. }
  353. else
  354. {
  355. SetChecked(GetChecked() == BST_INDETERMINATE ? BST_UNCHECKED : BST_CHECKED);
  356. }
  357. }
  359. void CXTPMarkupToggleButton::OnChecked(CXTPMarkupRoutedEventArgs* e)
  360. {
  361. RaiseEvent(e);
  362. }
  364. void CXTPMarkupToggleButton::OnUnchecked(CXTPMarkupRoutedEventArgs* e)
  365. {
  366. RaiseEvent(e);
  367. }
  369. void CXTPMarkupToggleButton::OnIndeterminate(CXTPMarkupRoutedEventArgs* e)
  370. {
  371. RaiseEvent(e);
  372. }
  374. void CXTPMarkupToggleButton::OnIsCheckedChanged(CXTPMarkupObject* d, CXTPMarkupPropertyChangedEventArgs* e)
  375. {
  376. CXTPMarkupToggleButton* pButton = MARKUP_DYNAMICCAST(CXTPMarkupToggleButton, d);
  377. if (!pButton)
  378. return;
  380. CXTPMarkupEnum* pValue = MARKUP_STATICCAST(CXTPMarkupEnum, e->m_pNewValue);
  382. int bValue = pValue != NULL ? (int)*pValue : FALSE;
  384. if (bValue == BST_CHECKED)
  385. {
  386. CXTPMarkupRoutedEventArgs args(CXTPMarkupToggleButton::m_pCheckedEvent, pButton);
  387. pButton->OnChecked(&args);
  388. }
  389. else if (bValue == BST_UNCHECKED)
  390. {
  391. CXTPMarkupRoutedEventArgs args(CXTPMarkupToggleButton::m_pUncheckedEvent, pButton);
  392. pButton->OnUnchecked(&args);
  393. }
  394. else
  395. {
  396. CXTPMarkupRoutedEventArgs args(CXTPMarkupToggleButton::m_pIndeterminateEvent, pButton);
  397. pButton->OnIndeterminate(&args);
  398. }
  399. }
  402. //////////////////////////////////////////////////////////////////////////
  403. // CXTPMarkupCheckBox
  405. IMPLEMENT_MARKUPCLASS(L"CheckBox", CXTPMarkupCheckBox, CXTPMarkupToggleButton)
  407. void CXTPMarkupCheckBox::RegisterMarkupClass()
  408. {
  410. }
  413. CXTPMarkupCheckBox::CXTPMarkupCheckBox()
  414. {
  415. }
  417. CXTPMarkupCheckBox::~CXTPMarkupCheckBox()
  418. {
  419. }
  421. CSize CXTPMarkupCheckBox::ArrangeOverride(CSize szFinalSize)
  422. {
  423. CXTPMarkupUIElement* pContent = GetContent();
  424. if (pContent != NULL)
  425. {
  426. CRect rt(0, 0, szFinalSize.cx, szFinalSize.cy);
  428. CRect finalRect = CXTPMarkupThickness::HelperDeflateRect(rt, GetPadding());
  429. finalRect.DeflateRect(13 + 3, 0, 0, 0);
  430. pContent->Arrange(finalRect);
  431. }
  432. return szFinalSize;
  433. }
  435. CSize CXTPMarkupCheckBox::MeasureOverride(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize)
  436. {
  437. m_themeButton.OpenTheme(0, L"BUTTON");
  439. CSize size3 = GetPadding()->Size();
  440. size3.cx += 13 + 3;
  442. CXTPMarkupUIElement* pContent = GetContent();
  443. if (pContent != NULL)
  444. {
  445. CSize availableSize(max(0, szAvailableSize.cx - size3.cx), max(0, szAvailableSize.cy - size3.cy));
  446. pContent->Measure(pDC, availableSize);
  448. CSize desiredSize = pContent->GetDesiredSize();
  450. return CSize(desiredSize.cx + size3.cx, max(13, desiredSize.cy + size3.cy));
  451. }
  453. return size3;
  454. }
  456. void CXTPMarkupCheckBox::OnRender(CXTPMarkupDrawingContext* pDC)
  457. {
  458. BOOL bPressed = IsPressed();
  459. BOOL bHot = IsMouseOver();
  460. BOOL bEnabled = TRUE;
  461. BOOL bChecked = GetChecked();
  463. CRect rc(0, GetRenderSize().cy / 2 - 6, 13, GetRenderSize().cy / 2 + 7);
  465. if (m_themeButton.IsAppThemed())
  466. {
  467. int nState = !bEnabled? CBS_UNCHECKEDDISABLED: bPressed? CBS_UNCHECKEDPRESSED: bHot?
  468. CBS_UNCHECKEDHOT: CBS_UNCHECKEDNORMAL;
  469. if (bChecked == BST_CHECKED)
  470. nState += 4;
  471. if (bChecked == BST_INDETERMINATE)
  472. nState += 8;
  474. m_themeButton.DrawThemeBackground(pDC->GetSafeHdc(), BP_CHECKBOX, nState, rc, NULL);
  475. }
  476. else
  477. {
  478. DrawFrameControl(pDC->GetSafeHdc(), rc, DFC_BUTTON, DFCS_BUTTONCHECK | (bPressed ? DFCS_PUSHED : 0)
  479. | (bChecked == BST_CHECKED ? DFCS_CHECKED : 0) | (bChecked == BST_INDETERMINATE ? DFCS_BUTTON3STATE | DFCS_CHECKED : 0));
  480. }
  481. }
  483. void CXTPMarkupCheckBox::OnRenderFocusVisual(CXTPMarkupDrawingContext* drawingContext)
  484. {
  485. CRect rc(0, 0, GetRenderSize().cx, GetRenderSize().cy);
  487. CXTPMarkupVisual* pContent = GetContent();
  488. if (!pContent)
  489. return;
  491. rc.left += 13 + 2;
  493. SetTextColor(drawingContext->GetSafeHdc(), 0xFFFFFF);
  494. SetBkColor(drawingContext->GetSafeHdc(), 0);
  495. DrawFocusRect(drawingContext->GetSafeHdc(), rc);
  496. }
  499. //////////////////////////////////////////////////////////////////////////
  500. // CXTPMarkupRadioButton
  502. IMPLEMENT_MARKUPCLASS(L"RadioButton", CXTPMarkupRadioButton, CXTPMarkupToggleButton)
  504. void CXTPMarkupRadioButton::RegisterMarkupClass()
  505. {
  507. }
  509. CXTPMarkupRadioButton::CXTPMarkupRadioButton()
  510. {
  511. }
  513. CXTPMarkupRadioButton::~CXTPMarkupRadioButton()
  514. {
  515. }
  517. CSize CXTPMarkupRadioButton::ArrangeOverride(CSize szFinalSize)
  518. {
  519. CXTPMarkupUIElement* pContent = GetContent();
  520. if (pContent != NULL)
  521. {
  522. CRect rt(0, 0, szFinalSize.cx, szFinalSize.cy);
  524. CRect finalRect = CXTPMarkupThickness::HelperDeflateRect(rt, GetPadding());
  525. finalRect.DeflateRect(13 + 3, 0, 0, 0);
  526. pContent->Arrange(finalRect);
  527. }
  528. return szFinalSize;
  529. }
  531. CSize CXTPMarkupRadioButton::MeasureOverride(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize)
  532. {
  533. m_themeButton.OpenTheme(0, L"BUTTON");
  535. CSize size3 = GetPadding()->Size();
  536. size3.cx += 13 + 3;
  538. CXTPMarkupUIElement* pContent = GetContent();
  539. if (pContent != NULL)
  540. {
  541. CSize availableSize(max(0, szAvailableSize.cx - size3.cx), max(0, szAvailableSize.cy - size3.cy));
  542. pContent->Measure(pDC, availableSize);
  544. CSize desiredSize = pContent->GetDesiredSize();
  546. return CSize(desiredSize.cx + size3.cx, max(13, desiredSize.cy + size3.cy));
  547. }
  549. return CSize(size3.cx, max(13, size3.cy));
  550. }
  552. void CXTPMarkupRadioButton::OnRender(CXTPMarkupDrawingContext* pDC)
  553. {
  554. BOOL bPressed = IsPressed();
  555. BOOL bHot = IsMouseOver();
  556. BOOL bEnabled = TRUE;
  557. BOOL bChecked = GetChecked();
  559. CRect rc(0, GetRenderSize().cy / 2 - 6, 13, GetRenderSize().cy / 2 + 7);
  561. if (m_themeButton.IsAppThemed())
  562. {
  563. int nState = !bEnabled? RBS_UNCHECKEDDISABLED: bPressed? RBS_UNCHECKEDPRESSED: bHot?
  564. RBS_UNCHECKEDHOT: RBS_UNCHECKEDNORMAL;
  566. if (bChecked)
  567. nState += 4;
  569. m_themeButton.DrawThemeBackground(pDC->GetSafeHdc(), BP_RADIOBUTTON, nState, rc, NULL);
  570. }
  571. else
  572. {
  573. DrawFrameControl(pDC->GetSafeHdc(), rc, DFC_BUTTON, DFCS_BUTTONRADIO | (bPressed ? DFCS_PUSHED : 0)
  574. | (bChecked ? DFCS_CHECKED : 0));
  575. }
  576. }
  578. void CXTPMarkupRadioButton::OnRenderFocusVisual(CXTPMarkupDrawingContext* drawingContext)
  579. {
  580. CRect rc(0, 0, GetRenderSize().cx, GetRenderSize().cy);
  582. CXTPMarkupVisual* pContent = GetContent();
  583. if (!pContent)
  584. return;
  586. rc.left += 13 + 2;
  588. SetTextColor(drawingContext->GetSafeHdc(), 0xFFFFFF);
  589. SetBkColor(drawingContext->GetSafeHdc(), 0);
  590. DrawFocusRect(drawingContext->GetSafeHdc(), rc);
  591. }
  593. void CXTPMarkupRadioButton::OnToggle()
  594. {
  595. SetChecked(TRUE);
  596. }
  598. void CXTPMarkupRadioButton::OnChecked(CXTPMarkupRoutedEventArgs* e)
  599. {
  600. UpdateRadioButtonGroup();
  601. CXTPMarkupToggleButton::OnChecked(e);
  602. }
  605. void CXTPMarkupRadioButton::UpdateRadioButtonGroup()
  606. {
  607. CXTPMarkupVisual* pParent = GetVisualParent();
  608. if (!pParent)
  609. return;
  611. int nCount = pParent->GetVisualChildrenCount();
  613. for (int i = 0; i < nCount; i++)
  614. {
  615. CXTPMarkupRadioButton* pButton = MARKUP_DYNAMICCAST(CXTPMarkupRadioButton, pParent->GetVisualChild(i));
  617. if (pButton && pButton != this && pButton->GetChecked())
  618. {
  619. pButton->SetChecked(FALSE);
  620. }
  621. }
  623. }