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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupInline.cpp：源码内容
  1. // XTPMarkupInline.cpp: implementation of the CXTPMarkupInline 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/XTPSystemHelpers.h"
  24. #include "Common/resource.h"
  26. #include "XTPMarkupResourceDictionary.h"
  27. #include "XTPMarkupInline.h"
  28. #include "XTPMarkupDrawingContext.h"
  29. #include "XTPMarkupBuilder.h"
  30. #include "XTPMarkupTextBlock.h"
  31. #include "XTPMarkupContext.h"
  32. #include "XTPMarkupButton.h"
  34. #ifdef _DEBUG
  35. #undef THIS_FILE
  36. static char THIS_FILE[]=__FILE__;
  37. #define new DEBUG_NEW
  38. #endif
  41. //////////////////////////////////////////////////////////////////////////
  42. // CXTPMarkupFrameworkContentElement
  44. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkContentElement::m_pTagProperty = NULL;
  46. IMPLEMENT_MARKUPCLASS(L"FrameworkContentElement", CXTPMarkupFrameworkContentElement, CXTPMarkupInputElement);
  48. void CXTPMarkupFrameworkContentElement::RegisterMarkupClass()
  49. {
  50. CXTPMarkupFrameworkElement::RegisterType();
  52. m_pTagProperty = CXTPMarkupFrameworkElement::m_pTagProperty->AddOwner(MARKUP_TYPE(CXTPMarkupFrameworkContentElement));
  53. }
  55. CXTPMarkupFrameworkContentElement::CXTPMarkupFrameworkContentElement()
  56. {
  57. }
  59. void CXTPMarkupFrameworkContentElement::OnPropertyChanged(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue)
  60. {
  61. CXTPMarkupInputElement::OnPropertyChanged(pProperty, pOldValue, pNewValue);
  63. FireTriggers(pProperty, pNewValue);
  65. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagAffectsMeasure)
  66. {
  67. CXTPMarkupFrameworkElement* pParent = GetParent();
  68. if (pParent) pParent->InvalidateMeasure();
  69. }
  71. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagAffectsArrange)
  72. {
  73. CXTPMarkupFrameworkElement* pParent = GetParent();
  74. if (pParent) pParent->InvalidateArrange();
  75. }
  77. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagAffectsRender)
  78. {
  79. CXTPMarkupFrameworkElement* pParent = GetParent();
  80. if (pParent) pParent->InvalidateVisual();
  81. }
  82. }
  84. CXTPMarkupFrameworkElement* CXTPMarkupFrameworkContentElement::GetParent() const
  85. {
  86. CXTPMarkupObject* pParent = m_pLogicalParent;
  87. while (pParent)
  88. {
  89. if (pParent->IsKindOf(MARKUP_TYPE(CXTPMarkupFrameworkElement)))
  90. return (CXTPMarkupFrameworkElement*)pParent;
  92. pParent = pParent->GetLogicalParent();
  93. }
  95. return NULL;
  96. }
  99. //////////////////////////////////////////////////////////////////////////
  100. //
  101. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pBackgroundProperty = NULL;
  102. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pForegroundProperty = NULL;
  103. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pFontSizeProperty = NULL;
  104. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pFontWeightProperty = NULL;
  105. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pFontFamilyProperty = NULL;
  106. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pFontStyleProperty = NULL;
  107. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pTextDecorationsProperty = NULL;
  108. CXTPMarkupDependencyProperty* CXTPMarkupTextElement::m_pFontQualityProperty = NULL;
  110. //////////////////////////////////////////////////////////////////////////
  111. // CXTPMarkupTextElement
  113. IMPLEMENT_MARKUPCLASS(L"TextElement", CXTPMarkupTextElement, CXTPMarkupFrameworkContentElement);
  115. void CXTPMarkupTextElement::RegisterMarkupClass()
  116. {
  117. m_pBackgroundProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"Background", MARKUP_TYPE(CXTPMarkupBrush), MARKUP_TYPE(CXTPMarkupTextElement),
  118. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsRender));
  120. m_pForegroundProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"Foreground", MARKUP_TYPE(CXTPMarkupBrush), MARKUP_TYPE(CXTPMarkupTextElement),
  121. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsRender));
  123. m_pFontSizeProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"FontSize", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupTextElement),
  124. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  126. m_pFontWeightProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"FontWeight", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupTextElement),
  127. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertFontWeight, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  129. m_pFontFamilyProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"FontFamily", MARKUP_TYPE(CXTPMarkupString), MARKUP_TYPE(CXTPMarkupTextElement),
  130. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  132. m_pFontStyleProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"FontStyle", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupTextElement),
  133. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertFontStyle, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  135. m_pTextDecorationsProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"TextDecorations", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupTextElement),
  136. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertTextDecorations, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsRender));
  138. m_pFontQualityProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"FontQuality", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupTextElement),
  139. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertFontQuality, CXTPMarkupPropertyMetadata::flagInherited | CXTPMarkupPropertyMetadata::flagAffectsRender));
  140. }
  142. CXTPMarkupTextElement::CXTPMarkupTextElement()
  143. {
  145. }
  147. CXTPMarkupTextElement::~CXTPMarkupTextElement()
  148. {
  150. }
  152. void CXTPMarkupTextElement::SetBackground(CXTPMarkupBrush* pBrush)
  153. {
  154. SetValue(m_pBackgroundProperty, pBrush);
  155. }
  157. void CXTPMarkupTextElement::SetBackground(COLORREF clr)
  158. {
  159. SetValue(m_pBackgroundProperty, new CXTPMarkupSolidColorBrush(clr));
  160. }
  162. void CXTPMarkupTextElement::SetBackground(CXTPMarkupObject* pObject, CXTPMarkupBrush* pBrush)
  163. {
  164. pObject->SetValue(m_pBackgroundProperty, pBrush);
  165. }
  167. CXTPMarkupBrush* CXTPMarkupTextElement::GetBackground() const
  168. {
  169. return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pBackgroundProperty));
  170. }
  172. void CXTPMarkupTextElement::SetForeground(CXTPMarkupBrush* pBrush)
  173. {
  174. SetValue(m_pForegroundProperty, pBrush);
  175. }
  177. void CXTPMarkupTextElement::SetForeground(COLORREF clr)
  178. {
  179. SetValue(m_pForegroundProperty, new CXTPMarkupSolidColorBrush(clr));
  180. }
  182. void CXTPMarkupTextElement::SetForeground(CXTPMarkupObject* pObject, CXTPMarkupBrush* pBrush)
  183. {
  184. pObject->SetValue(m_pForegroundProperty, pBrush);
  185. }
  187. CXTPMarkupBrush* CXTPMarkupTextElement::GetForeground() const
  188. {
  189. return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pForegroundProperty));
  190. }
  193. void CXTPMarkupTextElement::SetFontSize(int nFontSize)
  194. {
  195. SetValue(m_pFontSizeProperty, new CXTPMarkupInt(nFontSize));
  196. }
  198. int CXTPMarkupTextElement::GetFontSize() const
  199. {
  200. CXTPMarkupInt* pFontSize = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pFontSizeProperty));
  201. if (!pFontSize)
  202. return -12;
  204. return *pFontSize;
  205. }
  207. void CXTPMarkupTextElement::SetFontWeight(int nFontWeight)
  208. {
  209. SetValue(m_pFontWeightProperty, CXTPMarkupEnum::CreateValue(nFontWeight));
  210. }
  212. int CXTPMarkupTextElement::GetFontWeight() const
  213. {
  214. CXTPMarkupEnum* pFontWeigh = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pFontWeightProperty));
  215. if (!pFontWeigh)
  216. return FW_NORMAL;
  218. return *pFontWeigh;
  219. }
  221. void CXTPMarkupTextElement::SetFontStyle(int nFontStyle)
  222. {
  223. SetValue(m_pFontStyleProperty, CXTPMarkupEnum::CreateValue(nFontStyle));
  224. }
  226. int CXTPMarkupTextElement::GetFontStyle() const
  227. {
  228. CXTPMarkupEnum* pFontStyle = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pFontStyleProperty));
  229. if (!pFontStyle)
  230. return 0;
  232. return *pFontStyle;
  233. }
  235. void CXTPMarkupTextElement::SetTextDecorations(int nTextDecorations)
  236. {
  237. SetValue(m_pTextDecorationsProperty, CXTPMarkupEnum::CreateValue(nTextDecorations));
  238. }
  240. int CXTPMarkupTextElement::GetTextDecorations() const
  241. {
  242. CXTPMarkupEnum* pTextDecorations = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pTextDecorationsProperty));
  243. if (!pTextDecorations)
  244. return 0;
  246. return *pTextDecorations;
  247. }
  250. void CXTPMarkupTextElement::SetFontFamily(LPCWSTR lpszFontFamily)
  251. {
  252. SetValue(m_pFontFamilyProperty, CXTPMarkupString::CreateValue(lpszFontFamily));
  254. }
  255. LPCWSTR CXTPMarkupTextElement::GetFontFamily() const
  256. {
  257. CXTPMarkupString* pFontFamily = MARKUP_STATICCAST(CXTPMarkupString, GetValue(m_pFontFamilyProperty));
  258. if (!pFontFamily)
  259. return NULL;
  261. return *pFontFamily;
  262. }
  264. CXTPMarkupInputElement* CXTPMarkupFrameworkContentElement::InputHitTest(CPoint /*point*/) const
  265. {
  266. return (CXTPMarkupInputElement*)this;
  267. }
  269. CRect CXTPMarkupFrameworkContentElement::GetBoundRect() const
  270. {
  271. return GetParent()->GetBoundRect();
  272. }
  274. //////////////////////////////////////////////////////////////////////////
  275. // CXTPMarkupInline
  277. CXTPMarkupDependencyProperty* CXTPMarkupInline::m_pBaselineAlignmentProperty = NULL;
  279. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupInline, CXTPMarkupTextElement);
  281. void CXTPMarkupInline::RegisterMarkupClass()
  282. {
  283. m_pBaselineAlignmentProperty = CXTPMarkupDependencyProperty::Register(L"BaselineAlignment", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupInline),
  284. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertBaselineAlignment, CXTPMarkupPropertyMetadata::flagAffectsArrange));
  285. }
  288. CXTPMarkupInline::CXTPMarkupInline()
  289. {
  290. m_nIndex = -1;
  291. }
  293. CXTPMarkupInline::~CXTPMarkupInline()
  294. {
  296. }
  298. POSITION CXTPMarkupInline::GetContentStartPosition() const
  299. {
  300. return MARKUP_POSITION_EOF;
  301. };
  303. void CXTPMarkupInline::GetContentNextPosition(POSITION& pos) const
  304. {
  305. pos = NULL;
  306. }
  308. BOOL CXTPMarkupInline::IsWordBreakPosition(POSITION /*pos*/) const
  309. {
  310. return FALSE;
  311. }
  313. BOOL CXTPMarkupInline::IsLineBreakPosition(POSITION /*pos*/) const
  314. {
  315. return FALSE;
  316. }
  318. BOOL CXTPMarkupInline::IsWhiteSpacePosition(POSITION /*pos*/) const
  319. {
  320. return FALSE;
  321. }
  323. void CXTPMarkupInline::PrepareMeasure(CXTPMarkupDrawingContext* /*pDC*/)
  324. {
  326. }
  329. CSize CXTPMarkupInline::Measure(CXTPMarkupDrawingContext* /*pDC*/, POSITION /*posStart*/, POSITION /*posEnd*/)
  330. {
  331. return CSize(0, 0);
  332. }
  334. int CXTPMarkupInline::GetBaseline() const
  335. {
  336. return 0;
  337. }
  339. void CXTPMarkupInline::Arrange(CRect /*rcFinalRect*/, POSITION /*posStart*/, POSITION /*posEnd*/)
  340. {
  342. }
  344. void CXTPMarkupInline::Render(CXTPMarkupDrawingContext* /*pDC*/, CRect /*rc*/, POSITION /*posStart*/, POSITION /*posEnd*/)
  345. {
  347. }
  349. CXTPMarkupInline* CXTPMarkupInline::GetFirstInline() const
  350. {
  351. return (CXTPMarkupInline*)this;
  352. }
  354. CXTPMarkupInline* CXTPMarkupInline::GetNextInline() const
  355. {
  356. CXTPMarkupInlineCollection* pOwner = MARKUP_DYNAMICCAST(CXTPMarkupInlineCollection, m_pLogicalParent);
  358. if (!pOwner)
  359. return NULL;
  361. if (pOwner->GetCount() > m_nIndex + 1)
  362. return pOwner->GetInline(m_nIndex + 1)->GetFirstInline();
  364. if (MARKUP_DYNAMICCAST(CXTPMarkupSpan, pOwner->GetLogicalParent()))
  365. return ((CXTPMarkupSpan*)(pOwner->GetLogicalParent()))->GetNextInline();
  367. return NULL;
  368. }
  370. CXTPMarkupTextBlock* CXTPMarkupInline::GetTextBlock() const
  371. {
  372. return MARKUP_STATICCAST(CXTPMarkupTextBlock, GetParent());
  373. }
  376. //////////////////////////////////////////////////////////////////////////
  377. // CXTPMarkupRun
  379. CXTPMarkupDependencyProperty* CXTPMarkupRun::m_pTextProperty = NULL;
  381. IMPLEMENT_MARKUPCLASS(L"Run", CXTPMarkupRun, CXTPMarkupInline);
  383. void CXTPMarkupRun::RegisterMarkupClass()
  384. {
  385. m_pTextProperty = CXTPMarkupDependencyProperty::Register(L"Text", MARKUP_TYPE(CXTPMarkupString), MARKUP_TYPE(CXTPMarkupRun),
  386. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  387. }
  390. CXTPMarkupRun::CXTPMarkupRun()
  391. {
  392. m_nBaseline = 0;
  393. m_pFont = NULL;
  394. }
  396. CXTPMarkupRun::~CXTPMarkupRun()
  397. {
  398. MARKUP_RELEASE(m_pFont);
  399. }
  401. void CXTPMarkupRun::OnFinalRelease()
  402. {
  403. MARKUP_RELEASE(m_pFont);
  405. CXTPMarkupInline::OnFinalRelease();
  406. }
  408. void CXTPMarkupRun::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  409. {
  410. if (IsStringObject(pContent))
  411. {
  412. SetValue(m_pTextProperty, pContent);
  413. }
  414. else
  415. {
  416. CXTPMarkupInline::SetContentObject(pBuilder, pContent);
  417. }
  418. }
  420. BOOL CXTPMarkupRun::HasContentObject() const
  421. {
  422. return GetValue(m_pTextProperty) != NULL;
  423. }
  425. int CXTPMarkupRun::GetBaseline() const
  426. {
  427. return m_nBaseline;
  428. }
  430. CString CXTPMarkupRun::GetText() const
  431. {
  432. CXTPMarkupString* pString = MARKUP_STATICCAST(CXTPMarkupString, GetValue(m_pTextProperty));
  433. if (!pString)
  434. return _T("");
  436. return CString((LPCWSTR)*pString);
  437. }
  439. void CXTPMarkupRun::SetText(LPCWSTR lpszText)
  440. {
  441. SetValue(m_pTextProperty, CXTPMarkupString::CreateValue(lpszText));
  442. }
  444. void CXTPMarkupRun::SetText(CXTPMarkupString* pText)
  445. {
  446. SetValue(m_pTextProperty, pText);
  447. }
  449. POSITION CXTPMarkupRun::GetContentStartPosition() const
  450. {
  451. CXTPMarkupString* pString = MARKUP_STATICCAST(CXTPMarkupString, GetValue(m_pTextProperty));
  452. if (!pString)
  453. return MARKUP_POSITION_EOF;
  455. LPCWSTR lpszText = (LPCWSTR)(*pString);
  457. if ((!lpszText) || (*lpszText == ''))
  458. return MARKUP_POSITION_EOF;
  460. return (POSITION)lpszText;
  461. }
  463. void CXTPMarkupRun::GetContentNextPosition(POSITION& pos) const
  464. {
  465. if (!pos || pos == MARKUP_POSITION_EOF)
  466. return;
  468. LPCWSTR lpszText = (LPCWSTR)pos;
  469. if (*lpszText == '')
  470. {
  471. pos = MARKUP_POSITION_EOF;
  472. }
  473. else
  474. {
  475. lpszText++;
  476. pos = (POSITION)lpszText;
  477. }
  478. }
  480. BOOL CXTPMarkupRun::IsWordBreakPosition(POSITION pos) const
  481. {
  482. if (!pos)
  483. return FALSE;
  484. LPCWSTR lpszText = (LPCWSTR)pos;
  486. return *lpszText == _T(' ') || *lpszText == _T('t') || *lpszText == _T('n');
  487. }
  489. BOOL CXTPMarkupRun::IsWhiteSpacePosition(POSITION pos) const
  490. {
  491. if (!pos)
  492. return FALSE;
  494. LPCWSTR lpszText = (LPCWSTR)pos;
  496. return *lpszText == _T(' ') || *lpszText == _T('t');
  497. }
  499. BOOL CXTPMarkupRun::IsLineBreakPosition(POSITION pos) const
  500. {
  501. if (!pos)
  502. return FALSE;
  503. LPCWSTR lpszText = (LPCWSTR)pos;
  505. return *lpszText == _T('n');
  506. }
  508. void CXTPMarkupRun::GetLogFont(LOGFONT* pLogFont) const
  509. {
  510. memcpy(pLogFont, GetMarkupContext()->GetDefaultLogFont(), sizeof(LOGFONT));
  512. CXTPMarkupInt* pFontSize = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pFontSizeProperty));
  513. if (pFontSize)
  514. {
  515. pLogFont->lfHeight = - *pFontSize;
  516. }
  518. CXTPMarkupEnum* pFontWeight = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pFontWeightProperty));
  519. if (pFontWeight)
  520. {
  521. pLogFont->lfWeight = *pFontWeight;
  522. }
  524. CXTPMarkupEnum* pFontStyle = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pFontStyleProperty));
  525. if (pFontStyle)
  526. {
  527. pLogFont->lfItalic = *pFontStyle ? (BYTE)1 : (BYTE)0;
  528. }
  530. CXTPMarkupEnum* pFontQuality = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pFontQualityProperty));
  531. if (pFontQuality && XTPSystemVersion()->IsClearTypeTextQualitySupported())
  532. {
  533. pLogFont->lfQuality = (BYTE)*pFontQuality;
  534. }
  536. CXTPMarkupString* pFontFamily = MARKUP_STATICCAST(CXTPMarkupString, GetValue(m_pFontFamilyProperty));
  537. if (pFontFamily)
  538. {
  539. LPCWSTR lpszFaceName = *pFontFamily;
  540. LPTSTR lpszLogFontFaceName = pLogFont->lfFaceName;
  542. while ((*lpszLogFontFaceName++ = (TCHAR)*(lpszFaceName++)) != 0);
  543. }
  544. }
  546. void CXTPMarkupRun::PrepareMeasure(CXTPMarkupDrawingContext* pDC)
  547. {
  548. LOGFONT lf;
  549. GetLogFont(&lf);
  551. if (m_pFont == NULL || !CXTPMarkupContext::CompareFont(&m_pFont->m_lf, &lf))
  552. {
  553. CXTPMarkupFont* pFont = GetMarkupContext()->GetFont(&lf);
  554. MARKUP_RELEASE(m_pFont);
  556. m_pFont = pFont;
  557. }
  559. pDC->SetFont(m_pFont);
  561. TEXTMETRIC tm;
  562. GetTextMetrics(pDC->GetSafeHdc(), &tm);
  564. m_nBaseline = tm.tmDescent;
  565. }
  567. CSize CXTPMarkupRun::Measure(CXTPMarkupDrawingContext* pDC, POSITION posStart, POSITION posEnd)
  568. {
  569. if (posStart == NULL || posEnd == NULL || posEnd == posStart || posEnd == MARKUP_POSITION_EOF)
  570. return CSize(0, 0);
  572. LPCWSTR lpszText = (LPCWSTR)posStart;
  573. int nCount = int(posEnd - posStart) / sizeof(WCHAR);
  575. pDC->SetFont(m_pFont);
  577. SIZE sz = pDC->GetTextExtent(lpszText, nCount);
  579. return sz;
  580. }
  582. void CXTPMarkupRun::Render(CXTPMarkupDrawingContext* pDC, CRect rc, POSITION posStart, POSITION posEnd)
  583. {
  584. if (posStart == NULL || posEnd == NULL || posEnd == posStart || posEnd == MARKUP_POSITION_EOF)
  585. return;
  587. LPCWSTR lpszText = (LPCWSTR)posStart;
  588. UINT nCount = UINT(posEnd - posStart) / sizeof(WCHAR);
  590. pDC->SetFont(m_pFont);
  591. pDC->DrawTextLine(lpszText, nCount, rc);
  592. }
  594. //////////////////////////////////////////////////////////////////////////
  595. // CXTPMarkupLineBreak
  597. IMPLEMENT_MARKUPCLASS(L"LineBreak", CXTPMarkupLineBreak, CXTPMarkupRun);
  599. void CXTPMarkupLineBreak::RegisterMarkupClass()
  600. {
  602. }
  604. CXTPMarkupLineBreak::CXTPMarkupLineBreak()
  605. {
  606. SetText(L"n");
  607. }
  609. //////////////////////////////////////////////////////////////////////////
  610. // CXTPMarkupInlineCollection
  612. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupInlineCollection, CXTPMarkupCollection);
  614. void CXTPMarkupInlineCollection::RegisterMarkupClass()
  615. {
  617. }
  618. CXTPMarkupInlineCollection::CXTPMarkupInlineCollection()
  619. {
  620. m_pElementType = MARKUP_TYPE(CXTPMarkupInline);
  621. }
  623. CXTPMarkupInlineCollection::~CXTPMarkupInlineCollection()
  624. {
  625. }
  627. void CXTPMarkupInlineCollection::OnItemAdded(CXTPMarkupObject* pItem, int nIndex)
  628. {
  629. ((CXTPMarkupInline*)pItem)->m_nIndex = nIndex;
  630. }
  632. void CXTPMarkupInlineCollection::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  633. {
  634. CXTPMarkupInputElement* pParent = MARKUP_DYNAMICCAST(CXTPMarkupInputElement, m_pLogicalParent);
  635. ASSERT(pParent);
  636. if (!pParent)
  637. {
  638. pBuilder->ThrowBuilderException(CXTPMarkupBuilder::FormatString(_T("'%ls' object cannot be added to '%ls'. Object cannot be converted to type 'CXTPMarkupInline'"),
  639. (LPCTSTR)pContent->GetType()->m_lpszClassName, (LPCTSTR)GetType()->m_lpszClassName));
  640. }
  642. if (IsStringObject(pContent))
  643. {
  644. CXTPMarkupRun* pRun = MARKUP_CREATE(CXTPMarkupRun, pParent->GetMarkupContext());
  645. pRun->SetText((CXTPMarkupString*)pContent);
  646. Add(pRun);
  647. }
  648. else if (pContent->IsKindOf(MARKUP_TYPE(CXTPMarkupInline)))
  649. {
  650. Add((CXTPMarkupInline*)pContent);
  651. }
  652. else if  (pContent->IsKindOf(MARKUP_TYPE(CXTPMarkupUIElement)))
  653. {
  654. CXTPMarkupInlineUIContainer* pInlineUIContainer = MARKUP_CREATE(CXTPMarkupInlineUIContainer, pParent->GetMarkupContext());
  655. pInlineUIContainer->SetChild((CXTPMarkupUIElement*)pContent);
  656. Add(pInlineUIContainer);
  657. }
  658. else
  659. {
  660. pBuilder->ThrowBuilderException(CXTPMarkupBuilder::FormatString(_T("'%ls' object cannot be added to '%ls'. Object cannot be converted to type 'CXTPMarkupInline'"),
  661. (LPCTSTR)pContent->GetType()->m_lpszClassName, (LPCTSTR)GetType()->m_lpszClassName));
  662. }
  663. }
  666. //////////////////////////////////////////////////////////////////////////
  667. // CXTPMarkupSpan
  669. IMPLEMENT_MARKUPCLASS(L"Span", CXTPMarkupSpan, CXTPMarkupInline);
  671. void CXTPMarkupSpan::RegisterMarkupClass()
  672. {
  674. }
  676. CXTPMarkupSpan::CXTPMarkupSpan()
  677. {
  678. m_pInlines = new CXTPMarkupInlineCollection();
  679. m_pInlines->SetLogicalParent(this);
  680. }
  682. CXTPMarkupSpan::~CXTPMarkupSpan()
  683. {
  684. if (m_pInlines)
  685. {
  686. m_pInlines->SetLogicalParent(NULL);
  687. m_pInlines->Release();
  688. }
  689. }
  691. void CXTPMarkupSpan::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  692. {
  693. m_pInlines->SetContentObject(pBuilder, pContent);
  694. }
  695. BOOL CXTPMarkupSpan::HasContentObject() const
  696. {
  697. return m_pInlines->HasContentObject();
  698. }
  700. BOOL CXTPMarkupSpan::AllowWhiteSpaceContent() const
  701. {
  702. return TRUE;
  703. }
  706. CXTPMarkupInline* CXTPMarkupSpan::GetFirstInline() const
  707. {
  708. return m_pInlines->GetCount() > 0 ? m_pInlines->GetInline(0)->GetFirstInline() : (CXTPMarkupInline*)this;
  709. }
  711. //////////////////////////////////////////////////////////////////////////
  712. // CXTPMarkupBold
  714. IMPLEMENT_MARKUPCLASS(L"Bold", CXTPMarkupBold, CXTPMarkupSpan);
  716. void CXTPMarkupBold::RegisterMarkupClass()
  717. {
  719. }
  721. CXTPMarkupBold::CXTPMarkupBold()
  722. {
  723. SetFontWeight(FW_BOLD);
  725. }
  727. //////////////////////////////////////////////////////////////////////////
  728. // CXTPMarkupHyperlink
  730. CXTPMarkupRoutedEvent* CXTPMarkupHyperlink::m_pClickEvent = NULL;
  732. IMPLEMENT_MARKUPCLASS(L"Hyperlink", CXTPMarkupHyperlink, CXTPMarkupSpan);
  734. void CXTPMarkupHyperlink::RegisterMarkupClass()
  735. {
  736. CXTPMarkupStyle::RegisterType();
  737. CXTPMarkupButtonBase::RegisterType();
  738. CXTPMarkupSolidColorBrush::RegisterType();
  739. CXTPMarkupHyperlink::RegisterType();
  741. CXTPMarkupType* pType = MARKUP_TYPE(CXTPMarkupHyperlink);
  743. CXTPMarkupStyle* pStyle = new CXTPMarkupStyle();
  744. pStyle->GetSetters()->Add(new CXTPMarkupSetter(CXTPMarkupHyperlink::m_pTextDecorationsProperty, CXTPMarkupEnum::CreateValue(1)));
  745. pStyle->GetSetters()->Add(new CXTPMarkupSetter(CXTPMarkupHyperlink::m_pForegroundProperty, new CXTPMarkupSolidColorBrush(RGB(0, 0, 255))));
  746. pStyle->GetSetters()->Add(new CXTPMarkupSetter(CXTPMarkupHyperlink::m_pCursorProperty, new CXTPMarkupInt(32649)));
  748. CXTPMarkupTriggerCollection* pTriggers = new CXTPMarkupTriggerCollection();
  749. CXTPMarkupTrigger* pTrigger = new CXTPMarkupTrigger(CXTPMarkupHyperlink::m_pIsMouseOverProperty, CXTPMarkupBool::CreateTrueValue());
  750. CXTPMarkupSetterColection* pSetters = new CXTPMarkupSetterColection();
  751. pSetters->Add(new CXTPMarkupSetter(CXTPMarkupHyperlink::m_pForegroundProperty, new CXTPMarkupSolidColorBrush(RGB(255, 0, 0))));
  752. pTrigger->SetSetters(pSetters);
  753. pTriggers->Add(pTrigger);
  754. pStyle->SetTriggers(pTriggers);
  756. pType->SetTypeStyle(pStyle);
  758. m_pClickEvent = (CXTPMarkupRoutedEvent*)CXTPMarkupButtonBase::m_pClickEvent->AddOwner(MARKUP_TYPE(CXTPMarkupHyperlink));
  759. }
  761. CXTPMarkupHyperlink::CXTPMarkupHyperlink()
  762. {
  763. m_bPressed = FALSE;
  764. }
  766. void CXTPMarkupHyperlink::OnMouseLeftButtonUp(CXTPMarkupMouseButtonEventArgs* e)
  767. {
  768. if (m_bPressed)
  769. {
  770. m_bPressed = FALSE;
  771. OnClick();
  772. e->SetHandled();
  773. }
  774. }
  776. void CXTPMarkupHyperlink::OnMouseLeftButtonDown(CXTPMarkupMouseButtonEventArgs* e)
  777. {
  778. m_bPressed = TRUE;
  779. e->SetHandled();
  780. }
  782. void CXTPMarkupHyperlink::OnClick()
  783. {
  784. CXTPMarkupRoutedEventArgs e(m_pClickEvent, this);
  785. RaiseEvent(&e);
  786. }
  788. //////////////////////////////////////////////////////////////////////////
  789. // CXTPMarkupItalic
  791. IMPLEMENT_MARKUPCLASS(L"Italic", CXTPMarkupItalic, CXTPMarkupSpan);
  793. void CXTPMarkupItalic::RegisterMarkupClass()
  794. {
  796. }
  798. CXTPMarkupItalic::CXTPMarkupItalic()
  799. {
  800. SetFontStyle(1);
  801. }
  803. //////////////////////////////////////////////////////////////////////////
  804. // CXTPMarkupUnderline
  806. IMPLEMENT_MARKUPCLASS(L"Underline", CXTPMarkupUnderline, CXTPMarkupSpan);
  808. void CXTPMarkupUnderline::RegisterMarkupClass()
  809. {
  811. }
  813. CXTPMarkupUnderline::CXTPMarkupUnderline()
  814. {
  815. SetTextDecorations(1);
  816. }
  818. //////////////////////////////////////////////////////////////////////////
  819. // CXTPMarkupInlineUIContainer
  821. IMPLEMENT_MARKUPCLASS(L"InlineUIContainer", CXTPMarkupInlineUIContainer, CXTPMarkupInline);
  823. void CXTPMarkupInlineUIContainer::RegisterMarkupClass()
  824. {
  826. }
  828. CXTPMarkupInlineUIContainer::CXTPMarkupInlineUIContainer()
  829. {
  830. m_pChild = NULL;
  831. }
  833. CXTPMarkupInlineUIContainer::CXTPMarkupInlineUIContainer(CXTPMarkupUIElement* pElement)
  834. {
  835. m_pChild = NULL;
  836. SetChild(pElement);
  837. }
  839. CXTPMarkupInlineUIContainer::~CXTPMarkupInlineUIContainer()
  840. {
  841. MARKUP_RELEASE(m_pChild);
  842. }
  844. CXTPMarkupUIElement* CXTPMarkupInlineUIContainer::GetChild() const
  845. {
  846. return m_pChild;
  847. }
  849. void CXTPMarkupInlineUIContainer::SetChild(CXTPMarkupUIElement* pChild)
  850. {
  851. if (m_pChild)
  852. {
  853. m_pChild->SetLogicalParent(NULL);
  854. MARKUP_RELEASE(m_pChild);
  855. }
  857. m_pChild = pChild;
  859. if (m_pChild)
  860. {
  861. m_pChild->SetLogicalParent(this);
  862. }
  863. }
  866. void CXTPMarkupInlineUIContainer::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  867. {
  868. if (!pContent->IsKindOf(MARKUP_TYPE(CXTPMarkupUIElement)))
  869. {
  870. pBuilder->ThrowBuilderException(CXTPMarkupBuilder::FormatString(_T("'%ls' object cannot be added to '%ls'. Object cannot be converted to type 'CXTPMarkupUIElement'"),
  871. (LPCTSTR)pContent->GetType()->m_lpszClassName, (LPCTSTR)GetType()->m_lpszClassName));
  872. }
  874. SetChild((CXTPMarkupUIElement*)pContent);
  875. }
  877. BOOL CXTPMarkupInlineUIContainer::HasContentObject() const
  878. {
  879. return m_pChild != NULL;
  880. }
  882. POSITION CXTPMarkupInlineUIContainer::GetContentStartPosition() const
  883. {
  884. return m_pChild ? MARKUP_POSITION_START : MARKUP_POSITION_EOF;
  885. };
  887. void CXTPMarkupInlineUIContainer::GetContentNextPosition(POSITION& pos) const
  888. {
  889. pos = (pos == MARKUP_POSITION_START ? MARKUP_POSITION_END : MARKUP_POSITION_EOF);
  890. }
  892. BOOL CXTPMarkupInlineUIContainer::IsWordBreakPosition(POSITION pos) const
  893. {
  894. return pos == MARKUP_POSITION_START || pos == MARKUP_POSITION_END;
  895. }
  897. CSize CXTPMarkupInlineUIContainer::Measure(CXTPMarkupDrawingContext* pDC, POSITION posStart, POSITION /*posEnd*/)
  898. {
  899. if (!m_pChild || posStart != MARKUP_POSITION_START)
  900. return CSize(0, 0);
  902. m_pChild->Measure(pDC, CSize(32000, 32000));
  904. return m_pChild->GetDesiredSize();
  905. }
  907. void CXTPMarkupInlineUIContainer::Arrange(CRect rcFinalRect, POSITION posStart, POSITION /*posEnd*/)
  908. {
  909. if (!m_pChild || posStart != MARKUP_POSITION_START)
  910. return;
  912. m_pChild->Arrange(rcFinalRect);
  913. }
  915. void CXTPMarkupInlineUIContainer::Render(CXTPMarkupDrawingContext* pDC, CRect /*rc*/, POSITION posStart, POSITION /*posEnd*/)
  916. {
  917. if (!m_pChild  || posStart != MARKUP_POSITION_START)
  918. return;
  920. m_pChild->Render(pDC);
  921. }
  923. CXTPMarkupInputElement* CXTPMarkupInlineUIContainer::InputHitTest(CPoint point) const
  924. {
  925. CXTPMarkupInputElement* pObject = m_pChild ? m_pChild->InputHitTest(point) : (CXTPMarkupInputElement*)this;
  927. if (pObject)
  928. return pObject;
  930. return (CXTPMarkupInputElement*)this;
  931. }