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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupShape.cpp：源码内容
  1. // XTPMarkupShape.cpp: implementation of the CXTPMarkupShape 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 <math.h>
  24. #include "XTPMarkupShape.h"
  25. #include "XTPMarkupDrawingContext.h"
  26. #include "XTPMarkupBuilder.h"
  28. #ifdef _DEBUG
  29. #undef THIS_FILE
  30. static char THIS_FILE[]=__FILE__;
  31. #define new DEBUG_NEW
  32. #endif
  34. //////////////////////////////////////////////////////////////////////////
  35. // CXTPMarkupShape
  38. CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pFillProperty = NULL;
  39. CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeProperty = NULL;
  40. CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStrokeThicknessProperty = NULL;
  41. CXTPMarkupDependencyProperty* CXTPMarkupShape::m_pStretchProperty = NULL;
  43. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupShape, CXTPMarkupFrameworkElement)
  45. void CXTPMarkupShape::RegisterMarkupClass()
  46. {
  47. m_pFillProperty = CXTPMarkupDependencyProperty::Register(L"Fill", MARKUP_TYPE(CXTPMarkupBrush), MARKUP_TYPE(CXTPMarkupShape),
  48. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
  50. m_pStrokeProperty = CXTPMarkupDependencyProperty::Register(L"Stroke", MARKUP_TYPE(CXTPMarkupBrush), MARKUP_TYPE(CXTPMarkupShape),
  51. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
  53. m_pStrokeThicknessProperty = CXTPMarkupDependencyProperty::Register(L"StrokeThickness", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupShape),
  54. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsRender));
  56. m_pStretchProperty = CXTPMarkupDependencyProperty::Register(L"Stretch", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupShape),
  57. new CXTPMarkupPropertyMetadata(CXTPMarkupEnum::CreateValue(xtpMarkupStretchNone), &CXTPMarkupBuilder::ConvertStretch, CXTPMarkupPropertyMetadata::flagAffectsRender));
  58. }
  60. CXTPMarkupShape::CXTPMarkupShape()
  61. {
  62. }
  64. CXTPMarkupShape::~CXTPMarkupShape()
  65. {
  67. }
  69. CXTPMarkupBrush* CXTPMarkupShape::GetFill() const
  70. {
  71. return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pFillProperty));
  72. }
  74. void CXTPMarkupShape::SetFill(CXTPMarkupBrush* brush)
  75. {
  76. SetValue(m_pFillProperty, brush);
  77. }
  79. CXTPMarkupBrush* CXTPMarkupShape::GetStroke() const
  80. {
  81. return MARKUP_STATICCAST(CXTPMarkupBrush, GetValue(m_pStrokeProperty));
  82. }
  84. void CXTPMarkupShape::SetStroke(CXTPMarkupBrush* brush)
  85. {
  86. SetValue(m_pStrokeProperty, brush);
  87. }
  89. //////////////////////////////////////////////////////////////////////////
  90. // CXTPMarkupPointCollection
  92. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupPointCollection, CXTPMarkupObject)
  94. void CXTPMarkupPointCollection::RegisterMarkupClass()
  95. {
  97. }
  99. CXTPMarkupPointCollection::CXTPMarkupPointCollection()
  100. {
  101. m_rcBounds.SetRectEmpty();
  102. }
  104. CXTPMarkupPointCollection::CXTPMarkupPointCollection(CPointArray& arr)
  105. {
  106. m_arrPoints.Copy(arr);
  108. m_rcBounds.SetRectEmpty();
  109. for (int i = 0; i < (int)m_arrPoints.GetSize(); i++)
  110. {
  111. POINT& pt = m_arrPoints[i];
  112. if (pt.x > m_rcBounds.right) m_rcBounds.right = pt.x;
  113. if (pt.y > m_rcBounds.bottom) m_rcBounds.bottom = pt.y;
  114. }
  115. }
  118. BOOL CXTPMarkupPointCollection::GetNextValue(LPCWSTR& lpszValue, int& nValue)
  119. {
  120. while (*lpszValue == ' ') lpszValue++;
  121. LPCWSTR lpszNext = lpszValue;
  123. nValue = 0;
  124. int nSign = 1;
  125. if (*lpszNext == '-')
  126. {
  127. nSign = -1;
  128. lpszNext++;
  129. }
  131. if (*lpszNext == 0)
  132. return FALSE;
  134. while (*lpszNext != 0)
  135. {
  136. WCHAR c = *lpszNext;
  138. if (c == ' ' || c == ',')
  139. {
  140. if (lpszNext == lpszValue)
  141. return FALSE;
  142. lpszNext++;
  143. break;
  144. }
  146. if (c <'0' || c > '9')
  147. return FALSE;
  149. nValue = 10 * nValue + (c - '0');
  151. lpszNext++;
  152. }
  154. lpszValue = lpszNext;
  155. nValue *= nSign;
  157. return TRUE;
  158. }
  160. BOOL CXTPMarkupPointCollection::ConvertFromString(LPCWSTR lpszValue, CXTPMarkupPointCollection::CPointArray& arr)
  161. {
  162. if (!lpszValue)
  163. return FALSE;
  165. while (*lpszValue != 0)
  166. {
  167. int x, y;
  168. if (!GetNextValue(lpszValue, x))
  169. return FALSE;
  171. if (!GetNextValue(lpszValue, y))
  172. return FALSE;
  174. while (*lpszValue == ' ') lpszValue++;
  176. POINT pt = {x, y};
  177. arr.Add(pt);
  178. }
  180. return TRUE;
  181. }
  183. CXTPMarkupObject* CXTPMarkupPointCollection::ConvertFrom(CXTPMarkupObject* pObject) const
  184. {
  185. if (IsStringObject(pObject))
  186. {
  187. CPointArray arr;
  188. if (ConvertFromString(*((CXTPMarkupString*)pObject), arr))
  189. {
  190. return new CXTPMarkupPointCollection(arr);
  191. }
  192. }
  194. return NULL;
  195. }
  198. //////////////////////////////////////////////////////////////////////////
  199. // CXTPMarkupPolygon
  202. CXTPMarkupDependencyProperty* CXTPMarkupPolygon::m_pPointsProperty = NULL;
  204. IMPLEMENT_MARKUPCLASS(L"Polygon", CXTPMarkupPolygon, CXTPMarkupShape)
  206. void CXTPMarkupPolygon::RegisterMarkupClass()
  207. {
  208. m_pPointsProperty = CXTPMarkupDependencyProperty::Register(L"Points", MARKUP_TYPE(CXTPMarkupPointCollection), MARKUP_TYPE(CXTPMarkupPolygon),
  209. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  211. }
  213. CXTPMarkupPolygon::CXTPMarkupPolygon()
  214. {
  215. }
  217. CXTPMarkupPolygon::~CXTPMarkupPolygon()
  218. {
  220. }
  222. void CXTPMarkupPolygon::SetPoints(CXTPMarkupPointCollection* pPoints)
  223. {
  224. SetValue(m_pPointsProperty, pPoints);
  225. }
  227. CXTPMarkupPointCollection* CXTPMarkupPolygon::GetPoints() const
  228. {
  229. return MARKUP_STATICCAST(CXTPMarkupPointCollection, GetValue(m_pPointsProperty));
  230. }
  232. CSize CXTPMarkupPolygon::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize /*szAvailableSize*/)
  233. {
  234. CXTPMarkupPointCollection* pPoints = GetPoints();
  235. if (!pPoints)
  236. return CSize(0, 0);
  238. return pPoints->GetBounds().Size();
  239. }
  241. void CXTPMarkupPolygon::OnRender(CXTPMarkupDrawingContext* pDC)
  242. {
  243. CXTPMarkupBrush* pStrokeBrush = GetStroke();
  244. CXTPMarkupBrush* pFillBrush = GetFill();
  246. if (!pStrokeBrush && !pFillBrush)
  247. return;
  249. CXTPMarkupPointCollection* pPoints = GetPoints();
  250. if (!pPoints)
  251. return;
  253. const CXTPMarkupPointCollection::CPointArray& arr = pPoints->GetPoints();
  255. int nStroke = pStrokeBrush ? GetStrokeThickness() : 0;
  257. CPen penStroke;
  258. if (nStroke > 0) penStroke.CreatePen(PS_SOLID, nStroke, pStrokeBrush->GetHintColor());
  260. CBrush brushFill;
  261. if (pFillBrush) brushFill.CreateSolidBrush(pFillBrush->GetHintColor());
  263. HGDIOBJ hOldPen = penStroke.GetSafeHandle() ? ::SelectObject(pDC->GetSafeHdc(), penStroke) : ::SelectObject(pDC->GetSafeHdc(), ::GetStockObject(NULL_PEN));
  264. HGDIOBJ hOldBrush = brushFill.GetSafeHandle() ? ::SelectObject(pDC->GetSafeHdc(), brushFill) : ::SelectObject(pDC->GetSafeHdc(), ::GetStockObject(NULL_BRUSH));
  266. ::Polygon(pDC->GetSafeHdc(), arr.GetData(), (int)arr.GetSize());
  268. if (hOldPen) ::SelectObject(pDC->GetSafeHdc(), hOldPen);
  269. if (hOldBrush) ::SelectObject(pDC->GetSafeHdc(), hOldBrush);
  270. }
  272. //////////////////////////////////////////////////////////////////////////
  273. // CXTPMarkupPolyline
  276. CXTPMarkupDependencyProperty* CXTPMarkupPolyline::m_pPointsProperty = NULL;
  278. IMPLEMENT_MARKUPCLASS(L"Polyline", CXTPMarkupPolyline, CXTPMarkupShape)
  280. void CXTPMarkupPolyline::RegisterMarkupClass()
  281. {
  282. m_pPointsProperty = CXTPMarkupDependencyProperty::Register(L"Points", MARKUP_TYPE(CXTPMarkupPointCollection), MARKUP_TYPE(CXTPMarkupPolyline),
  283. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  284. }
  286. CXTPMarkupPolyline::CXTPMarkupPolyline()
  287. {
  288. }
  290. CXTPMarkupPolyline::~CXTPMarkupPolyline()
  291. {
  293. }
  295. void CXTPMarkupPolyline::SetPoints(CXTPMarkupPointCollection* pPoints)
  296. {
  297. SetValue(m_pPointsProperty, pPoints);
  298. }
  300. CXTPMarkupPointCollection* CXTPMarkupPolyline::GetPoints() const
  301. {
  302. return MARKUP_STATICCAST(CXTPMarkupPointCollection, GetValue(m_pPointsProperty));
  303. }
  305. CSize CXTPMarkupPolyline::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize /*szAvailableSize*/)
  306. {
  307. CXTPMarkupPointCollection* pPoints = GetPoints();
  308. if (!pPoints)
  309. return CSize(0, 0);
  311. CSize sz = pPoints->GetBounds().Size();
  313. CXTPMarkupBrush* pStrokeBrush = GetStroke();
  314. int nStroke = pStrokeBrush ? GetStrokeThickness() : 0;
  316. sz.cx += nStroke;
  317. sz.cy += nStroke;
  319. return sz;
  320. }
  322. void CXTPMarkupPolyline::OnRender(CXTPMarkupDrawingContext* pDC)
  323. {
  324. CXTPMarkupBrush* pStrokeBrush = GetStroke();
  326. if (!pStrokeBrush)
  327. return;
  329. CXTPMarkupPointCollection* pPoints = GetPoints();
  330. if (!pPoints)
  331. return;
  333. const CXTPMarkupPointCollection::CPointArray& arr = pPoints->GetPoints();
  335. int nStroke = pStrokeBrush ? GetStrokeThickness() : 0;
  337. CPen penStroke;
  338. if (nStroke > 0) penStroke.CreatePen(PS_SOLID, nStroke, pStrokeBrush->GetHintColor());
  340. HGDIOBJ hOldPen = penStroke.GetSafeHandle() ? ::SelectObject(pDC->GetSafeHdc(), penStroke) : ::SelectObject(pDC->GetSafeHdc(), ::GetStockObject(NULL_PEN));
  342. if (GetStretch() != xtpMarkupStretchNone)
  343. {
  344. CXTPMarkupPointCollection::CPointArray arrStretch;
  345. arrStretch.Copy(arr);
  346. int nCount = (int)arrStretch.GetSize();
  348. CSize sz = GetRenderSize();
  349. CRect rc = pPoints->GetBounds();
  350. for (int i = 0; i < nCount; i++)
  351. {
  352. POINT& pt = arrStretch[i];
  353. if (rc.Width() != 0) pt.x = pt.x * sz.cx / rc.Width();
  354. if (rc.Height() != 0) pt.y = pt.y * sz.cy / rc.Height();
  355. }
  357. ::Polyline(pDC->GetSafeHdc(), arrStretch.GetData(), nCount);
  358. }
  359. else
  360. {
  361. ::Polyline(pDC->GetSafeHdc(), arr.GetData(), (int)arr.GetSize());
  362. }
  364. if (hOldPen) ::SelectObject(pDC->GetSafeHdc(), hOldPen);
  365. }
  370. //////////////////////////////////////////////////////////////////////////
  371. // CXTPMarkupRectangle
  373. IMPLEMENT_MARKUPCLASS(L"Rectangle", CXTPMarkupRectangle, CXTPMarkupShape)
  375. void CXTPMarkupRectangle::RegisterMarkupClass()
  376. {
  378. }
  380. CXTPMarkupRectangle::CXTPMarkupRectangle()
  381. {
  382. }
  384. CXTPMarkupRectangle::~CXTPMarkupRectangle()
  385. {
  387. }
  389. CSize CXTPMarkupRectangle::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize /*szAvailableSize*/)
  390. {
  391. return CSize(0, 0);
  392. }
  394. void CXTPMarkupRectangle::OnRender(CXTPMarkupDrawingContext* pDC)
  395. {
  396. CXTPMarkupBrush* pStrokeBrush = GetStroke();
  397. CXTPMarkupBrush* pFillBrush = GetFill();
  399. if (!pStrokeBrush && !pFillBrush)
  400. return;
  402. int nStroke = pStrokeBrush ? GetStrokeThickness() : 0;
  404. CRect rc(0, 0, GetRenderSize().cx, GetRenderSize().cy);
  405. if (rc.Width() == 0 || rc.Height() == 0)
  406. return;
  409. if (FALSE)
  410. {
  411. CPoint ptViewortOrg;
  412. GetViewportOrgEx(pDC->GetSafeHdc(), &ptViewortOrg);
  414. CRgn rgn;
  415. rgn.Attach(::CreateRoundRectRgn(ptViewortOrg.x, ptViewortOrg.y, ptViewortOrg.x + rc.Width(), ptViewortOrg.y + rc.Height(), 0, 0));
  417. ::ExtSelectClipRgn(pDC->GetSafeHdc(), rgn, RGN_AND);
  418. }
  420. if (pFillBrush) pFillBrush->FillRect(pDC, rc);
  422. if (nStroke > 0)
  423. {
  424. pStrokeBrush->FillRect(pDC, CRect(0, 0, nStroke, rc.bottom));
  425. pStrokeBrush->FillRect(pDC, CRect(rc.right - nStroke, 0, rc.right, rc.bottom));
  426. pStrokeBrush->FillRect(pDC, CRect(0, 0, rc.right, nStroke));
  427. pStrokeBrush->FillRect(pDC, CRect(0, rc.bottom - nStroke, rc.right, rc.bottom));
  429. }
  431. if (FALSE)
  432. {
  433. ::SelectClipRgn(pDC->GetSafeHdc(), 0);
  434. }
  435. }
  438. //////////////////////////////////////////////////////////////////////////
  439. // CXTPMarkupEllipse
  442. IMPLEMENT_MARKUPCLASS(L"Ellipse", CXTPMarkupEllipse, CXTPMarkupShape)
  444. void CXTPMarkupEllipse::RegisterMarkupClass()
  445. {
  447. }
  449. CXTPMarkupEllipse::CXTPMarkupEllipse()
  450. {
  451. }
  453. CXTPMarkupEllipse::~CXTPMarkupEllipse()
  454. {
  456. }
  458. CSize CXTPMarkupEllipse::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize /*szAvailableSize*/)
  459. {
  460. return CSize(0, 0);
  461. }
  463. void CXTPMarkupEllipse::OnRender(CXTPMarkupDrawingContext* pDC)
  464. {
  465. CXTPMarkupBrush* pStrokeBrush = GetStroke();
  466. CXTPMarkupBrush* pFillBrush = GetFill();
  468. if (!pStrokeBrush && !pFillBrush)
  469. return;
  471. int nStroke = pStrokeBrush ? GetStrokeThickness() : 0;
  473. CPen penStroke;
  474. if (nStroke > 0) penStroke.CreatePen(PS_SOLID, nStroke, pStrokeBrush->GetHintColor());
  476. CBrush brushFill;
  477. if (pFillBrush) brushFill.CreateSolidBrush(pFillBrush->GetHintColor());
  479. HGDIOBJ hOldPen = penStroke.GetSafeHandle() ? ::SelectObject(pDC->GetSafeHdc(), penStroke) : ::SelectObject(pDC->GetSafeHdc(), ::GetStockObject(NULL_PEN));
  480. HGDIOBJ hOldBrush = brushFill.GetSafeHandle() ? ::SelectObject(pDC->GetSafeHdc(), brushFill) : ::SelectObject(pDC->GetSafeHdc(), ::GetStockObject(NULL_BRUSH));
  482. ::Ellipse(pDC->GetSafeHdc(), 0, 0, GetRenderSize().cx, GetRenderSize().cy);
  484. if (hOldPen) ::SelectObject(pDC->GetSafeHdc(), hOldPen);
  485. if (hOldBrush) ::SelectObject(pDC->GetSafeHdc(), hOldBrush);
  486. }
  488. CXTPMarkupInputElement* CXTPMarkupEllipse::InputHitTestOverride(CPoint point) const
  489. {
  490. if (m_szRenderSize.cx < 1 || m_szRenderSize.cy < 1)
  491. return (CXTPMarkupInputElement*)this;
  493.    // Determine radii
  494. double a = m_szRenderSize.cx / 2;
  495. double b = m_szRenderSize.cy / 2;
  497. double x = point.x - a;
  498. double y = point.y - b;
  500. return ((x * x) / (a * a) + (y * y) / (b * b) <= 1) ? (CXTPMarkupInputElement*)this : NULL;
  501. }
  504. //////////////////////////////////////////////////////////////////////////
  505. //
  507. //////////////////////////////////////////////////////////////////////////
  508. // CXTPMarkupLine
  511. CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pX1Property = NULL;
  512. CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pY1Property = NULL;
  513. CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pX2Property = NULL;
  514. CXTPMarkupDependencyProperty* CXTPMarkupLine::m_pY2Property = NULL;
  517. IMPLEMENT_MARKUPCLASS(L"Line", CXTPMarkupLine, CXTPMarkupShape)
  519. void CXTPMarkupLine::RegisterMarkupClass()
  520. {
  521. m_pX1Property = CXTPMarkupDependencyProperty::Register(L"X1", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
  522. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  524. m_pY1Property = CXTPMarkupDependencyProperty::Register(L"Y1", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
  525. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  527. m_pX2Property = CXTPMarkupDependencyProperty::Register(L"X2", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
  528. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  530. m_pY2Property = CXTPMarkupDependencyProperty::Register(L"Y2", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupLine),
  531. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  532. }
  534. CXTPMarkupLine::CXTPMarkupLine()
  535. {
  536. }
  538. CXTPMarkupLine::~CXTPMarkupLine()
  539. {
  541. }
  543. int CXTPMarkupLine::GetX1() const
  544. {
  545. CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pX1Property));
  546. return pValue != NULL ? (int)*pValue : 0;
  547. }
  549. int CXTPMarkupLine::GetX2() const
  550. {
  551. CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pX2Property));
  552. return pValue != NULL ? (int)*pValue : 0;
  553. }
  555. int CXTPMarkupLine::GetY1() const
  556. {
  557. CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pY1Property));
  558. return pValue != NULL ? (int)*pValue : 0;
  559. }
  561. int CXTPMarkupLine::GetY2() const
  562. {
  563. CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pY2Property));
  564. return pValue != NULL ? (int)*pValue : 0;
  565. }
  567. CSize CXTPMarkupLine::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize /*szAvailableSize*/)
  568. {
  569. int x = max(GetX1(), GetX2());
  570. int y = max(GetY1(), GetY2());
  572. return CSize(x, y);
  573. }
  575. void CXTPMarkupLine::OnRender(CXTPMarkupDrawingContext* pDC)
  576. {
  577. CXTPMarkupBrush* pStrokeBrush = GetStroke();
  579. if (!pStrokeBrush)
  580. return;
  582. int x1 = GetX1();
  583. int x2 = GetX2();
  584. int y1 = GetY1();
  585. int y2 = GetY2();
  586. if (x1 == 0 && x2 == 0 && y1 == 0 && y2 == 0)
  587. return;
  589. int nStroke = GetStrokeThickness();
  590. if (nStroke == 0)
  591. return;
  593. CPen penStroke;
  594. penStroke.CreatePen(PS_SOLID, nStroke, pStrokeBrush->GetHintColor());
  596. HGDIOBJ hOldPen = penStroke.GetSafeHandle() ? ::SelectObject(pDC->GetSafeHdc(), penStroke) : ::SelectObject(pDC->GetSafeHdc(), ::GetStockObject(NULL_PEN));
  598. ::MoveToEx(pDC->GetSafeHdc(), x1, y1, NULL);
  599. ::LineTo(pDC->GetSafeHdc(), x2, y2);
  601. if (hOldPen) ::SelectObject(pDC->GetSafeHdc(), hOldPen);
  602. }
  604. CXTPMarkupInputElement* CXTPMarkupLine::InputHitTestOverride(CPoint point) const
  605. {
  606. if (!GetStroke())
  607. return NULL;
  609. int nStroke = GetStrokeThickness();
  610. if (nStroke == 0)
  611. return NULL;
  613. double x = GetX2() - GetX1();
  614. double y = GetY2() - GetY1();
  616. double xp = point.x - GetX1();
  617. double yp = point.y - GetY1();
  619. double s = (double)nStroke / 2.0;
  621. if (xp + s < min(x, 0) || xp - s > max(x, 0) || yp + s < min(y, 0) || yp - s > max(y, 0))
  622. return NULL;
  624. if (x == 0)
  625. return fabs(xp) <= s ? (CXTPMarkupInputElement*)this : NULL;
  627. double yStroke = fabs(s / cos(atan(y / x)));
  629. double y0 = y * xp / (double)x;
  631. return fabs(y0 - yp) <= yStroke ? (CXTPMarkupInputElement*)this : NULL;
  632. }