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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupFrameworkElement.cpp：源码内容
  1. // XTPMarkupFrameworkElement.cpp: implementation of the CXTPMarkupFrameworkElement 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 "XTPMarkupFrameworkElement.h"
  24. #include "XTPMarkupBuilder.h"
  25. #include "XTPMarkupResourceDictionary.h"
  27. #ifdef _DEBUG
  28. #undef THIS_FILE
  29. static char THIS_FILE[]=__FILE__;
  30. #define new DEBUG_NEW
  31. #endif
  34. //////////////////////////////////////////////////////////////////////////
  35. // CXTPMarkupFrameworkElement
  37. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pMarginProperty = NULL;
  38. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pHorizontalAlignmentProperty = NULL;
  39. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pVerticalAlignmentProperty = NULL;
  40. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pWidthProperty = NULL;
  41. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pHeightProperty = NULL;
  42. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pMinWidthProperty = NULL;
  43. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pMinHeightProperty = NULL;
  44. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pMaxWidthProperty = NULL;
  45. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pMaxHeightProperty = NULL;
  46. CXTPMarkupDependencyProperty* CXTPMarkupFrameworkElement::m_pTagProperty = NULL;
  48. //////////////////////////////////////////////////////////////////////
  49. // Construction/Destruction
  50. //////////////////////////////////////////////////////////////////////
  51. IMPLEMENT_MARKUPCLASS(L"FrameworkElement", CXTPMarkupFrameworkElement, CXTPMarkupUIElement)
  53. void CXTPMarkupFrameworkElement::RegisterMarkupClass()
  54. {
  55. CXTPMarkupStyle::RegisterType();
  57. m_pMarginProperty = CXTPMarkupDependencyProperty::Register(L"Margin", MARKUP_TYPE(CXTPMarkupThickness), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  58. new CXTPMarkupPropertyMetadata(CXTPMarkupThickness::CreateValue(), CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  60. m_pHorizontalAlignmentProperty = CXTPMarkupDependencyProperty::Register(L"HorizontalAlignment", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  61. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertHorizontalAlignment, CXTPMarkupPropertyMetadata::flagAffectsArrange));
  63. m_pVerticalAlignmentProperty = CXTPMarkupDependencyProperty::Register(L"VerticalAlignment", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  64. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertVerticalAlignment, CXTPMarkupPropertyMetadata::flagAffectsArrange));
  66. m_pWidthProperty = CXTPMarkupDependencyProperty::Register(L"Width", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  67. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  69. m_pHeightProperty = CXTPMarkupDependencyProperty::Register(L"Height", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  70. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  72. m_pMinWidthProperty = CXTPMarkupDependencyProperty::Register(L"MinWidth", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  73. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  75. m_pMinHeightProperty = CXTPMarkupDependencyProperty::Register(L"MinHeight", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  76. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  78. m_pMaxWidthProperty = CXTPMarkupDependencyProperty::Register(L"MaxWidth", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  79. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  81. m_pMaxHeightProperty = CXTPMarkupDependencyProperty::Register(L"MaxHeight", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupFrameworkElement),
  82. new CXTPMarkupPropertyMetadata(NULL, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  84. m_pTagProperty = CXTPMarkupDependencyProperty::Register(L"Tag", MARKUP_TYPE(CXTPMarkupObject), MARKUP_TYPE(CXTPMarkupFrameworkElement));
  85. }
  87. CXTPMarkupFrameworkElement::CXTPMarkupFrameworkElement()
  88. {
  89. m_bNeedsClipBounds = FALSE;
  91. m_bUnclippedDesiredSize = FALSE;
  92. m_szUnclippedDesiredSize = CSize(0, 0);
  93. }
  95. CXTPMarkupFrameworkElement::~CXTPMarkupFrameworkElement()
  96. {
  97. }
  99. CXTPMarkupFrameworkElement::MINMAX::MINMAX()
  100. {
  101. nMaxHeight = nMaxWidth = INT_MAX;
  102. nMinWidth = nMinHeight = 0;
  103. }
  105. AFX_INLINE int InlineMin(int a, int b) {
  106. return a < b ? (a) : (b);
  107. }
  109. AFX_INLINE int InlineMax(int a, int b) {
  110. return a > b ? (a) : (b);
  111. }
  113. void CXTPMarkupFrameworkElement::MINMAX::Update(const CXTPMarkupFrameworkElement* pElement)
  114. {
  115. CXTPMarkupInt* pHeight = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(CXTPMarkupFrameworkElement::m_pHeightProperty));
  116. CXTPMarkupInt* pMinHeight = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(CXTPMarkupFrameworkElement::m_pMinHeightProperty));
  117. CXTPMarkupInt* pMaxHeight = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(CXTPMarkupFrameworkElement::m_pMaxHeightProperty));
  118. CXTPMarkupInt* pWidth = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(CXTPMarkupFrameworkElement::m_pWidthProperty));
  119. CXTPMarkupInt* pMinWidth = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(CXTPMarkupFrameworkElement::m_pMinWidthProperty));
  120. CXTPMarkupInt* pMaxWidth = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(CXTPMarkupFrameworkElement::m_pMaxWidthProperty));
  123. nMaxHeight = InlineMax(InlineMin(pHeight ? (int)*pHeight : INT_MAX, pMaxHeight ? (int)*pMaxHeight : INT_MAX), pMinHeight ? (int)*pMinHeight : 0);
  124. nMinHeight = InlineMax(InlineMin(nMaxHeight, pHeight ? (int)*pHeight : 0), pMinHeight ? (int)*pMinHeight : 0);
  126. nMaxWidth = InlineMax(InlineMin(pWidth ? (int)*pWidth : INT_MAX, pMaxWidth ? (int)*pMaxWidth : INT_MAX), pMinWidth ? (int)*pMinWidth : 0);
  127. nMinWidth = InlineMax(InlineMin(nMaxWidth, pWidth ? (int)*pWidth : 0), pMinWidth ? (int)*pMinWidth : 0);
  128. }
  132. inline int SafeSum(int a, int b)
  133. {
  134. if (a > INT_MAX / 2 || b > INT_MAX / 2)
  135. return INT_MAX;
  136. return a + b;
  137. }
  139. CSize CXTPMarkupFrameworkElement::MeasureCore(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize)
  140. {
  141. CXTPMarkupThickness* pMargin = GetMargin();
  143. long num = pMargin->left + pMargin->right;
  144. long num2 = pMargin->top + pMargin->bottom;
  146. CSize transformSpaceBounds = CSize(max(SafeSum(szAvailableSize.cx, -num), 0), max(SafeSum(szAvailableSize.cy, -num2), 0));
  148. m_mmBounds.Update(this);
  150. transformSpaceBounds.cx = max(m_mmBounds.nMinWidth, min(transformSpaceBounds.cx, m_mmBounds.nMaxWidth));
  151. transformSpaceBounds.cy = max(m_mmBounds.nMinHeight, min(transformSpaceBounds.cy, m_mmBounds.nMaxHeight));
  153. CSize size2 = MeasureOverride(pDC, transformSpaceBounds);
  154. size2 = CSize(max(size2.cx, m_mmBounds.nMinWidth), max(size2.cy, m_mmBounds.nMinHeight));
  155. CSize size = size2;
  157. BOOL fClip = FALSE;
  159. if (size2.cx > m_mmBounds.nMaxWidth)
  160. {
  161. size2.cx = m_mmBounds.nMaxWidth;
  162. fClip = TRUE;
  163. }
  165. if (size2.cy > m_mmBounds.nMaxHeight)
  166. {
  167. size2.cy = m_mmBounds.nMaxHeight;
  168. fClip = TRUE;
  169. }
  172. long width = size2.cx + num;
  173. long height = size2.cy + num2;
  175. if (width > szAvailableSize.cx)
  176. {
  177. width = szAvailableSize.cx;
  178. fClip = TRUE;
  179. }
  181. if (height > szAvailableSize.cy)
  182. {
  183. height = szAvailableSize.cy;
  184. fClip = TRUE;
  185. }
  187. m_bNeedsClipBounds = FALSE;
  188. m_bUnclippedDesiredSize = FALSE;
  190. if ((fClip || (width < 0)) || (height < 0))
  191. {
  192. m_bNeedsClipBounds = TRUE;
  194. m_bUnclippedDesiredSize = TRUE;
  195. m_szUnclippedDesiredSize = size;
  196. }
  198. return CSize(max(0, width), max(0, height));
  199. }
  201. BOOL CXTPMarkupFrameworkElement::GetClipToBounds() const
  202. {
  203. CXTPMarkupBool* pClipToBounds = MARKUP_STATICCAST(CXTPMarkupBool, GetValue(m_pClipToBoundsProperty));
  204. return pClipToBounds && (BOOL)*pClipToBounds;
  205. }
  207. BOOL CXTPMarkupFrameworkElement::GetLayoutClip(CRect& rc) const
  208. {
  209. if (CXTPMarkupUIElement::GetLayoutClip(rc))
  210. return TRUE;
  212. BOOL bClipToBounds = GetClipToBounds();
  214. if (!bClipToBounds && !m_bNeedsClipBounds)
  215. return FALSE;
  217. CSize szRenderSize = m_szRenderSize;
  219. int num = m_mmBounds.nMaxWidth == INT_MAX ? szRenderSize.cx : m_mmBounds.nMaxWidth;
  220. int num2 = m_mmBounds.nMaxHeight == INT_MAX ? szRenderSize.cy : m_mmBounds.nMaxHeight;
  221. BOOL bFlag = bClipToBounds ||num < szRenderSize.cx || num2 < szRenderSize.cy;
  222. szRenderSize = CSize(min(szRenderSize.cx, m_mmBounds.nMaxWidth), min(szRenderSize.cy, m_mmBounds.nMaxHeight));
  224. CXTPMarkupThickness* pMargin = GetMargin();
  226. long num3 = pMargin->left + pMargin->right;
  227. long num4 = pMargin->top + pMargin->bottom;
  229. CSize szClientSize  = CSize(max(m_rcFinalRect.Width() - num3, 0), max(m_rcFinalRect.Height() - num4, 0));
  230. BOOL bFlag2 = bClipToBounds || szClientSize.cx < szRenderSize.cx || szClientSize.cy < szRenderSize.cy;
  232. if (bFlag && !bFlag2)
  233. {
  234. rc = CRect(0, 0, num, num2);
  235. return TRUE;
  236. }
  238. if (!bFlag && !bFlag2)
  239. return FALSE;
  241. CPoint offset = ComputeAlignmentOffset(szClientSize, szRenderSize);
  243. rc = CRect(-offset, szClientSize);
  244. if (bFlag)
  245. {
  246. rc.IntersectRect(rc, CRect(0, 0, num, num2));
  247. }
  248. return TRUE;
  249. }
  251. CSize CXTPMarkupFrameworkElement::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize /*szAvailableSize*/)
  252. {
  253. return CSize(0, 0);
  254. }
  256. XTPMarkupHorizontalAlignment CXTPMarkupFrameworkElement::GetHorizontalAlignment() const
  257. {
  258. CXTPMarkupEnum* pAlign = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pHorizontalAlignmentProperty));
  259. return pAlign ? (XTPMarkupHorizontalAlignment)(int)(*pAlign) : xtpMarkupHorizontalAlignmentStretch;
  260. }
  262. XTPMarkupVerticalAlignment CXTPMarkupFrameworkElement::GetVerticalAlignment() const
  263. {
  264. CXTPMarkupEnum* pAlign = MARKUP_STATICCAST(CXTPMarkupEnum, GetValue(m_pVerticalAlignmentProperty));
  265. return pAlign ? (XTPMarkupVerticalAlignment)(int)(*pAlign) : xtpMarkupVerticalAlignmentStretch;
  266. }
  269. void CXTPMarkupFrameworkElement::ArrangeCore(CRect rcFinalRect)
  270. {
  271. CSize size = rcFinalRect.Size();
  273. CXTPMarkupThickness* pMargin = GetMargin();
  275. long num = pMargin->left +pMargin->right;
  276. long num2 = pMargin->top + pMargin->bottom;
  278. size.cx = max(0, (size.cx - num));
  279. size.cy = max(0, (size.cy - num2));
  281. CSize untransformedDS(0, 0);
  282. if (!m_bUnclippedDesiredSize)
  283. {
  284. untransformedDS = CSize(m_szDesiredSize.cx - num, m_szDesiredSize.cy - num2);
  285. }
  286. else
  287. {
  288. untransformedDS = m_szUnclippedDesiredSize;
  289. }
  291. if (size.cx < untransformedDS.cx)
  292. {
  293. m_bNeedsClipBounds = TRUE;
  294. size.cx = untransformedDS.cx;
  295. }
  297. if (size.cy < untransformedDS.cy)
  298. {
  299. m_bNeedsClipBounds = TRUE;
  300. size.cy = untransformedDS.cy;
  301. }
  303. if (GetHorizontalAlignment() != xtpMarkupHorizontalAlignmentStretch)
  304. {
  305. size.cx = untransformedDS.cx;
  306. }
  308. if (GetVerticalAlignment() != xtpMarkupVerticalAlignmentStretch)
  309. {
  310. size.cy = untransformedDS.cy;
  311. }
  313. long num3 = max(untransformedDS.cx, m_mmBounds.nMaxWidth);
  314. if (num3 < size.cx)
  315. {
  316. m_bNeedsClipBounds = TRUE;
  317. size.cx = num3;
  318. }
  320. long num4 = max(untransformedDS.cy, m_mmBounds.nMaxHeight);
  321. if (num4 < size.cy)
  322. {
  323. m_bNeedsClipBounds = TRUE;
  324. size.cy = num4;
  325. }
  327. CSize size7 = ArrangeOverride(size);
  328. m_szRenderSize = size7;
  330. CSize inkSize = CSize(min(size7.cx, m_mmBounds.nMaxWidth), min(size7.cy, m_mmBounds.nMaxHeight));
  332. if (inkSize.cx < size7.cx || inkSize.cy < size7.cy)
  333. {
  334. m_bNeedsClipBounds = TRUE;
  335. }
  337. CSize clientSize = CSize(max(0, rcFinalRect.Width() - num), max(0, rcFinalRect.Height() - num2));
  339. if (clientSize.cx < inkSize.cx || clientSize.cy < inkSize.cy)
  340. {
  341. m_bNeedsClipBounds = TRUE;
  342. }
  344. CPoint offset = ComputeAlignmentOffset(clientSize, inkSize);
  345. offset.x += rcFinalRect.left + pMargin->left;
  346. offset.y += rcFinalRect.top + pMargin->top;
  348. m_ptVisualOffset = offset;
  349. }
  351. CPoint CXTPMarkupFrameworkElement::ComputeAlignmentOffset(CSize clientSize, CSize inkSize) const
  352. {
  353. CPoint vector(0, 0);
  354. XTPMarkupHorizontalAlignment horizontalAlignment = GetHorizontalAlignment();
  355. XTPMarkupVerticalAlignment verticalAlignment = GetVerticalAlignment();
  357. if ((horizontalAlignment == xtpMarkupHorizontalAlignmentStretch) && (inkSize.cx > clientSize.cx))
  358. {
  359. horizontalAlignment = xtpMarkupHorizontalAlignmentLeft;
  360. }
  361. if ((verticalAlignment == xtpMarkupVerticalAlignmentStretch) && (inkSize.cy > clientSize.cy))
  362. {
  363. verticalAlignment = xtpMarkupVerticalAlignmentTop;
  364. }
  365. switch (horizontalAlignment)
  366. {
  367. case xtpMarkupHorizontalAlignmentCenter:
  368. case xtpMarkupHorizontalAlignmentStretch:
  369. vector.x = (clientSize.cx - inkSize.cx) / 2;
  370. break;
  372. default:
  373. if (horizontalAlignment == xtpMarkupHorizontalAlignmentRight)
  374. {
  375. vector.x = clientSize.cx - inkSize.cx;
  376. }
  377. else
  378. {
  379. vector.x = 0;
  380. }
  381. break;
  382. }
  383. switch (verticalAlignment)
  384. {
  385. case xtpMarkupVerticalAlignmentCenter:
  386. case xtpMarkupVerticalAlignmentStretch:
  387. vector.y = (clientSize.cy - inkSize.cy) / 2;
  388. return vector;
  390. case xtpMarkupVerticalAlignmentBottom:
  391. vector.y = clientSize.cy - inkSize.cy;
  392. return vector;
  393. }
  394. vector.y = 0;
  395. return vector;
  396. }
  400. CSize CXTPMarkupFrameworkElement::ArrangeOverride(CSize szFinalSize)
  401. {
  402. return szFinalSize;
  403. }
  405. void CXTPMarkupFrameworkElement::OnPropertyChanged(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue)
  406. {
  407. CXTPMarkupUIElement::OnPropertyChanged(pProperty, pOldValue, pNewValue);
  409. FireTriggers(pProperty, pNewValue);
  411. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagAffectsMeasure)
  412. {
  413. InvalidateMeasure();
  414. }
  416. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagAffectsArrange)
  417. {
  418. InvalidateArrange();
  419. }
  421. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagAffectsRender)
  422. {
  423. InvalidateVisual();
  424. }
  425. }