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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupTextBlock.cpp：源码内容
  1. // XTPMarkupTextBlock.cpp: implementation of the CXTPMarkupTextBlock 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"
  22. #include "XTPMarkupTextBlock.h"
  23. #include "XTPMarkupDrawingContext.h"
  24. #include "XTPMarkupInline.h"
  25. #include "XTPMarkupBuilder.h"
  26. #include "XTPMarkupContext.h"
  28. #ifdef _DEBUG
  29. #undef THIS_FILE
  30. static char THIS_FILE[]=__FILE__;
  31. #define new DEBUG_NEW
  32. #endif
  35. struct CXTPMarkupTextBlock::CLinePart
  36. {
  37. CLinePart(CXTPMarkupInline* pInline, POSITION pos)
  38. {
  39. ZeroMemory(this, sizeof(CLinePart));
  41. this->pInline = pInline;
  42. this->posStart = pos;
  43. this->posEnd = pos;
  45. pInline->AddRef();
  46. }
  48. ~CLinePart()
  49. {
  50. pInline->Release();
  52. }
  54. void Calculate(CLineIterator& li);
  56. CXTPMarkupInline* pInline;
  57. POSITION posStart;
  58. POSITION posEnd;
  59. POINT ptTopLeft;
  60. POINT ptOffset;
  61. CLine* pLine;
  62. SIZE size;
  63. int nBaseline;
  64. CLinePart* m_pNextChain;
  65. };
  67. class CXTPMarkupTextBlock::CLinePartList : public CXTPMarkupTypedSimpleStack<CLinePart>
  68. {
  70. };
  72. struct CXTPMarkupTextBlock::CLine
  73. {
  74. public:
  75. CLine()
  76. {
  77. m_nWidth = m_nHeight = m_nBaseline = 0;
  78. m_pNextChain = NULL;
  79. }
  81. ~CLine()
  82. {
  83. CLinePart* pos = m_arrParts.GetHead();
  84. while (pos)
  85. {
  86. CLinePart* posDelete = pos;
  87. pos = pos->m_pNextChain;
  89. delete posDelete;
  90. }
  92. m_arrParts.RemoveAll();
  93. }
  95. public:
  97. BOOL IsEmpty() const
  98. {
  99. return m_arrParts.IsEmpty();
  100. }
  102. CLinePartList m_arrParts;
  103. int m_nWidth;
  104. int m_nHeight;
  105. int m_nBaseline;
  106. CLine* m_pNextChain;
  107. };
  109. class CXTPMarkupTextBlock::CLineList : public CXTPMarkupTypedSimpleStack<CLine>
  110. {
  112. };
  116. struct CXTPMarkupTextBlock::CLineIterator
  117. {
  118. CLineIterator()
  119. {
  120. x = y = nMaxWidth = 0;
  121. pLine = NULL;
  122. pLinePart = NULL;
  123. }
  125. int x;
  126. int y;
  127. int nMaxWidth;
  128. CLine* pLine;
  129. CLinePart* pLinePart;
  130. CLinePartList arrStack;
  131. CXTPMarkupDrawingContext* pDC;
  132. BOOL bTextWrapping;
  133. XTPMarkupTextTrimming bTextTrimming;
  134. };
  136. //////////////////////////////////////////////////////////////////////
  137. // Construction/Destruction
  138. //////////////////////////////////////////////////////////////////////
  140. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pBackgroundProperty = NULL;
  141. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pForegroundProperty = NULL;
  142. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pFontSizeProperty = NULL;
  143. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pFontWeightProperty = NULL;
  144. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pFontFamilyProperty = NULL;
  145. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pFontStyleProperty = NULL;
  146. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pTextDecorationsProperty = NULL;
  147. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pTextWrappingProperty = NULL;
  148. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pTextTrimmingProperty = NULL;
  149. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pTextAlignmentProperty = NULL;
  150. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pPaddingProperty = NULL;
  151. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pTextProperty = NULL;
  152. CXTPMarkupDependencyProperty* CXTPMarkupTextBlock::m_pFontQualityProperty = NULL;
  155. IMPLEMENT_MARKUPCLASS(L"TextBlock", CXTPMarkupTextBlock, CXTPMarkupFrameworkElement)
  157. void CXTPMarkupTextBlock::RegisterMarkupClass()
  158. {
  159. CXTPMarkupTextElement::RegisterType();
  161. m_pBackgroundProperty =
  162. CXTPMarkupTextElement::m_pBackgroundProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  164. m_pForegroundProperty =
  165. CXTPMarkupTextElement::m_pForegroundProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  167. m_pFontSizeProperty =
  168. CXTPMarkupTextElement::m_pFontSizeProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  170. m_pFontWeightProperty =
  171. CXTPMarkupTextElement::m_pFontWeightProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  173. m_pFontQualityProperty =
  174. CXTPMarkupTextElement::m_pFontQualityProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  176. m_pFontFamilyProperty =
  177. CXTPMarkupTextElement::m_pFontFamilyProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  179. m_pFontStyleProperty =
  180. CXTPMarkupTextElement::m_pFontStyleProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  182. m_pTextDecorationsProperty =
  183. CXTPMarkupTextElement::m_pTextDecorationsProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTextBlock));
  185. m_pTextWrappingProperty =
  186. CXTPMarkupDependencyProperty::Register(L"TextWrapping", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupTextBlock),
  187. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertTextWrapping, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  189. m_pTextTrimmingProperty =
  190. CXTPMarkupDependencyProperty::Register(L"TextTrimming", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupTextBlock),
  191. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertTextTrimming, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  193. m_pTextAlignmentProperty =
  194. CXTPMarkupDependencyProperty::Register(L"TextAlignment", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupTextBlock),
  195. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertTextAlignment, CXTPMarkupPropertyMetadata::flagAffectsArrange));
  197. m_pPaddingProperty =
  198. CXTPMarkupDependencyProperty::Register(L"Padding", MARKUP_TYPE(CXTPMarkupThickness), MARKUP_TYPE(CXTPMarkupTextBlock),
  199. new CXTPMarkupPropertyMetadata(CXTPMarkupThickness::CreateValue(), CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  201. m_pTextProperty =
  202. CXTPMarkupDependencyProperty::Register(L"Text", MARKUP_TYPE(CXTPMarkupString), MARKUP_TYPE(CXTPMarkupTextBlock),
  203. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  205. }
  207. CXTPMarkupTextBlock::CXTPMarkupTextBlock()
  208. {
  209. m_pInlines = new CXTPMarkupInlineCollection();
  210. m_pInlines->SetLogicalParent(this);
  212. m_nLastWidth = -1;
  213. m_szBlockSize = CSize(0, 0);
  215. m_pLineList = new CLineList();
  216. }
  218. CXTPMarkupTextBlock::~CXTPMarkupTextBlock()
  219. {
  220. RemoveAllLines();
  221. delete m_pLineList;
  223. if (m_pInlines)
  224. {
  225. m_pInlines->RemoveAll();
  226. m_pInlines->SetLogicalParent(NULL);
  227. MARKUP_RELEASE(m_pInlines);
  228. }
  229. }
  231. void CXTPMarkupTextBlock::SetTextAlignment(XTPMarkupTextAlignment alignment)
  232. {
  233. SetValue(m_pTextAlignmentProperty, CXTPMarkupEnum::CreateValue(alignment));
  234. }
  236. XTPMarkupTextAlignment CXTPMarkupTextBlock::GetTextAlignment() const
  237. {
  238. CXTPMarkupEnum* pAlign = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pTextAlignmentProperty));
  239. return pAlign ? (XTPMarkupTextAlignment)(int)(*pAlign) : xtpMarkupTextAlignmentLeft;
  240. }
  242. CXTPMarkupBrush* CXTPMarkupTextBlock::GetBackground() const
  243. {
  244. return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pBackgroundProperty));
  245. }
  247. CXTPMarkupBrush* CXTPMarkupTextBlock::GetForeground() const
  248. {
  249. return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pForegroundProperty));
  250. }
  252. void CXTPMarkupTextBlock::SetBackground(CXTPMarkupBrush* brush)
  253. {
  254. SetValue(m_pBackgroundProperty, brush);
  255. }
  257. void CXTPMarkupTextBlock::SetForeground(CXTPMarkupBrush* brush)
  258. {
  259. SetValue(m_pForegroundProperty, brush);
  260. }
  262. void CXTPMarkupTextBlock::SetText(LPCWSTR lpszText)
  263. {
  264. SetValue(m_pTextProperty, CXTPMarkupString::CreateValue(lpszText));
  265. }
  267. CString CXTPMarkupTextBlock::GetText() const
  268. {
  269. if (m_pInlines->GetCount() != 1 || MARKUP_DYNAMICCAST(CXTPMarkupRun, m_pInlines->GetInline(0)) == 0)
  270. return _T("");
  272. return ((CXTPMarkupRun*)m_pInlines->GetInline(0))->GetText();
  273. }
  275. void CXTPMarkupTextBlock::OnPropertyChanged(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue)
  276. {
  277. if (pProperty == m_pTextProperty)
  278. {
  279. ASSERT(m_pMarkupContext);
  280. m_pInlines->RemoveAll();
  282. CXTPMarkupRun* pRun = MARKUP_CREATE(CXTPMarkupRun, m_pMarkupContext);
  283. pRun->SetText(((CXTPMarkupString*)pNewValue));
  285. m_pInlines->Add(pRun);
  287. MARKUP_ADDREF(pNewValue);
  288. }
  290. CXTPMarkupFrameworkElement::OnPropertyChanged(pProperty, pOldValue  , pNewValue);
  291. }
  293. void CXTPMarkupTextBlock::SetFontSize(int nFontSize)
  294. {
  295. SetValue(m_pFontSizeProperty, new CXTPMarkupInt(nFontSize));
  296. }
  298. int CXTPMarkupTextBlock::GetFontSize() const
  299. {
  300. CXTPMarkupInt* pFontSize = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pFontSizeProperty));
  301. if (!pFontSize)
  302. return -12;
  304. return *pFontSize;
  305. }
  307. void CXTPMarkupTextBlock::SetFontWeight(int nFontWeight)
  308. {
  309. SetValue(m_pFontWeightProperty, CXTPMarkupEnum::CreateValue(nFontWeight));
  310. }
  312. int CXTPMarkupTextBlock::GetFontWeight() const
  313. {
  314. CXTPMarkupEnum* pFontWeigh = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pFontWeightProperty));
  315. if (!pFontWeigh)
  316. return FW_NORMAL;
  318. return *pFontWeigh;
  319. }
  321. void CXTPMarkupTextBlock::SetFontStyle(int nFontStyle)
  322. {
  323. SetValue(m_pFontStyleProperty, CXTPMarkupEnum::CreateValue(nFontStyle));
  324. }
  326. int CXTPMarkupTextBlock::GetFontStyle() const
  327. {
  328. CXTPMarkupEnum* pFontStyle = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pFontStyleProperty));
  329. if (!pFontStyle)
  330. return 0;
  332. return *pFontStyle;
  333. }
  335. void CXTPMarkupTextBlock::SetTextDecorations(int nTextDecorations)
  336. {
  337. SetValue(m_pTextDecorationsProperty, CXTPMarkupEnum::CreateValue(nTextDecorations));
  338. }
  340. int CXTPMarkupTextBlock::GetTextDecorations() const
  341. {
  342. CXTPMarkupEnum* pTextDecorations = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pTextDecorationsProperty));
  343. if (!pTextDecorations)
  344. return 0;
  346. return *pTextDecorations;
  347. }
  350. void CXTPMarkupTextBlock::SetFontFamily(LPCWSTR lpszFontFamily)
  351. {
  352. SetValue(m_pFontFamilyProperty, CXTPMarkupString::CreateValue(lpszFontFamily));
  354. }
  355. LPCWSTR CXTPMarkupTextBlock::GetFontFamily() const
  356. {
  357. CXTPMarkupString* pFontFamily = MARKUP_STATICCAST(CXTPMarkupString, GetValue(m_pFontFamilyProperty));
  358. if (!pFontFamily)
  359. return NULL;
  361. return *pFontFamily;
  362. }
  365. CXTPMarkupInline* CXTPMarkupTextBlock::GetFirstInline() const
  366. {
  367. return m_pInlines->GetCount() > 0 ? m_pInlines->GetInline(0)->GetFirstInline() : NULL;
  368. }
  370. void CXTPMarkupTextBlock::RemoveAllLines()
  371. {
  372. CLine* pLine = m_pLineList->GetHead();
  373. while (pLine)
  374. {
  375. CLine* pLineDelete = pLine;
  376. pLine = pLine->m_pNextChain;
  377. delete pLineDelete;
  378. }
  379. m_pLineList->RemoveAll();
  380. }
  382. void CXTPMarkupTextBlock::TrimLine(CLineIterator& li, int nWidth)
  383. {
  384. CXTPMarkupRun* pRunEllipsis = MARKUP_CREATE(CXTPMarkupRun, m_pMarkupContext);
  385. pRunEllipsis->SetLogicalParent(this);
  386. pRunEllipsis->SetText(L"...");
  388. CLinePart* pPartEllipsis = new CLinePart(pRunEllipsis, pRunEllipsis->GetContentStartPosition());
  389. pRunEllipsis->GetContentNextPosition(pPartEllipsis->posEnd);
  390. pRunEllipsis->GetContentNextPosition(pPartEllipsis->posEnd);
  391. pRunEllipsis->GetContentNextPosition(pPartEllipsis->posEnd);
  393. pPartEllipsis->pInline->PrepareMeasure(li.pDC);
  394. pPartEllipsis->Calculate(li);
  396. nWidth -= pPartEllipsis->size.cx;
  398. int x = 0;
  399. CLinePart* pPart = li.pLine->m_arrParts.GetHead();
  400. while (pPart)
  401. {
  402. if (x + pPart->size.cx > nWidth)
  403. {
  404. CXTPMarkupInline* pInline = pPart->pInline;
  405. pPart->posEnd = pPart->posStart;
  406. POSITION posChar = pPart->posEnd, posWord = (x == 0 ? NULL : pPart->posEnd);
  408. while (pPart->posEnd != MARKUP_POSITION_EOF)
  409. {
  410. pPart->Calculate(li);
  412. if (x + pPart->size.cx > nWidth)
  413. break;
  415. posChar = pPart->posEnd;
  417. if (li.bTextTrimming == xtpMarkupTextTrimmingWordEllipsis && pInline->IsWordBreakPosition(pPart->posEnd))
  418. posWord = posChar;
  420. pInline->GetContentNextPosition(pPart->posEnd);
  421. }
  422. pPart->posEnd = posWord && li.bTextTrimming == xtpMarkupTextTrimmingWordEllipsis ? posWord : posChar;
  423. pPart->Calculate(li);
  425. x += pPart->size.cx;
  426. break;
  427. }
  428. x += pPart->size.cx;
  430. pPart = pPart->m_pNextChain;
  431. }
  433. if (pPart)
  434. {
  435. while (pPart->m_pNextChain)
  436. {
  437. CLinePart* pNextChain = pPart->m_pNextChain;
  438. li.pLine->m_arrParts.Remove(pNextChain);
  440. delete pNextChain;
  441. }
  442. }
  444. li.pLine->m_arrParts.AddTail(pPartEllipsis);
  445. pPartEllipsis->ptTopLeft = CPoint(x, li.y);
  447. pRunEllipsis->Release();
  448. }
  450. void CXTPMarkupTextBlock::CloseLine(CLineIterator& li, int nWidth)
  451. {
  452. if (!li.pLine->m_arrParts.IsEmpty())
  453. {
  454. ASSERT(li.pLine->m_nHeight == 0);
  456. if (li.bTextTrimming != xtpMarkupTextTrimmingNone && li.x > nWidth)
  457. {
  458. TrimLine(li, nWidth);
  459. }
  461. CLinePart* pPart = li.pLine->m_arrParts.GetHead();
  462. while (pPart)
  463. {
  464. li.pLine->m_nWidth += pPart->size.cx;
  465. li.pLine->m_nBaseline = max(li.pLine->m_nBaseline, pPart->nBaseline);
  466. pPart = pPart->m_pNextChain;
  467. }
  469. pPart = li.pLine->m_arrParts.GetHead();
  470. while (pPart)
  471. {
  472. li.pLine->m_nHeight = max(li.pLine->m_nHeight, pPart->size.cy - pPart->nBaseline + li.pLine->m_nBaseline);
  473. pPart = pPart->m_pNextChain;
  474. }
  476. li.nMaxWidth = max(li.nMaxWidth, li.pLine->m_nWidth);
  478. li.x = 0;
  479. li.y += li.pLine->m_nHeight;
  481. m_pLineList->AddTail(li.pLine);
  482. li.pLine = new CLine();
  483. }
  484. }
  486. void CXTPMarkupTextBlock::PushLinePart(CLineIterator& li, int nWidth, BOOL bAddToStack)
  487. {
  488. if (bAddToStack && li.pLinePart && li.pLinePart->posStart != li.pLinePart->posEnd)
  489. {
  490. CLinePart* pLinePart = li.pLinePart;
  491. li.pLinePart = new CLinePart(pLinePart->pInline, pLinePart->posEnd);
  493. li.arrStack.AddTail(pLinePart);
  494. }
  496. while (!li.arrStack.IsEmpty())
  497. {
  498. if (li.bTextWrapping && li.x > 0 && li.x + GetStackWidth(li) > nWidth)
  499. {
  500. if (!bAddToStack)
  501. {
  502. break;
  503. }
  504. CloseLine(li, nWidth);
  505. }
  507. CLinePart* pPart = li.arrStack.RemoveHead();
  509. if (li.x == 0 && li.y > 0 && pPart->pInline->IsWhiteSpacePosition(pPart->posStart))
  510. {
  511. while (pPart->posStart != pPart->posEnd && pPart->pInline->IsWhiteSpacePosition(pPart->posStart))
  512. {
  513. pPart->pInline->GetContentNextPosition(pPart->posStart);
  514. }
  516. if (pPart->posStart == pPart->posEnd)
  517. {
  518. delete pPart;
  519. continue;
  520. }
  521. pPart->size = pPart->pInline->Measure(li.pDC, pPart->posStart, pPart->posEnd);
  522. }
  524. CLinePart* pPartLast = !li.pLine->m_arrParts.IsEmpty() ? li.pLine->m_arrParts.GetTail() : NULL;
  526. if (pPartLast && pPartLast->posEnd == pPart->posStart && pPart->pInline == pPartLast->pInline && pPartLast->pInline)
  527. {
  528. ASSERT(pPartLast->size.cy == pPart->size.cy);
  529. pPartLast->posEnd = pPart->posEnd;
  531. li.x -= pPartLast->size.cx;
  532. pPartLast->size = pPartLast->pInline->Measure(li.pDC, pPartLast->posStart, pPartLast->posEnd);
  533. li.x += pPartLast->size.cx;
  535. delete pPart;
  536. }
  537. else
  538. {
  539. pPart->ptTopLeft = CPoint(li.x, li.y);
  540. pPart->pLine = li.pLine;
  541. li.pLine->m_arrParts.AddTail(pPart);
  542. li.x += pPart->size.cx;
  543. }
  544. }
  545. }
  547. void CXTPMarkupTextBlock::CLinePart::Calculate(CLineIterator& li)
  548. {
  549. size = pInline->Measure(li.pDC, posStart, posEnd);
  550. nBaseline = pInline->GetBaseline();
  551. }
  553. int CXTPMarkupTextBlock::GetStackWidth(CLineIterator& li) const
  554. {
  555. int nStackWidth = 0;
  557. for (CLinePart* part = li.arrStack.GetHead(); part != NULL; part = part->m_pNextChain)
  558. {
  559. nStackWidth += part->size.cx;
  560. }
  562. return nStackWidth;
  563. }
  566. void CXTPMarkupTextBlock::CalculateLines(CXTPMarkupDrawingContext* pDC, int nWidth)
  567. {
  568. CLineIterator li;
  569. li.bTextWrapping = GetTextWrapping();
  570. li.bTextTrimming = li.bTextWrapping ? xtpMarkupTextTrimmingNone : GetTextTrimming();
  572. if (((m_nLastWidth == nWidth) || (!li.bTextWrapping && !li.bTextTrimming && m_nLastWidth != -1)) && !pDC->IsPrinting())
  573. return;
  575. m_nLastWidth = nWidth;
  577. RemoveAllLines();
  579. li.pLine = new CLine();
  581. li.pDC = pDC;
  583. CXTPMarkupInline* pInline = GetFirstInline();
  585. while (pInline)
  586. {
  587. pInline->PrepareMeasure(li.pDC);
  589. POSITION pos = pInline->GetContentStartPosition();
  591. li.pLinePart = new CLinePart(pInline, pos);
  593. while (pos != MARKUP_POSITION_EOF)
  594. {
  595. li.pLinePart->posEnd = pos;
  597. if (li.bTextWrapping && pInline->IsWordBreakPosition(pos))
  598. {
  599. li.pLinePart->Calculate(li);
  601. PushLinePart(li, nWidth);
  602. }
  604. if (pInline->IsLineBreakPosition(pos))
  605. {
  606. pInline->GetContentNextPosition(pos);
  608. if (li.pLine->m_arrParts.IsEmpty())
  609. {
  610. if (li.pLinePart->posEnd == li.pLinePart->posStart && li.arrStack.IsEmpty())
  611. li.pLinePart->posEnd = pos;
  613. li.pLinePart->Calculate(li);
  614. PushLinePart(li, nWidth);
  615. }
  617. CloseLine(li, nWidth);
  618. li.pLinePart->posStart = pos;
  620. continue;
  621. }
  623. pInline->GetContentNextPosition(pos);
  624. }
  626. if (li.pLinePart->posStart == li.pLinePart->posEnd)
  627. {
  628. delete li.pLinePart;
  629. }
  630. else
  631. {
  632. li.pLinePart->Calculate(li);
  634. li.arrStack.AddTail(li.pLinePart);
  635. }
  636. li.pLinePart = NULL;
  638. pInline = pInline->GetNextInline();
  639. }
  641. PushLinePart(li, nWidth);
  642. CloseLine(li, nWidth);
  644. delete li.pLine;
  645. ASSERT(!li.pLinePart);
  646. ASSERT(li.arrStack.IsEmpty());
  648. if (pDC->IsPrinting())
  649. m_nLastWidth = -1;
  651. m_szBlockSize = CSize(li.nMaxWidth, li.y);
  652. };
  654. void CXTPMarkupTextBlock::InvalidateMeasureOverride(CXTPMarkupDrawingContext* pDC)
  655. {
  656. m_nLastWidth = -1;
  657. CXTPMarkupFrameworkElement::InvalidateMeasureOverride(pDC);
  658. }
  660. CSize CXTPMarkupTextBlock::MeasureOverride(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize)
  661. {
  662. CSize size3 = GetPadding()->Size();
  664. CSize availableSize(max(0, szAvailableSize.cx - size3.cx), max(0, szAvailableSize.cy - size3.cy));
  666. CalculateLines(pDC, availableSize.cx);
  668. return CSize(m_szBlockSize.cx + size3.cx, m_szBlockSize.cy + size3.cy);
  669. }
  671. CSize CXTPMarkupTextBlock::ArrangeOverride(CSize szFinalSize)
  672. {
  673. CXTPMarkupThickness* pPadding = GetPadding();
  675. XTPMarkupTextAlignment textAlignment = GetTextAlignment();
  677. for (CLine* pLine = m_pLineList->GetHead(); pLine != NULL; pLine = pLine->m_pNextChain)
  678. {
  679. int xOffset = textAlignment == xtpMarkupTextAlignmentRight ? szFinalSize.cx - pLine->m_nWidth :
  680. textAlignment == xtpMarkupTextAlignmentCenter ? (szFinalSize.cx - pLine->m_nWidth) / 2 : 0;
  682. for (CLinePart* part = pLine->m_arrParts.GetHead(); part != NULL; part = part->m_pNextChain)
  683. {
  684. part->ptOffset = CPoint(pPadding->left + xOffset, pPadding->top + pLine->m_nHeight - part->size.cy);
  686. XTPMarkupBaselineAlignment baseline = part->pInline->GetBaselineAlignment();
  687. switch (baseline)
  688. {
  689. case xtpMarkupBaseline:
  690. part->ptOffset.y += part->nBaseline - pLine->m_nBaseline;
  691. break;
  692. case xtpMarkupBaselineSubscript:
  693. part->ptOffset.y += part->nBaseline - pLine->m_nBaseline / 2;
  694. break;
  696. case xtpMarkupBaselineSuperscript:
  697. part->ptOffset.y += part->size.cy - pLine->m_nHeight + pLine->m_nBaseline / 2 - part->nBaseline;
  698. break;
  700. case xtpMarkupBaselineBottom:
  701. case xtpMarkupBaselineTextBottom:
  702. break;
  704. case xtpMarkupBaselineTop:
  705. case xtpMarkupBaselineTextTop:
  706. part->ptOffset.y += part->size.cy - pLine->m_nHeight;
  707. break;
  709. case xtpMarkupBaselineCenter:
  710. part->ptOffset.y += (part->size.cy - pLine->m_nHeight) / 2;
  711. break;
  712. }
  714. CRect rc(part->ptTopLeft, part->size);
  715. rc.OffsetRect(part->ptOffset);
  717. part->pInline->Arrange(rc, part->posStart, part->posEnd);
  718. }
  719. }
  721. return szFinalSize;
  722. }
  724. void CXTPMarkupTextBlock::RenderTextDecorations(CXTPMarkupDrawingContext* pDC, CLinePart* part)
  725. {
  726. CXTPMarkupInt* pTextDecorations = (CXTPMarkupInt*)part->pInline->GetValue(CXTPMarkupTextBlock::m_pTextDecorationsProperty);
  727. if (!pTextDecorations || (int)*pTextDecorations == 0)
  728. return;
  730. CRect rc(part->ptTopLeft, part->size);
  731. rc.OffsetRect(part->ptOffset);
  733. int nTopDecoration = 0;
  735. if (*pTextDecorations == 1)
  736. nTopDecoration = rc.bottom - part->nBaseline + max(1, part->pLine->m_nBaseline / 3);
  737. else if (*pTextDecorations == 2)
  738. nTopDecoration = rc.bottom - part->nBaseline + part->pLine->m_nBaseline - (part->pLine->m_nHeight - part->pLine->m_nBaseline) / 2;
  740. CRect rcDecoration(rc.left, nTopDecoration, rc.right, nTopDecoration + max(1, part->pLine->m_nBaseline / 3));
  742. CXTPMarkupObject* pDecorationsOwner = part->pInline->GetValueSource(CXTPMarkupTextBlock::m_pTextDecorationsProperty);
  743. if (!pDecorationsOwner)
  744. {
  745. ASSERT(FALSE);
  746. return;
  747. }
  749. CXTPMarkupBrush* pDecorationsBrush = (CXTPMarkupBrush*)pDecorationsOwner->GetValue(CXTPMarkupTextBlock::m_pForegroundProperty);
  750. if (pDecorationsBrush)
  751. {
  752. pDC->DrawRectangle(pDecorationsBrush, rcDecoration);
  753. }
  754. else
  755. {
  756. CXTPMarkupSolidColorBrush brush(GetMarkupContext()->GetDefaultForeground());
  757. pDC->DrawRectangle(&brush, rcDecoration);
  758. }
  759. }
  761. void CXTPMarkupTextBlock::OnRender(CXTPMarkupDrawingContext* pDC)
  762. {
  763. CXTPMarkupBrush* pTextBackground = GetBackground();
  765. if (pTextBackground != NULL)
  766. {
  767. CRect rcRender(CPoint(0, 0), GetActualSize());
  768. pTextBackground->FillRect(pDC, rcRender);
  769. }
  771. RECT rcClipBox = pDC->GetClipBox(), rcIntersect;
  773. for (CLine* pLine = m_pLineList->GetHead(); pLine != NULL; pLine = pLine->m_pNextChain)
  774. {
  775. for (CLinePart* part = pLine->m_arrParts.GetHead(); part != NULL; part = part->m_pNextChain)
  776. {
  777. CRect rc(part->ptTopLeft, part->size);
  778. rc.OffsetRect(part->ptOffset);
  780. if (!IntersectRect(&rcIntersect, &rc, &rcClipBox))
  781. continue;
  783. CXTPMarkupBrush* pForeground = part->pInline->GetForeground();
  784. CXTPMarkupBrush* pBackground = part->pInline->GetBackground();
  786. if (pBackground != NULL && pBackground != pTextBackground)
  787. {
  788. pBackground->FillRect(pDC, rc);
  789. }
  791. ::SetTextColor(pDC->GetSafeHdc(), pForeground ? pForeground->GetHintColor() : m_pMarkupContext->GetDefaultForeground());
  793. part->pInline->Render(pDC, rc, part->posStart, part->posEnd);
  795. RenderTextDecorations(pDC, part);
  796. }
  797. }
  798. }
  800. void CXTPMarkupTextBlock::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  801. {
  802. m_pInlines->SetContentObject(pBuilder, pContent);
  803. }
  805. BOOL CXTPMarkupTextBlock::HasContentObject() const
  806. {
  807. return m_pInlines->HasContentObject();
  808. }
  810. BOOL CXTPMarkupTextBlock::AllowWhiteSpaceContent() const
  811. {
  812. return TRUE;
  813. }
  815. CXTPMarkupInputElement* CXTPMarkupTextBlock::InputHitTestOverride(CPoint point) const
  816. {
  817. for (CLine* pLine = m_pLineList->GetHead(); pLine != NULL; pLine = pLine->m_pNextChain)
  818. {
  819. for (CLinePart* part = pLine->m_arrParts.GetHead(); part != NULL; part = part->m_pNextChain)
  820. {
  821. CRect rc(part->ptTopLeft, part->size);
  822. rc.OffsetRect(part->ptOffset);
  824. if (rc.PtInRect(point))
  825. return part->pInline->InputHitTest(point);
  826. }
  827. }
  829. return (CXTPMarkupInputElement*)this;
  831. }