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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupDrawingContext.cpp：源码内容
  1. // XTPMarkupDrawingContext.cpp: implementation of the CXTPMarkupDrawingContext 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 "Common/XTPImageManager.h"
  25. #include "Common/XTPvc80Helpers.h"
  27. #include "XTPMarkupDrawingContext.h"
  28. #include "XTPMarkupContext.h"
  30. #ifdef _DEBUG
  31. #undef THIS_FILE
  32. static char THIS_FILE[]=__FILE__;
  33. #define new DEBUG_NEW
  34. #endif
  37. //////////////////////////////////////////////////////////////////////
  38. // Construction/Destruction
  39. //////////////////////////////////////////////////////////////////////
  41. CXTPMarkupDrawingContext::CXTPMarkupDrawingContext(HDC hDC)
  42. {
  43. m_hDC = hDC;
  44. m_bDeleteDC = FALSE;
  46. Init();
  47. }
  49. CXTPMarkupDrawingContext::CXTPMarkupDrawingContext()
  50. {
  51. m_hDC = CreateCompatibleDC(0);
  52. m_bDeleteDC = TRUE;
  54. Init();
  55. }
  58. void CXTPMarkupDrawingContext::Init()
  59. {
  60. m_hAttribDC = m_hDC;
  61. m_pSelectedFont = NULL;
  62. m_hOldFont = NULL;
  64. ::GetWindowExtEx(m_hDC, &m_sizeWinExt);
  65. ::GetViewportExtEx(m_hDC, &m_sizeVpExt);
  66. ::GetViewportOrgEx(m_hDC, &m_ptViewortOrg);
  68. m_rcClipBox.SetRectEmpty();
  69. ::GetClipBox(m_hDC, &m_rcClipBox);
  71. ::SetBkMode(m_hDC, TRANSPARENT);
  72. }
  74. CXTPMarkupDrawingContext::~CXTPMarkupDrawingContext()
  75. {
  76. SetFont(NULL);
  78. if (m_bDeleteDC)
  79. {
  80. DeleteDC(m_hDC);
  81. }
  82. }
  84. POINT CXTPMarkupDrawingContext::TranslatePoint(const POINT& ptVisualOffset) const
  85. {
  86. POINT pt;
  87. pt.x = MulDiv(ptVisualOffset.x, abs(m_sizeVpExt.cx), abs(m_sizeWinExt.cx));
  88. pt.y = MulDiv(ptVisualOffset.y, abs(m_sizeVpExt.cy), abs(m_sizeWinExt.cy));
  89. return pt;
  90. }
  93. HDC CXTPMarkupDrawingContext::Detach()
  94. {
  95. SetFont(NULL);
  97. HDC hDC = m_hDC;
  98. m_hDC = NULL;
  99. return hDC;
  100. }
  102. void CXTPMarkupDrawingContext::SetViewportOrg(const POINT& ptViewortOrg)
  103. {
  104. SetViewportOrgEx(m_hDC, ptViewortOrg.x, ptViewortOrg.y, NULL);
  105. }
  107. POINT CXTPMarkupDrawingContext::OffsetViewport(const POINT& ptVisualOffset)
  108. {
  109. POINT ptViewortOrg = m_ptViewortOrg;
  111. POINT pt = TranslatePoint(ptVisualOffset);
  113. m_ptViewortOrg.x += pt.x;
  114. m_ptViewortOrg.y += pt.y;
  116. ::SetViewportOrgEx(m_hDC, m_ptViewortOrg.x, m_ptViewortOrg.y, NULL);
  118. ::GetClipBox(m_hDC, &m_rcClipBox);
  120. return ptViewortOrg;
  121. }
  123. void CXTPMarkupDrawingContext::SetViewport(const POINT& ptViewortOrg)
  124. {
  125. m_ptViewortOrg = ptViewortOrg;
  127. ::SetViewportOrgEx(m_hDC, m_ptViewortOrg.x, m_ptViewortOrg.y, NULL);
  129. ::GetClipBox(m_hDC, &m_rcClipBox);
  130. }
  133. HRGN CXTPMarkupDrawingContext::SaveClipRegion()
  134. {
  135. HRGN hrgnClip = ::CreateRectRgn(0, 0, 0, 0);
  137. if (hrgnClip != NULL)
  138. {
  139. if (GetClipRgn(m_hDC, hrgnClip) != 1)
  140. {
  141. DeleteObject(hrgnClip);
  142. hrgnClip = (HRGN)-1;
  143. }
  144. }
  145. return hrgnClip;
  146. }
  148. void CXTPMarkupDrawingContext::IntersectClipRect(const RECT& rcLayoutClip)
  149. {
  150. ::IntersectClipRect(m_hDC, rcLayoutClip.left, rcLayoutClip.top, rcLayoutClip.right, rcLayoutClip.bottom);
  151. ::GetClipBox(m_hDC, m_rcClipBox);
  152. }
  154. void CXTPMarkupDrawingContext::RestoreClipRegion(HRGN hrgnClip)
  155. {
  156. if (hrgnClip != NULL)
  157. {
  158. if (hrgnClip == (HRGN)-1)
  159. {
  160. ExtSelectClipRgn(m_hDC, NULL, RGN_COPY);
  161. }
  162. else
  163. {
  164. ExtSelectClipRgn(m_hDC, hrgnClip, RGN_COPY);
  165. DeleteObject(hrgnClip);
  166. }
  168. ::GetClipBox(m_hDC, m_rcClipBox);
  169. }
  170. }
  173. void CXTPMarkupDrawingContext::FillSolidRect(CRect rc, COLORREF clr)
  174. {
  175. CXTPMarkupSolidColorBrush brush(clr);
  176. brush.FillRect(this, rc);
  178. }
  179. void CXTPMarkupDrawingContext::DrawRectangle(CXTPMarkupBrush* pBrush, CRect rc)
  180. {
  181. pBrush->FillRect(this, rc);
  182. }
  184. void CXTPMarkupDrawingContext::DrawFrame(CXTPMarkupBrush* pBrush, CRect rc)
  185. {
  186. pBrush->FillRect(this, CRect(rc.left, rc.top, rc.right, rc.top + 1));
  187. pBrush->FillRect(this, CRect(rc.left, rc.top, rc.left + 1, rc.bottom));
  188. pBrush->FillRect(this, CRect(rc.left, rc.bottom - 1, rc.right, rc.bottom));
  189. pBrush->FillRect(this, CRect(rc.right - 1, rc.top, rc.right, rc.bottom));
  190. }
  192. void CXTPMarkupDrawingContext::DrawTextLine(LPCWSTR lpszText, UINT nCount, LPCRECT lpRect)
  193. {
  194. ::ExtTextOutW(m_hDC, lpRect->left, lpRect->top, 0, lpRect, lpszText, nCount, 0);
  195. }
  197. void CXTPMarkupDrawingContext::SetFont(CXTPMarkupFont* pFont)
  198. {
  199. if (!m_hDC)
  200. return;
  202. if (m_pSelectedFont == pFont)
  203. return;
  205. if (pFont == NULL && m_hOldFont)
  206. {
  207. SelectFontObject(m_hOldFont);
  208. m_hOldFont = NULL;
  209. }
  210. else if (pFont != NULL && m_hOldFont == NULL)
  211. {
  212. m_hOldFont = SelectFontObject(pFont->m_hFont);
  213. }
  214. else if (pFont != NULL)
  215. {
  216. SelectFontObject(pFont->m_hFont);
  217. }
  219. MARKUP_RELEASE(m_pSelectedFont);
  220. m_pSelectedFont = pFont;
  221. MARKUP_ADDREF(m_pSelectedFont);
  222. }
  224. SIZE CXTPMarkupDrawingContext::GetTextExtent(LPCWSTR lpszText, int nCount) const
  225. {
  226. SIZE sz;
  227. VERIFY(::GetTextExtentPoint32W(m_hAttribDC, lpszText, nCount, &sz));
  228. return sz;
  229. }
  232. HFONT CXTPMarkupDrawingContext::SelectFontObject(HFONT hFont)
  233. {
  234. HFONT hOldObj = 0;
  236. if (m_hDC != m_hAttribDC)
  237. hOldObj = (HFONT)::SelectObject(m_hDC, hFont);
  239. if (m_hAttribDC != NULL)
  240. hOldObj = (HFONT)::SelectObject(m_hAttribDC, hFont);
  242. return hOldObj;
  243. }
  245. CXTPMarkupPrintingContext::CXTPMarkupPrintingContext(HDC hDC, HDC hAttribDC)
  246. : CXTPMarkupDrawingContext(hDC)
  247. {
  248. m_hAttribDC = hAttribDC;
  249. }
  251. void CXTPMarkupPrintingContext::DrawTextLine(LPCWSTR lpszString, UINT nCount, LPCRECT lpRect)
  252. {
  253. if (m_hAttribDC == m_hDC)
  254. {
  255. ::ExtTextOutW(m_hDC, lpRect->left, lpRect->top, 0, lpRect, lpszString, nCount, 0);
  256. return;
  257. }
  259. LPINT lpDxWidths = NULL;
  261. ASSERT(m_hDC != NULL);
  262. ASSERT(m_hAttribDC != NULL);
  263. ASSERT(lpszString != NULL);
  264. ASSERT(lpDxWidths == NULL ||
  265. AfxIsValidAddress(lpDxWidths, sizeof(int) * nCount, FALSE));
  266. ASSERT(AfxIsValidAddress(lpszString, nCount, FALSE));
  268. int* pDeltas = NULL;
  269. LPWSTR pOutputString = NULL;
  270. int nRightFixup = 0;
  272. if (nCount == 0)    // Do nothing
  273. return;
  275. pDeltas = new int[nCount];
  276. pOutputString = new WCHAR[nCount];
  278. int x = lpRect->left;
  280. ComputeDeltas(x, (LPWSTR)lpszString, nCount, FALSE, 0, NULL, 0,
  281. pOutputString, pDeltas, nRightFixup);
  283. lpDxWidths = pDeltas;
  284. lpszString = pOutputString;
  286. ::ExtTextOutW(m_hDC, x, lpRect->top, 0, lpRect, lpszString, nCount, lpDxWidths);
  288. delete[] pDeltas;
  289. delete[] pOutputString;
  290. }
  292. int CXTPMarkupPrintingContext::ComputeNextTab(int x, UINT nTabStops, LPINT lpnTabStops,
  293. int nTabOrigin, int nTabWidth) const
  294. {
  295. x -= nTabOrigin;        // normalize position to tab origin
  296. for (UINT i = 0; i < nTabStops; i++, lpnTabStops++)
  297. {
  298. if (*lpnTabStops > x)
  299. return *lpnTabStops + nTabOrigin;
  300. }
  301. return (x / nTabWidth + 1) * nTabWidth + nTabOrigin;
  302. }
  304. CSize CXTPMarkupPrintingContext::ComputeDeltas(int& x, LPCWSTR lpszString, UINT &nCount,
  305. BOOL bTabbed, UINT nTabStops, LPINT lpnTabStops, int nTabOrigin,
  306. LPWSTR lpszOutputString, int* pnDxWidths, int& nRightFixup) const
  307. {
  308. TEXTMETRIC tmAttrib;
  309. TEXTMETRIC tmScreen;
  310. ::GetTextMetrics(m_hAttribDC, &tmAttrib);
  311. ::GetTextMetrics(m_hDC, &tmScreen);
  313. CSize sizeExtent;
  314. ::GetTextExtentPoint32A(m_hAttribDC, "A", 1, &sizeExtent);
  316. CPoint ptCurrent;
  317. UINT nAlignment = ::GetTextAlign(m_hAttribDC);
  318. BOOL bUpdateCP = (nAlignment & TA_UPDATECP) != 0;
  319. if (bUpdateCP)
  320. {
  321. ::GetCurrentPositionEx(m_hDC, &ptCurrent);
  322. x = ptCurrent.x;
  323. }
  325. LPCWSTR lpszCurChar = lpszString;
  326. LPCWSTR lpszStartRun = lpszString;
  327. int* pnCurDelta = pnDxWidths;
  328. int nStartRunPos = x;
  329. int nCurrentPos = x;
  330. int nStartOffset = 0;
  332. int nTabWidth = 0;
  333. if (bTabbed)
  334. {
  335. if (nTabStops == 1)
  336. {
  337. nTabWidth = lpnTabStops[0];
  338. }
  339. else
  340. {
  341. // Get default size of a tab
  342. nTabWidth = LOWORD(::GetTabbedTextExtentA(m_hAttribDC,
  343. "t", 1, 0, NULL));
  344. }
  345. }
  347. for (UINT i = 0; i < nCount; i++)
  348. {
  349. BOOL bSpace = ((_TUCHAR)*lpszCurChar == (_TUCHAR)tmAttrib.tmBreakChar);
  350. if (bSpace || (bTabbed && *lpszCurChar == 't'))
  351. {
  352. // bSpace will be either TRUE (==1) or FALSE (==0).  For spaces
  353. // we want the space included in the GetTextExtent, for tabs we
  354. // do not want the tab included
  355. int nRunLength = (int)(lpszCurChar - lpszStartRun) + (bSpace ? 1 : 0);
  357. CSize sizeExtent2;
  358. ::GetTextExtentPoint32W(m_hAttribDC, lpszStartRun, nRunLength,
  359. &sizeExtent2);
  360. int nNewPos = nStartRunPos + sizeExtent2.cx
  361. - tmAttrib.tmOverhang;
  363. // now, if this is a Tab (!bSpace), compute the next tab stop
  364. if (!bSpace)
  365. {
  366. nNewPos = ComputeNextTab(nNewPos, nTabStops, lpnTabStops,
  367. nTabOrigin, nTabWidth);
  368. }
  370. // Add this width to previous width
  371. if (pnCurDelta == pnDxWidths)
  372. nStartOffset += nNewPos - nCurrentPos;
  373. else
  374. *(pnCurDelta-1) += nNewPos - nCurrentPos;
  376. nCurrentPos = nNewPos;
  378. nStartRunPos = nCurrentPos;     // set start of run
  379. // *lpszCurChar must be SBC: tmBreakChar or 't'
  380. lpszStartRun = lpszCurChar + 1;
  381. }
  382. else
  383. {
  384. // For the non-tabbed or non-tab-character case
  385. int cxScreen;
  386. if (_istlead(*lpszCurChar))
  387. {
  388. cxScreen = tmScreen.tmAveCharWidth;
  389. *pnCurDelta = tmAttrib.tmAveCharWidth;
  390. }
  391. else
  392. {
  393. ::GetCharWidth(m_hDC, (_TUCHAR)*lpszCurChar,
  394. (_TUCHAR)*lpszCurChar, &cxScreen);
  395. if (!::GetCharWidth(m_hAttribDC, (_TUCHAR)*lpszCurChar,
  396. (_TUCHAR)*lpszCurChar, pnCurDelta))
  397. {
  398. // If printer driver fails the above call, use the average width
  399. *pnCurDelta = tmAttrib.tmAveCharWidth;
  400. }
  401. }
  402. *pnCurDelta -= tmAttrib.tmOverhang;
  403. cxScreen -= tmScreen.tmOverhang;
  404. nCurrentPos += *pnCurDelta;     // update current position
  406. // Center character in allotted space
  407. if (pnCurDelta != pnDxWidths)
  408. {
  409. int diff = (*pnCurDelta - cxScreen) / 2;
  410. *pnCurDelta -= diff;
  411. *(pnCurDelta - 1) += diff;
  412. }
  413. *lpszOutputString++ = *lpszCurChar;
  414. if (_istlead(*lpszCurChar))
  415. {
  416. *lpszOutputString++ = *(lpszCurChar+1); // copy trailing byte
  417. *(pnCurDelta + 1) = *pnCurDelta;        // double wide
  418. nCurrentPos += *pnCurDelta;
  419. pnCurDelta++;
  420. i++;
  421. }
  422. pnCurDelta++;
  423. }
  424. lpszCurChar++;
  425. }
  427. nAlignment &= TA_CENTER|TA_RIGHT;
  428. sizeExtent.cx = nCurrentPos - x;
  429. nRightFixup = 0;
  431. if (nAlignment == TA_LEFT)
  432. x += nStartOffset;      // Full left side adjustment
  433. else if (nAlignment == TA_CENTER)
  434. x += nStartOffset/2;    // Adjust Center by 1/2 left side adjustment
  435. else if (nAlignment == TA_RIGHT)
  436. nRightFixup = nStartOffset; // Right adjust needed later if TA_UPDATECP
  438. if (bUpdateCP)
  439. ::MoveToEx(m_hDC, x, ptCurrent.y, NULL);
  441. nCount = (UINT)(pnCurDelta - pnDxWidths);   // number of characters output
  442. return sizeExtent;
  443. }
  445. //////////////////////////////////////////////////////////////////////////
  446. // CXTPMarkupBrush
  448. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupBrush, CXTPMarkupObject);
  450. void CXTPMarkupBrush::RegisterMarkupClass()
  451. {
  453. }
  456. void CXTPMarkupBrush::FillRect(CXTPMarkupDrawingContext* /*pDC*/, CRect /*rc*/)
  457. {
  459. }
  461. COLORREF CXTPMarkupBrush::GetHintColor() const
  462. {
  463. return 0;
  464. }
  466. CXTPMarkupObject* CXTPMarkupBrush::ConvertFrom(CXTPMarkupObject* pObject) const
  467. {
  468. if (IsStringObject(pObject))
  469. {
  470. COLORREF clr;
  471. if (CXTPMarkupColor::ConvertFromString(*((CXTPMarkupString*)pObject), clr))
  472. {
  473. return new CXTPMarkupSolidColorBrush(clr);
  474. }
  475. }
  477. return NULL;
  478. }
  481. //////////////////////////////////////////////////////////////////////////
  482. // CXTPMarkupSolidColorBrush
  484. CXTPMarkupDependencyProperty* CXTPMarkupSolidColorBrush::m_pColorProperty = NULL;
  486. IMPLEMENT_MARKUPCLASS(L"SolidColorBrush", CXTPMarkupSolidColorBrush, CXTPMarkupBrush);
  488. void CXTPMarkupSolidColorBrush::RegisterMarkupClass()
  489. {
  490. m_pColorProperty = CXTPMarkupDependencyProperty::Register(L"Color", MARKUP_TYPE(CXTPMarkupColor), MARKUP_TYPE(CXTPMarkupSolidColorBrush));
  491. }
  493. CXTPMarkupSolidColorBrush::CXTPMarkupSolidColorBrush()
  494. {
  495. }
  497. CXTPMarkupSolidColorBrush::CXTPMarkupSolidColorBrush(COLORREF clr)
  498. {
  499. SetValue(m_pColorProperty, new CXTPMarkupColor(clr));
  500. }
  502. BOOL CXTPMarkupSolidColorBrush::IsEqual(const CXTPMarkupObject* pObject) const
  503. {
  504. if (!pObject)
  505. return FALSE;
  507. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupSolidColorBrush))
  508. return FALSE;
  510. return GetHintColor() == ((CXTPMarkupSolidColorBrush*)pObject)->GetHintColor();
  512. }
  514. void CXTPMarkupSolidColorBrush::FillRect(CXTPMarkupDrawingContext* pDC, CRect rc)
  515. {
  516. CXTPMarkupColor* pColor = MARKUP_STATICCAST(CXTPMarkupColor, GetValue(m_pColorProperty));
  518. if (pColor)
  519. {
  520. COLORREF clrOld = ::SetBkColor(pDC->GetSafeHdc(), *pColor);
  521. ::ExtTextOut(pDC->GetSafeHdc(), 0, 0, ETO_OPAQUE, rc, NULL, 0, NULL);
  522. ::SetBkColor(pDC->GetSafeHdc(), clrOld);
  523. }
  524. }
  526. COLORREF CXTPMarkupSolidColorBrush::GetHintColor() const
  527. {
  528. CXTPMarkupColor* pColor = MARKUP_STATICCAST(CXTPMarkupColor, GetValue(m_pColorProperty));
  530. if (pColor)
  531. {
  532. return *pColor;
  533. }
  535. return 0;
  536. }
  538. //////////////////////////////////////////////////////////////////////////
  539. // CXTPMarkupPoint
  541. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupPoint, CXTPMarkupObject);
  543. void CXTPMarkupPoint::RegisterMarkupClass()
  544. {
  546. }
  548. CXTPMarkupPoint::CXTPMarkupPoint()
  549. {
  550. x = 0;
  551. y = 0;
  552. }
  554. CXTPMarkupPoint::CXTPMarkupPoint(double x, double y)
  555. {
  556. this->x = x;
  557. this->y = y;
  558. }
  560. CXTPMarkupPoint& CXTPMarkupPoint::operator=(const CXTPMarkupPoint& srcPoint)
  561. {
  562. x = srcPoint.x;
  563. y = srcPoint.y;
  564. return *this;
  565. }
  567. CXTPMarkupObject* CXTPMarkupPoint::ConvertFrom(CXTPMarkupObject* pObject) const
  568. {
  569. if (IsStringObject(pObject))
  570. {
  571. LPCWSTR lpszValue = *(CXTPMarkupString*)pObject;
  573. float x = 0 , y = 0;
  574. if (WSCANF_S(lpszValue, L"%f,%f", &x, &y) != 2)
  575. return FALSE;
  577. return new CXTPMarkupPoint(x, y);
  578. }
  579. return FALSE;
  580. }
  583. //////////////////////////////////////////////////////////////////////////
  584. // CXTPMarkupGradientStop
  585. CXTPMarkupDependencyProperty* CXTPMarkupGradientStop::m_pColorProperty = NULL;
  586. CXTPMarkupDependencyProperty* CXTPMarkupGradientStop::m_pOffsetProperty = NULL;
  588. IMPLEMENT_MARKUPCLASS(L"GradientStop", CXTPMarkupGradientStop, CXTPMarkupObject);
  590. void CXTPMarkupGradientStop::RegisterMarkupClass()
  591. {
  592. m_pColorProperty = CXTPMarkupDependencyProperty::Register(L"Color", MARKUP_TYPE(CXTPMarkupColor), MARKUP_TYPE(CXTPMarkupGradientStop));
  593. m_pOffsetProperty = CXTPMarkupDependencyProperty::Register(L"Offset", MARKUP_TYPE(CXTPMarkupDouble), MARKUP_TYPE(CXTPMarkupGradientStop));
  594. }
  596. CXTPMarkupGradientStop::CXTPMarkupGradientStop()
  597. {
  599. }
  601. CXTPMarkupGradientStop::CXTPMarkupGradientStop(COLORREF clr, double dOffset)
  602. {
  603. SetValue(m_pColorProperty, new CXTPMarkupColor(clr));
  604. SetValue(m_pOffsetProperty, new CXTPMarkupDouble(dOffset));
  605. }
  607. COLORREF CXTPMarkupGradientStop::GetColor() const
  608. {
  609. CXTPMarkupColor* pColor = MARKUP_STATICCAST(CXTPMarkupColor, GetValue(m_pColorProperty));
  610. return pColor != NULL ? (COLORREF)*pColor : 0;
  611. }
  613. double CXTPMarkupGradientStop::GetOffset() const
  614. {
  615. CXTPMarkupDouble* pOffset = MARKUP_STATICCAST(CXTPMarkupDouble, GetValue(m_pOffsetProperty));
  616. return pOffset != NULL ? (double)*pOffset : 0.0;
  618. }
  622. CXTPMarkupGradientStops::CXTPMarkupGradientStops()
  623. {
  624. m_pElementType = MARKUP_TYPE(CXTPMarkupGradientStop);
  625. }
  627. //////////////////////////////////////////////////////////////////////////
  628. // CXTPMarkupLinearGradientBrush
  630. CXTPMarkupDependencyProperty* CXTPMarkupLinearGradientBrush::m_pStartPointProperty = NULL;
  631. CXTPMarkupDependencyProperty* CXTPMarkupLinearGradientBrush::m_pEndPointProperty = NULL;
  633. IMPLEMENT_MARKUPCLASS(L"LinearGradientBrush", CXTPMarkupLinearGradientBrush, CXTPMarkupBrush);
  635. void CXTPMarkupLinearGradientBrush::RegisterMarkupClass()
  636. {
  637. m_pStartPointProperty = CXTPMarkupDependencyProperty::Register(L"StartPoint", MARKUP_TYPE(CXTPMarkupPoint), MARKUP_TYPE(CXTPMarkupLinearGradientBrush));
  638. m_pEndPointProperty = CXTPMarkupDependencyProperty::Register(L"EndPoint", MARKUP_TYPE(CXTPMarkupPoint), MARKUP_TYPE(CXTPMarkupLinearGradientBrush));
  639. }
  642. CXTPMarkupLinearGradientBrush::CXTPMarkupLinearGradientBrush()
  643. {
  644. m_pGradientStops = new CXTPMarkupGradientStops();
  645. }
  647. CXTPMarkupLinearGradientBrush::CXTPMarkupLinearGradientBrush(CXTPMarkupGradientStops* pGradientStops)
  648. {
  649. m_pGradientStops = pGradientStops;
  650. }
  652. CXTPMarkupLinearGradientBrush::~CXTPMarkupLinearGradientBrush()
  653. {
  654. MARKUP_RELEASE(m_pGradientStops);
  655. }
  657. void CXTPMarkupLinearGradientBrush::SetStartPoint(double x, double y)
  658. {
  659. SetValue(m_pStartPointProperty, new CXTPMarkupPoint(x, y));
  660. }
  662. void CXTPMarkupLinearGradientBrush::SetEndPoint(double x, double y)
  663. {
  664. SetValue(m_pEndPointProperty, new CXTPMarkupPoint(x, y));
  665. }
  667. void CXTPMarkupLinearGradientBrush::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  668. {
  669. m_pGradientStops->SetContentObject(pBuilder, pContent);
  670. }
  672. int _cdecl CXTPMarkupLinearGradientBrush::_GradientStopCompare(const void *arg1, const void *arg2)
  673. {
  674. double& dOffset1 = ((GRADIENTSTOP*)arg1)->dOffset;
  675. double& dOffset2 = ((GRADIENTSTOP*)arg2)->dOffset;
  677. return dOffset1 > dOffset2 ? 1 : dOffset1 < dOffset2 ? -1 : ((GRADIENTSTOP*)arg1)->nIndex - ((GRADIENTSTOP*)arg2)->nIndex;
  678. };
  680. void CXTPMarkupLinearGradientBrush::FillRect(CXTPMarkupDrawingContext* pDC , CRect rc)
  681. {
  682. HDC hDC = pDC->GetSafeHdc();
  683. int cx = rc.Width();
  684. int cy = rc.Height();
  686. if (m_pGradientStops->GetCount() == 0)
  687. return;
  689. if (cx <= 0 || cy <= 0)
  690. return;
  692. if (m_pGradientStops->GetCount() == 1)
  693. {
  694. COLORREF clr = m_pGradientStops->GetItem(0)->GetColor();
  695. COLORREF clrOld = ::SetBkColor(hDC, clr);
  696. ::ExtTextOut(hDC, 0, 0, ETO_OPAQUE, rc, NULL, 0, NULL);
  697. ::SetBkColor(hDC, clrOld);
  698. return;
  699. }
  701. CXTPMarkupPoint ptStartPoint(0, 0);
  702. if (GetValue(m_pStartPointProperty)) ptStartPoint =  *MARKUP_STATICCAST(CXTPMarkupPoint, GetValue(m_pStartPointProperty));
  704. CXTPMarkupPoint ptEndPoint(1, 1);
  705. if (GetValue(m_pEndPointProperty)) ptEndPoint =  *MARKUP_STATICCAST(CXTPMarkupPoint, GetValue(m_pEndPointProperty));
  707. ptStartPoint.x *= cx;
  708. ptStartPoint.y *= cy;
  710. ptEndPoint.x *= cx;
  711. ptEndPoint.y *= cy;
  713. BOOL bHorizontal = ptStartPoint.y == ptEndPoint.y;
  714. BOOL bVertical = ptStartPoint.x == ptEndPoint.x;
  716. if (bHorizontal && bVertical)
  717. return;
  719. CRect rcClipBox = pDC->GetClipBox();
  721. if (pDC->IsPrinting())
  722. rcClipBox.InflateRect(1, 1);
  724. rcClipBox.OffsetRect(-rc.TopLeft());
  726. if (!rcClipBox.IntersectRect(&rcClipBox, CRect(0, 0, cx, cy)))
  727. return;
  729. LPDWORD lpBits;
  730. HBITMAP hBitmap = CXTPImageManager::Create32BPPDIBSection(0, cx, cy, (LPBYTE*)&lpBits);
  733. int nCount = m_pGradientStops->GetCount();
  734. GRADIENTSTOP* pStops = new GRADIENTSTOP[nCount];
  736. for (int i = 0; i < nCount; i++)
  737. {
  738. CXTPMarkupGradientStop* pItem = m_pGradientStops->GetItem(i);
  740. COLORREF clr = pItem->GetColor();
  741. pStops[i].clr.rgbRed = GetRValue(clr);
  742. pStops[i].clr.rgbGreen = GetGValue(clr);
  743. pStops[i].clr.rgbBlue = GetBValue(clr);
  744. pStops[i].clr.rgbReserved = 0;
  745. pStops[i].dOffset = pItem->GetOffset();
  746. pStops[i].nIndex = i;
  747. }
  749. GRADIENTSTOP *pStopFirst = pStops, *pStopLast = pStops + nCount - 1, *pStop;
  751. qsort(pStopFirst, nCount, sizeof(GRADIENTSTOP), _GradientStopCompare);
  753. for (pStop = pStopFirst + 1; pStop <= pStopLast; pStop++)
  754. {
  755. pStop->dDiff = pStop->dOffset - (pStop - 1)->dOffset;
  756. }
  758. CXTPMarkupPoint ptCenter((double)cx / 2, (double)cy /2);
  760. double len = sqrt(pow(ptStartPoint.x - ptEndPoint.x, 2) + pow(ptStartPoint.y - ptEndPoint.y, 2));
  761. double cosA = (ptEndPoint.x - ptStartPoint.x) / len;
  762. double sinA = (ptEndPoint.y - ptStartPoint.y) / len;
  764. double dDiff = - ptCenter.x * cosA  - ptCenter.y * sinA + ptCenter.x;
  765. double dStart = ptStartPoint.x * cosA + ptStartPoint.y * sinA + dDiff;
  766. double dEnd = ptEndPoint.x * cosA + ptEndPoint.y * sinA + dDiff;
  768. LPDWORD lpPixel = lpBits;
  770. double fDist = 1.0 / (dEnd - dStart);
  771. cosA = cosA * fDist;
  772. sinA = sinA * fDist;
  773. dDiff = (dDiff - dStart) * fDist;
  775. if (bVertical)
  776. {
  777. lpPixel += (cy - rcClipBox.bottom) * cx;
  779. for (int y = (cy - rcClipBox.bottom); y < (cy - rcClipBox.top); y++)
  780. {
  781. double fAmount = double(cy - y) * sinA + dDiff;
  783. DWORD dwPixel = 0;
  785. if (fAmount <= pStopFirst->dOffset)
  786. {
  787. dwPixel =  *((LPDWORD)&pStopFirst->clr);
  788. }
  789. else if(fAmount >= pStopLast->dOffset)
  790. {
  791. dwPixel =  *((LPDWORD)&pStopLast->clr);
  792. }
  793. else for (pStop = pStopFirst + 1; pStop <= pStopLast; pStop++)
  794. {
  795. if (fAmount < pStop->dOffset && pStop->dDiff != 0)
  796. {
  797. const RGBQUAD& clrFrom = (pStop - 1)->clr;
  798. const RGBQUAD& clrTo = pStop->clr;
  800. double fAmountA = (pStop->dOffset - fAmount) / pStop->dDiff;
  801. double fAmountB = (1.0 - fAmountA);
  803. ((LPBYTE)&dwPixel)[2] = (BYTE)(clrFrom.rgbRed * fAmountA + clrTo.rgbRed * fAmountB);
  804. ((LPBYTE)&dwPixel)[1] = (BYTE)(clrFrom.rgbGreen * fAmountA + clrTo.rgbGreen * fAmountB);
  805. ((LPBYTE)&dwPixel)[0] = (BYTE)(clrFrom.rgbBlue * fAmountA + clrTo.rgbBlue * fAmountB);
  806. break;
  807. }
  808. }
  810. for (int x = 0; x < cx; x++)
  811. {
  812. *lpPixel = dwPixel;
  813. lpPixel++;
  814. }
  815. }
  817. }
  818. else if (bHorizontal)
  819. {
  820. dDiff += double(cy) * sinA;
  822. lpPixel += rcClipBox.left;
  824. for (int x = rcClipBox.left; x < rcClipBox.right; x++)
  825. {
  826. double fAmount = (double)x * cosA + dDiff;
  828. if (fAmount <= pStopFirst->dOffset)
  829. {
  830. *lpPixel =  *((LPDWORD)&pStopFirst->clr);
  831. }
  832. else if(fAmount >= pStopLast->dOffset)
  833. {
  834. *lpPixel =  *((LPDWORD)&pStopLast->clr);
  835. }
  836. else for (pStop = pStopFirst + 1; pStop <= pStopLast; pStop++)
  837. {
  838. if (fAmount < pStop->dOffset && pStop->dDiff != 0)
  839. {
  840. const RGBQUAD& clrFrom = (pStop - 1)->clr;
  841. const RGBQUAD& clrTo = pStop->clr;
  843. double fAmountA = (pStop->dOffset - fAmount) / pStop->dDiff;
  844. double fAmountB = (1.0 - fAmountA);
  846. ((LPBYTE)lpPixel)[2] = (BYTE)(clrFrom.rgbRed * fAmountA + clrTo.rgbRed * fAmountB);
  847. ((LPBYTE)lpPixel)[1] = (BYTE)(clrFrom.rgbGreen * fAmountA + clrTo.rgbGreen * fAmountB);
  848. ((LPBYTE)lpPixel)[0] = (BYTE)(clrFrom.rgbBlue * fAmountA + clrTo.rgbBlue * fAmountB);
  849. break;
  850. }
  851. }
  853. lpPixel++;
  854. }
  856. lpPixel += (cx - rcClipBox.right);
  858. int y = max(1, cy - rcClipBox.bottom);
  860. if (y > 1)
  861. {
  862. lpPixel += cx * (cy - rcClipBox.bottom - 1);
  863. }
  865. for (; y < (cy - rcClipBox.top); y++)
  866. {
  867. memcpy(lpPixel, lpBits, sizeof(DWORD) * cx);
  868. lpPixel += cx;
  869. }
  870. }
  871. else
  872. {
  873. lpPixel += (cy - rcClipBox.bottom) * cx;
  875. for (int y = (cy - rcClipBox.bottom); y < (cy - rcClipBox.top); y++)
  876. {
  877. lpPixel += rcClipBox.left;
  879. for (int x = rcClipBox.left; x < rcClipBox.right; x++)
  880. {
  881. double fAmount = (double)x * cosA + double(cy - y) * sinA + dDiff;
  883. if (fAmount <= pStopFirst->dOffset)
  884. {
  885. *lpPixel =  *((LPDWORD)&pStopFirst->clr);
  886. }
  887. else if(fAmount >= pStopLast->dOffset)
  888. {
  889. *lpPixel =  *((LPDWORD)&pStopLast->clr);
  890. }
  891. else for (pStop = pStopFirst + 1; pStop <= pStopLast; pStop++)
  892. {
  893. if (fAmount < pStop->dOffset && pStop->dDiff != 0)
  894. {
  895. const RGBQUAD& clrFrom = (pStop - 1)->clr;
  896. const RGBQUAD& clrTo = pStop->clr;
  898. double fAmountA = (pStop->dOffset - fAmount) / pStop->dDiff;
  899. double fAmountB = (1.0 - fAmountA);
  901. ((LPBYTE)lpPixel)[2] = (BYTE)(clrFrom.rgbRed * fAmountA + clrTo.rgbRed * fAmountB);
  902. ((LPBYTE)lpPixel)[1] = (BYTE)(clrFrom.rgbGreen * fAmountA + clrTo.rgbGreen * fAmountB);
  903. ((LPBYTE)lpPixel)[0] = (BYTE)(clrFrom.rgbBlue * fAmountA + clrTo.rgbBlue * fAmountB);
  904. break;
  905. }
  906. }
  908. lpPixel++;
  909. }
  911. lpPixel += (cx - rcClipBox.right);
  912. }
  913. }
  915. HDC hBitmapDC = ::CreateCompatibleDC(hDC);
  917. HBITMAP hOldBitmap = (HBITMAP)SelectObject(hBitmapDC, hBitmap);
  919. BitBlt(hDC, rc.left + rcClipBox.left, rc.top + rcClipBox.top, rcClipBox.Width(), rcClipBox.Height(), hBitmapDC, rcClipBox.left, rcClipBox.top, SRCCOPY);
  921. SelectObject(hBitmapDC, hOldBitmap);
  922. DeleteDC(hBitmapDC);
  924. DeleteObject(hBitmap);
  925. delete[] pStops;
  926. }