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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupGrid.cpp：源码内容
  1. // XTPMarkupGrid.cpp: implementation of the CXTPMarkupGrid 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/XTPVc80Helpers.h"
  25. #include "XTPMarkupGrid.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. // CXTPMarkupGridLength
  37. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupGridLength, CXTPMarkupObject);
  39. void CXTPMarkupGridLength::RegisterMarkupClass()
  40. {
  42. }
  44. CXTPMarkupGridLength::CXTPMarkupGridLength(double nValue /* = 0 */, CXTPMarkupGridLength::GridUnitType type /* = xtpMarkupGridUnitPixel */)
  45. {
  46. m_nValue = nValue;
  47. m_type = type;
  48. }
  51. CXTPMarkupObject* CXTPMarkupGridLength::ConvertFrom(CXTPMarkupObject* pObject) const
  52. {
  53. if (IsStringObject(pObject))
  54. {
  55. LPCWSTR lpszValue = *((CXTPMarkupString*)pObject);
  56. int nLength = ((CXTPMarkupString*)pObject)->GetLength();
  57. if (nLength < 1)
  58. return NULL;
  60. if (nLength == 4 && _wcsicmp(lpszValue, L"Auto") == 0)
  61. {
  62. return new CXTPMarkupGridLength(1, unitTypeAuto);
  63. }
  65. float fValue = 0;
  66. WSCANF_S(lpszValue, L"%f", &fValue);
  68. if (lpszValue[nLength - 1] == '*')
  69. {
  70. return new CXTPMarkupGridLength(nLength == 1 ? 1 : fValue, unitTypeStar);
  71. }
  73. return new CXTPMarkupGridLength(fValue);
  74. }
  75. return NULL;
  76. }
  78. //////////////////////////////////////////////////////////////////////////
  79. // CXTPMarkupDefinitionBase
  81. CXTPMarkupDefinitionBase::CXTPMarkupDefinitionBase(BOOL bIsColumnDefinition)
  82. {
  83. m_bIsColumnDefinition = bIsColumnDefinition;
  84. m_nMinSize = 0;
  85. m_nSizeType = 0;
  86. m_nMeasureSize = 0;
  87. }
  89. void CXTPMarkupDefinitionBase::OnBeforeLayout()
  90. {
  91. m_nSizeType = 0;
  92. m_nMinSize = 0;
  93. m_nMeasureSize = 0;
  94. }
  96. void CXTPMarkupDefinitionBase::UpdateMinSize(int nMinSize)
  97. {
  98. m_nMinSize = max(m_nMinSize, nMinSize);
  99. }
  101. int CXTPMarkupDefinitionBase::GetUserMinSize() const
  102. {
  103. CXTPMarkupInt* pMinValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_bIsColumnDefinition ? CXTPMarkupColumnDefinition::m_pMinWidthProperty : CXTPMarkupRowDefinition::m_pMinHeightProperty));
  104. return pMinValue != NULL ? (int)*pMinValue : 0;
  105. }
  107. int CXTPMarkupDefinitionBase::GetUserMaxSize() const
  108. {
  109. CXTPMarkupInt* pMaxValue = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_bIsColumnDefinition ? CXTPMarkupColumnDefinition::m_pMaxWidthProperty : CXTPMarkupRowDefinition::m_pMaxHeightProperty));
  110. return pMaxValue != NULL ? (int)*pMaxValue : INT_MAX;
  111. }
  113. CXTPMarkupGridLength* CXTPMarkupDefinitionBase::GetUserSize() const
  114. {
  115. CXTPMarkupGridLength* pValue = MARKUP_STATICCAST(CXTPMarkupGridLength, GetValue(m_bIsColumnDefinition ? CXTPMarkupColumnDefinition::m_pWidthProperty : CXTPMarkupRowDefinition::m_pHeightProperty));
  117. ASSERT(pValue);
  118. return pValue;
  119. }
  121. //////////////////////////////////////////////////////////////////////////
  122. // CXTPMarkupColumnDefinition
  124. CXTPMarkupDependencyProperty* CXTPMarkupColumnDefinition::m_pWidthProperty = NULL;
  125. CXTPMarkupDependencyProperty* CXTPMarkupColumnDefinition::m_pMinWidthProperty = NULL;
  126. CXTPMarkupDependencyProperty* CXTPMarkupColumnDefinition::m_pMaxWidthProperty = NULL;
  128. IMPLEMENT_MARKUPCLASS(L"ColumnDefinition", CXTPMarkupColumnDefinition, CXTPMarkupObject);
  130. void CXTPMarkupColumnDefinition::RegisterMarkupClass()
  131. {
  132. m_pWidthProperty = CXTPMarkupDependencyProperty::Register(L"Width", MARKUP_TYPE(CXTPMarkupGridLength), MARKUP_TYPE(CXTPMarkupColumnDefinition),
  133. new CXTPMarkupPropertyMetadata(new CXTPMarkupGridLength(1, CXTPMarkupGridLength::unitTypeStar)));
  135. m_pMinWidthProperty = CXTPMarkupDependencyProperty::Register(L"MinWidth", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupColumnDefinition));
  137. m_pMaxWidthProperty = CXTPMarkupDependencyProperty::Register(L"MaxWidth", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupColumnDefinition));
  138. }
  140. CXTPMarkupColumnDefinition::CXTPMarkupColumnDefinition()
  141. : CXTPMarkupDefinitionBase(TRUE)
  142. {
  144. }
  146. //////////////////////////////////////////////////////////////////////////
  147. // CXTPMarkupRowDefinition
  149. CXTPMarkupDependencyProperty* CXTPMarkupRowDefinition::m_pHeightProperty = NULL;
  150. CXTPMarkupDependencyProperty* CXTPMarkupRowDefinition::m_pMinHeightProperty = NULL;
  151. CXTPMarkupDependencyProperty* CXTPMarkupRowDefinition::m_pMaxHeightProperty = NULL;
  153. IMPLEMENT_MARKUPCLASS(L"RowDefinition", CXTPMarkupRowDefinition, CXTPMarkupObject);
  155. void CXTPMarkupRowDefinition::RegisterMarkupClass()
  156. {
  157. m_pHeightProperty = CXTPMarkupDependencyProperty::Register(L"Height", MARKUP_TYPE(CXTPMarkupGridLength), MARKUP_TYPE(CXTPMarkupRowDefinition),
  158. new CXTPMarkupPropertyMetadata(new CXTPMarkupGridLength(1, CXTPMarkupGridLength::unitTypeStar)));
  160. m_pMinHeightProperty = CXTPMarkupDependencyProperty::Register(L"MinHeight", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupRowDefinition));
  162. m_pMaxHeightProperty = CXTPMarkupDependencyProperty::Register(L"MaxHeight", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupRowDefinition));
  163. }
  165. CXTPMarkupRowDefinition::CXTPMarkupRowDefinition()
  166. : CXTPMarkupDefinitionBase(FALSE)
  167. {
  169. }
  172. //////////////////////////////////////////////////////////////////////////
  173. // CXTPMarkupDefinitionCollection
  175. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupDefinitionCollection, CXTPMarkupCollection);
  177. void CXTPMarkupDefinitionCollection::RegisterMarkupClass()
  178. {
  180. }
  182. CXTPMarkupDefinitionCollection::CXTPMarkupDefinitionCollection()
  183. {
  184. }
  186. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupRowDefinitionCollection, CXTPMarkupDefinitionCollection);
  188. void CXTPMarkupRowDefinitionCollection::RegisterMarkupClass()
  189. {
  191. }
  193. CXTPMarkupRowDefinitionCollection::CXTPMarkupRowDefinitionCollection()
  194. {
  195. m_pElementType = MARKUP_TYPE(CXTPMarkupRowDefinition);
  196. }
  198. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupColumnDefinitionCollection, CXTPMarkupDefinitionCollection);
  200. void CXTPMarkupColumnDefinitionCollection::RegisterMarkupClass()
  201. {
  203. }
  205. CXTPMarkupColumnDefinitionCollection::CXTPMarkupColumnDefinitionCollection()
  206. {
  207. m_pElementType = MARKUP_TYPE(CXTPMarkupColumnDefinition);
  208. }
  211. //////////////////////////////////////////////////////////////////////
  212. // Construction/Destruction
  213. //////////////////////////////////////////////////////////////////////
  215. CXTPMarkupDependencyProperty* CXTPMarkupGrid::m_pColumnDefinitionsProperty = NULL;
  216. CXTPMarkupDependencyProperty* CXTPMarkupGrid::m_pRowDefinitionsProperty = NULL;
  217. CXTPMarkupDependencyProperty* CXTPMarkupGrid::m_pColumnProperty = NULL;
  218. CXTPMarkupDependencyProperty* CXTPMarkupGrid::m_pRowProperty = NULL;
  220. IMPLEMENT_MARKUPCLASS(L"Grid", CXTPMarkupGrid, CXTPMarkupPanel)
  222. void CXTPMarkupGrid::RegisterMarkupClass()
  223. {
  224. m_pColumnDefinitionsProperty = CXTPMarkupDependencyProperty::Register(L"ColumnDefinitions", MARKUP_TYPE(CXTPMarkupColumnDefinitionCollection), MARKUP_TYPE(CXTPMarkupGrid));
  226. m_pRowDefinitionsProperty = CXTPMarkupDependencyProperty::Register(L"RowDefinitions", MARKUP_TYPE(CXTPMarkupRowDefinitionCollection), MARKUP_TYPE(CXTPMarkupGrid));
  228. m_pColumnProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"Column", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupGrid),
  229. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupGrid::OnCellAttachedPropertyChanged));
  231. m_pRowProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"Row", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupGrid),
  232. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupGrid::OnCellAttachedPropertyChanged));
  233. }
  236. CXTPMarkupGrid::CXTPMarkupGrid()
  237. {
  238. m_pRowDefinitions = new CXTPMarkupRowDefinitionCollection();
  239. m_pRowDefinitions->SetLogicalParent(this);
  241. m_pColumnDefinitions = new CXTPMarkupColumnDefinitionCollection();
  242. m_pColumnDefinitions->SetLogicalParent(this);
  244. m_pCellCachesCollection = NULL;
  246. m_pDefinitionsU = NULL;
  247. m_pDefinitionsV = NULL;
  248. }
  250. CXTPMarkupGrid::~CXTPMarkupGrid()
  251. {
  252. MARKUP_RELEASE(m_pColumnDefinitions);
  253. MARKUP_RELEASE(m_pRowDefinitions);
  255. SAFE_DELETE_AR(m_pCellCachesCollection);
  257. MARKUP_RELEASE(m_pDefinitionsU);
  258. MARKUP_RELEASE(m_pDefinitionsV);
  259. }
  261. void CXTPMarkupGrid::OnCellAttachedPropertyChanged(CXTPMarkupObject* d, CXTPMarkupPropertyChangedEventArgs* /*e*/)
  262. {
  263. CXTPMarkupUIElement* pVisual = MARKUP_DYNAMICCAST(CXTPMarkupUIElement, d);
  264. if (!pVisual)
  265. return;
  267. CXTPMarkupGrid* pGrid = MARKUP_DYNAMICCAST(CXTPMarkupGrid, pVisual->GetVisualParent());
  268. if (!pGrid)
  269. return;
  271. pGrid->InvalidateMeasure();
  272. }
  274. int CXTPMarkupGrid::GetColumn(CXTPMarkupUIElement* pElement)
  275. {
  276. CXTPMarkupInt* pColumn = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(m_pColumnProperty));
  277. return pColumn != NULL ? (int)*pColumn : 0;
  278. }
  280. int CXTPMarkupGrid::GetRow(CXTPMarkupUIElement* pElement)
  281. {
  282. CXTPMarkupInt* pRow = MARKUP_STATICCAST(CXTPMarkupInt, pElement->GetValue(m_pRowProperty));
  283. return pRow != NULL ? (int)*pRow : 0;
  284. }
  286. void CXTPMarkupGrid::SetColumn(CXTPMarkupUIElement* pElement, int nColumn)
  287. {
  288. pElement->SetValue(m_pColumnProperty, new CXTPMarkupInt(nColumn));
  289. }
  291. void CXTPMarkupGrid::SetRow(CXTPMarkupUIElement* pElement, int nRow)
  292. {
  293. pElement->SetValue(m_pRowProperty, new CXTPMarkupInt(nRow));
  294. }
  296. int CXTPMarkupGrid::GetColumnSpan(CXTPMarkupUIElement* /*pElement*/)
  297. {
  298. return 1;
  299. }
  301. int CXTPMarkupGrid::GetRowSpan(CXTPMarkupUIElement* /*pElement*/)
  302. {
  303. return 1;
  304. }
  307. void CXTPMarkupGrid::SetPropertyObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  308. {
  309. if (pProperty == m_pColumnDefinitionsProperty)
  310. {
  311. if (!pValue || !pValue->IsKindOf(MARKUP_TYPE(CXTPMarkupColumnDefinitionCollection)))
  312. {
  313. pBuilder->ThrowBuilderException(_T("CXTPMarkupColumnDefinitionCollection class expected"));
  314. }
  316. MARKUP_RELEASE(m_pColumnDefinitions);
  317. m_pColumnDefinitions = (CXTPMarkupColumnDefinitionCollection*)pValue;
  318. m_pColumnDefinitions->SetLogicalParent(this);
  319. }
  320. else if (pProperty == m_pRowDefinitionsProperty)
  321. {
  322. if (!pValue || !pValue->IsKindOf(MARKUP_TYPE(CXTPMarkupRowDefinitionCollection)))
  323. {
  324. pBuilder->ThrowBuilderException(_T("CXTPMarkupRowDefinitionCollection class expected"));
  325. }
  327. MARKUP_RELEASE(m_pRowDefinitions);
  328. m_pRowDefinitions = (CXTPMarkupRowDefinitionCollection*)pValue;
  329. m_pRowDefinitions->SetLogicalParent(this);
  331. }
  332. else
  333. {
  334. CXTPMarkupPanel::SetPropertyObject(pBuilder, pProperty, pValue);
  335. }
  336. }
  338. AFX_INLINE BOOL IsPositiveInfinity(int size) {
  339. return size > 32000;
  340. }
  342. AFX_INLINE BOOL IsNan(int nSize) {
  343. return nSize == INT_MAX;
  344. }
  346. void CXTPMarkupGrid::ValidateDefinitionsLayout(CXTPMarkupDefinitionCollection* pDefinitions, BOOL bTreatStarAsAuto)
  347. {
  348. for (int i = 0; i < pDefinitions->GetCount(); i++)
  349. {
  350. CXTPMarkupDefinitionBase* pDefinition = pDefinitions->GetItem(i);
  351. pDefinition->OnBeforeLayout();
  352. int nUserMinSize = pDefinition->GetUserMinSize();
  353. int nUserMaxSize = pDefinition->GetUserMaxSize();
  354. int nPositiveInfinity = INT_MAX;
  355. switch (pDefinition->GetUserSize()->GetUnitType())
  356. {
  357. case CXTPMarkupGridLength::unitTypeAuto:
  358. pDefinition->m_nSizeType = sizeTypeAuto;
  359. break;
  361. case  CXTPMarkupGridLength::unitTypePixel:
  362. pDefinition->m_nSizeType = sizeTypePixel;
  363. nPositiveInfinity = (int)pDefinition->GetUserSize()->GetValue();
  364. nUserMinSize = max(nUserMinSize, min(nPositiveInfinity, nUserMaxSize));
  365. break;
  367. case CXTPMarkupGridLength::unitTypeStar:
  368. pDefinition->m_nSizeType = bTreatStarAsAuto ? sizeTypeAuto : sizeTypeStar;
  369. break;
  370.    }
  372. pDefinition->UpdateMinSize(nUserMinSize);
  373. pDefinition->m_nMeasureSize = max(nUserMinSize, min(nPositiveInfinity, nUserMaxSize));
  374. }
  375. }
  377. int CXTPMarkupGrid::GetLengthTypeForRange(CXTPMarkupDefinitionCollection* pDefinitions, int start, int count)
  378. {
  379. ASSERT(pDefinitions->GetCount() > 0);
  380. int nSizeType = sizeTypeNone;
  382. for (int i = start; i < start + count; i++)
  383. {
  384. nSizeType = (nSizeType | pDefinitions->GetItem(i)->m_nSizeType);
  385. }
  387. return nSizeType;
  388. }
  390. BOOL CXTPMarkupGrid::CELLCACHE::IsStarU() const
  391. {
  392. return nSizeTypeU & CXTPMarkupGrid::sizeTypeStar;
  393. }
  395. BOOL CXTPMarkupGrid::CELLCACHE::IsStarV() const
  396. {
  397. return nSizeTypeV & CXTPMarkupGrid::sizeTypeStar;
  398. }
  400. BOOL CXTPMarkupGrid::CELLCACHE::IsAutoU() const
  401. {
  402. return nSizeTypeU & CXTPMarkupGrid::sizeTypeAuto;
  403. }
  405. BOOL CXTPMarkupGrid::CELLCACHE::IsAutoV() const
  406. {
  407. return nSizeTypeV & CXTPMarkupGrid::sizeTypeAuto;
  408. }
  410. void CXTPMarkupGrid::ValidateCells()
  411. {
  412. SAFE_DELETE_AR(m_pCellCachesCollection);
  414. m_pCellCachesCollection = new CELLCACHE[GetChildren()->GetCount()];
  415. m_nCellGroup[0] = INT_MAX;
  416. m_nCellGroup[1] = INT_MAX;
  417. m_nCellGroup[2] = INT_MAX;
  418. m_nCellGroup[3] = INT_MAX;
  419. BOOL flag = FALSE;
  420. BOOL flag2 = FALSE;
  421. BOOL flag3 = FALSE;
  423. for (int i = GetChildren()->GetCount() - 1; i >= 0; i--)
  424. {
  425. CXTPMarkupUIElement* pElement = GetChildren()->GetItem(i);
  426. if (!pElement)
  427. continue;
  429. CELLCACHE& cache = m_pCellCachesCollection[i];
  430. cache.nColumnIndex = min(GetColumn(pElement), m_pDefinitionsU->GetCount() - 1);
  431. cache.nRowIndex = min(GetRow(pElement), m_pDefinitionsV->GetCount() - 1);
  432. cache.nColumnSpan = min(GetColumnSpan(pElement), m_pDefinitionsU->GetCount() - cache.nColumnIndex);
  433. cache.nRowSpan = min(GetRowSpan(pElement),  m_pDefinitionsV->GetCount() - cache.nRowIndex);
  434. cache.nSizeTypeU = GetLengthTypeForRange(m_pDefinitionsU, cache.nColumnIndex, cache.nColumnSpan);
  435. cache.nSizeTypeV = GetLengthTypeForRange(m_pDefinitionsV, cache.nRowIndex, cache.nRowSpan);
  436. flag |= cache.IsStarU();
  437. flag2 |= cache.IsStarV();
  438. if (!cache.IsStarV())
  439. {
  440. if (!cache.IsStarU())
  441. {
  442. cache.nNext = m_nCellGroup[0];
  443. m_nCellGroup[0] = i;
  444. }
  445. else
  446. {
  447. cache.nNext = m_nCellGroup[2];
  448. m_nCellGroup[2] = i;
  449. flag3 |= cache.IsAutoV();
  450. }
  451. }
  452. else if (cache.IsAutoU() && !cache.IsStarU())
  453. {
  454. cache.nNext = m_nCellGroup[1];
  455. m_nCellGroup[1] = i;
  456. }
  457. else
  458. {
  459. cache.nNext = m_nCellGroup[3];
  460. m_nCellGroup[3] = i;
  461. }
  462. }
  464. m_bHasStarCellsU = flag;
  465. m_bHasStarCellsV = flag2;
  466. m_bHasGroup2CellsInAutoRows = flag3;
  467. }
  469. int CXTPMarkupGrid::GetMeasureSizeForRange(CXTPMarkupDefinitionCollection* pDefinitions, int start, int count)
  470. {
  471. double num = 0;
  472. for (int nIndex = start; nIndex < start + count; nIndex++)
  473. {
  474. CXTPMarkupDefinitionBase* pDefinition = pDefinitions->GetItem(nIndex);
  475. num += pDefinition->m_nSizeType == sizeTypeAuto ? pDefinition->m_nMinSize : pDefinition->m_nMeasureSize;
  476. }
  478. return (int)num;
  479. }
  481. void CXTPMarkupGrid::MeasureCell(CXTPMarkupDrawingContext* pDC, int cell, BOOL forceInfinityV)
  482. {
  483. int nPositiveInfinity;
  484. int num2;
  485. if (m_pCellCachesCollection[cell].IsAutoU() && !m_pCellCachesCollection[cell].IsStarU())
  486. {
  487. nPositiveInfinity = INT_MAX;
  488. }
  489. else
  490. {
  491. nPositiveInfinity = GetMeasureSizeForRange(m_pDefinitionsU, m_pCellCachesCollection[cell].nColumnIndex, m_pCellCachesCollection[cell].nColumnSpan);
  492. }
  494. if (forceInfinityV)
  495. {
  496. num2 = INT_MAX;
  497. }
  498. else if (m_pCellCachesCollection[cell].IsAutoV() && !m_pCellCachesCollection[cell].IsStarV())
  499. {
  500. num2 = INT_MAX;
  501. }
  502. else
  503. {
  504. num2 = GetMeasureSizeForRange(m_pDefinitionsV, m_pCellCachesCollection[cell].nRowIndex, m_pCellCachesCollection[cell].nRowSpan);
  505. }
  507. CXTPMarkupUIElement* pElement = GetChildren()->GetItem(cell);
  508. if (pElement != NULL)
  509. {
  510. pElement->Measure(pDC, CSize(nPositiveInfinity, num2));
  511. }
  512. }
  514. void CXTPMarkupGrid::MeasureCellsGroup(CXTPMarkupDrawingContext* pDC, int cellsHead, CSize /*referenceSize*/, BOOL ignoreDesiredSizeU, BOOL forceInfinityV)
  515. {
  516. int nCount = GetChildren()->GetCount();
  517. if (cellsHead < nCount)
  518. {
  519. BOOL flag = forceInfinityV;
  520. int cell = cellsHead;
  522. do
  523. {
  524. CELLCACHE& cellCache =  m_pCellCachesCollection[cell];
  526. MeasureCell(pDC, cell, forceInfinityV);
  527. if (!ignoreDesiredSizeU)
  528. {
  529. if (cellCache.nColumnSpan == 1)
  530. {
  531. m_pDefinitionsU->GetItem(cellCache.nColumnIndex)->UpdateMinSize(GetChildren()->GetItem(cell)->GetDesiredSize().cx);
  532. }
  533. else
  534. {
  535. ASSERT(FALSE);
  536. }
  537. }
  538. if (!flag)
  539. {
  540. if (cellCache.nRowSpan == 1)
  541. {
  542. m_pDefinitionsV->GetItem(cellCache.nRowIndex)->UpdateMinSize(GetChildren()->GetItem(cell)->GetDesiredSize().cy);
  543. }
  544. else
  545. {
  546. ASSERT(FALSE);
  547. }
  548. }
  549. cell = cellCache.nNext;
  550. }
  551. while (cell < nCount);
  552. }
  553. }
  555. void CXTPMarkupGrid::ValidateDefinitions()
  556. {
  557. MARKUP_RELEASE(m_pDefinitionsU);
  558. MARKUP_RELEASE(m_pDefinitionsV);
  560. if (m_pColumnDefinitions->GetCount() == 0)
  561. {
  562. m_pDefinitionsU = new CXTPMarkupColumnDefinitionCollection();
  563. m_pDefinitionsU->Add(new CXTPMarkupColumnDefinition());
  564. }
  565. else
  566. {
  567. m_pDefinitionsU = m_pColumnDefinitions;
  568. m_pDefinitionsU->AddRef();
  569. }
  571. if (m_pRowDefinitions->GetCount() == 0)
  572. {
  573. m_pDefinitionsV = new CXTPMarkupRowDefinitionCollection();
  574. m_pDefinitionsV->Add(new CXTPMarkupRowDefinition());
  575. }
  576. else
  577. {
  578. m_pDefinitionsV = m_pRowDefinitions;
  579. m_pDefinitionsV->AddRef();
  580. }
  581. }
  583. int CXTPMarkupGrid::CalculateDesiredSize(CXTPMarkupDefinitionCollection* pDefinitions)
  584. {
  585. int num = 0;
  586. for (int i = 0; i < pDefinitions->GetCount(); i++)
  587. {
  588. num += pDefinitions->GetItem(i)->m_nMinSize;
  589. }
  590. return num;
  591. }
  593. void CXTPMarkupGrid::ResolveStar(CXTPMarkupDefinitionCollection* pDefinitions, double availableSize)
  594. {
  595. CXTPMarkupDefinitionBase** pTempDefinitions = new CXTPMarkupDefinitionBase*[pDefinitions->GetCount()];
  597. int length = 0;
  598. double num2 = 0;
  600. for (int i = 0; i < pDefinitions->GetCount(); i++)
  601. {
  602. CXTPMarkupDefinitionBase* pDefinition = pDefinitions->GetItem(i);
  604. switch (pDefinition->m_nSizeType)
  605. {
  606. case sizeTypePixel:
  607. num2 += pDefinition->m_nMeasureSize;
  608. continue;
  610. case sizeTypeAuto:
  611. num2 +=  pDefinition->m_nMinSize;
  612. continue;
  614. case sizeTypeStar:
  615. {
  616. pTempDefinitions[length++] = pDefinition;
  617. double num4 = pDefinition->GetUserSize()->GetValue();
  618. if (num4 != 0)
  619. {
  620. pDefinition->m_nMeasureSize = num4;
  621. double num5 = IsNan(pDefinition->GetUserMaxSize()) ? pDefinition->m_nMinSize : max(pDefinition->m_nMinSize, pDefinition->GetUserMaxSize());
  622. pDefinition->m_nSizeCache = num5 / num4;
  623. }
  624. else
  625. {
  626. pDefinition->m_nMeasureSize = 0;
  627. pDefinition->m_nSizeCache = 0;
  628. }
  629. continue;
  630. }
  631. }
  632. }
  633. if (length > 0)
  634. {
  635. qsort(pTempDefinitions, length, sizeof(CXTPMarkupDefinitionBase*), StarDistributionOrderComparer);
  637. int nIndex;
  638. double num6 = 0;
  639. for (nIndex = length - 1; nIndex >= 0; nIndex--)
  640. {
  641. num6 += pTempDefinitions[nIndex]->m_nMeasureSize;
  642. pTempDefinitions[nIndex]->m_nSizeCache = num6;
  643. }
  645. for (nIndex = 0; nIndex < length; nIndex++)
  646. {
  647. CXTPMarkupDefinitionBase* pDefinition = pTempDefinitions[nIndex];
  649. int nMinSize;
  650. double nMeasureSize = pDefinition->m_nMeasureSize;
  651. if (nMeasureSize == 0)
  652. {
  653. nMinSize = pDefinition->m_nMinSize;
  654. }
  655. else
  656. {
  657. int num10 = (int)(max((double) (availableSize - num2), (double) 0) * (nMeasureSize / pDefinition->m_nSizeCache));
  658. nMinSize = min(num10, pDefinition->GetUserMaxSize());
  659. nMinSize = max(pDefinition->m_nMinSize, nMinSize);
  660. }
  661. pDefinition->m_nMeasureSize = nMinSize;
  662. num2 += nMinSize;
  663. }
  664. }
  666. delete[] pTempDefinitions;
  667. }
  670. CSize CXTPMarkupGrid::MeasureOverride(CXTPMarkupDrawingContext* pDC, CSize constraint)
  671. {
  672. CSize size(0, 0);
  674. if (m_pColumnDefinitions->GetCount() == 0 && m_pRowDefinitions->GetCount() == 0)
  675. {
  676. int nCount = m_pChildren->GetCount();
  677. for (int i = 0; i < nCount; i++)
  678. {
  679. CXTPMarkupUIElement* pElement = m_pChildren->GetItem(i);
  680. if (pElement == NULL)
  681. continue;
  683. pElement->Measure(pDC, constraint);
  685. size.cx = max(size.cx, pElement->GetDesiredSize().cx);
  686. size.cy = max(size.cy, pElement->GetDesiredSize().cy);
  687. }
  689. return size;
  690. }
  692. BOOL bTreatStarAsAuto = IsPositiveInfinity(constraint.cx);
  693. BOOL bFlag2 = IsPositiveInfinity(constraint.cy);
  695. ValidateDefinitions();
  696. ValidateDefinitionsLayout(m_pDefinitionsU, bTreatStarAsAuto);
  697. ValidateDefinitionsLayout(m_pDefinitionsV, bFlag2);
  699. ValidateCells();
  701. MeasureCellsGroup(pDC, m_nCellGroup[0], constraint, FALSE, FALSE);
  703. if (!m_bHasGroup2CellsInAutoRows)
  704. {
  705. if (m_bHasStarCellsV)
  706. {
  707. ResolveStar(m_pDefinitionsV, constraint.cy);
  708. }
  709. MeasureCellsGroup(pDC, m_nCellGroup[1], constraint, FALSE, FALSE);
  710. if (m_bHasStarCellsU)
  711. {
  712. ResolveStar(m_pDefinitionsU, constraint.cx);
  713. }
  714. MeasureCellsGroup(pDC, m_nCellGroup[2], constraint, FALSE, FALSE);
  715. }
  716. else if (m_nCellGroup[1] > GetChildren()->GetCount())
  717. {
  718. if (m_bHasStarCellsU)
  719. {
  720. ResolveStar(m_pDefinitionsU, constraint.cx);
  721. }
  722. MeasureCellsGroup(pDC, m_nCellGroup[2], constraint, FALSE, FALSE);
  723. if (m_bHasStarCellsV)
  724. {
  725. ResolveStar(m_pDefinitionsV, constraint.cy);
  726. }
  727. }
  728. else
  729. {
  730. MeasureCellsGroup(pDC, m_nCellGroup[1], constraint, FALSE, TRUE);
  731. if (m_bHasStarCellsU)
  732. {
  733. ResolveStar(m_pDefinitionsU, constraint.cx);
  734. }
  735. MeasureCellsGroup(pDC, m_nCellGroup[2], constraint, FALSE, FALSE);
  736. if (m_bHasStarCellsV)
  737. {
  738. ResolveStar(m_pDefinitionsV, constraint.cy);
  739. }
  740. MeasureCellsGroup(pDC, m_nCellGroup[1], constraint, TRUE, FALSE);
  741. }
  743. MeasureCellsGroup(pDC, m_nCellGroup[3], constraint, FALSE, FALSE);
  744. size = CSize(CalculateDesiredSize(m_pDefinitionsU), CalculateDesiredSize(m_pDefinitionsV));
  746. return size;
  747. }
  750. int _cdecl CXTPMarkupGrid::DistributionOrderComparer(const void *arg1, const void *arg2)
  751. {
  752. CXTPMarkupDefinitionBase* base2 = *((CXTPMarkupDefinitionBase**)arg1);
  753. CXTPMarkupDefinitionBase* base3 = *((CXTPMarkupDefinitionBase**)arg2);
  755. if ((base2->m_nSizeCache - base2->m_nMinSize) == (base3->m_nSizeCache - base3->m_nMinSize))
  756. {
  757. return 0;
  758. }
  759. else if ((base2->m_nSizeCache - base2->m_nMinSize) < (base3->m_nSizeCache - base3->m_nMinSize))
  760. {
  761. return -1;
  762. }
  763. return 1;
  764. };
  766. int _cdecl CXTPMarkupGrid::StarDistributionOrderComparer(const void *arg1, const void *arg2)
  767. {
  768. CXTPMarkupDefinitionBase* base2 = *((CXTPMarkupDefinitionBase**)arg1);
  769. CXTPMarkupDefinitionBase* base3 = *((CXTPMarkupDefinitionBase**)arg2);
  771. if (base2->m_nSizeCache == base3->m_nSizeCache)
  772. {
  773. return 0;
  774. }
  775. else if (base2->m_nSizeCache < base3->m_nSizeCache)
  776. {
  777. return -1;
  778. }
  779. return 1;
  780. };
  782. void CXTPMarkupGrid::SetFinalSize(CXTPMarkupDefinitionCollection* pDefinitions, int finalSize)
  783. {
  784. CXTPMarkupDefinitionBase** pTempDefinitions = new CXTPMarkupDefinitionBase*[pDefinitions->GetCount()];
  786. int length = 0;
  787. int num2 = pDefinitions->GetCount();
  788. double num3 = 0;
  789. for (int i = 0; i < pDefinitions->GetCount(); i++)
  790. {
  791. CXTPMarkupDefinitionBase* pDefinition = pDefinitions->GetItem(i);
  793. if (pDefinition->GetUserSize()->IsStar())
  794. {
  795. pTempDefinitions[length++] = pDefinition;
  796. double d = pDefinition->GetUserSize()->GetValue();
  797. if (d == 0)
  798. {
  799. pDefinition->m_nMeasureSize = 0;
  800. pDefinition->m_nSizeCache = 0;
  801. }
  802. else
  803. {
  804. pDefinition->m_nMeasureSize = d;
  805. int num6 = IsNan(pDefinition->GetUserMaxSize()) ? pDefinition->m_nMinSize : max(pDefinition->m_nMinSize, pDefinition->GetUserMaxSize());
  806. pDefinition->m_nSizeCache = (double)num6 / (double)d;
  807. }
  808. }
  809. else
  810. {
  811. pTempDefinitions[--num2] = pDefinition;
  812. double nMinSizeForArrange = 0;
  813. switch (pDefinition->GetUserSize()->GetUnitType())
  814. {
  815. case CXTPMarkupGridLength::unitTypeAuto:
  816. nMinSizeForArrange = pDefinition->m_nMinSize;
  817. break;
  819. case CXTPMarkupGridLength::unitTypePixel:
  820. nMinSizeForArrange = pDefinition->GetUserSize()->GetValue();
  821. break;
  822. }
  823. int nUserMaxSize = pDefinition->GetUserMaxSize();
  824. pDefinition->m_nSizeCache = max(pDefinition->m_nMinSize, min(nMinSizeForArrange, nUserMaxSize));
  825. num3 += pDefinition->m_nSizeCache;
  826. }
  827. }
  828. if (length > 0)
  829. {
  830. qsort(pTempDefinitions, length, sizeof(CXTPMarkupDefinitionBase*), StarDistributionOrderComparer);
  832. double num9 = 0;
  833. int nIndex;
  834. for (nIndex = length - 1; nIndex >= 0; nIndex--)
  835. {
  836. num9 += pTempDefinitions[nIndex]->m_nMeasureSize;
  837. pTempDefinitions[nIndex]->m_nSizeCache = num9;
  838. }
  839. for (nIndex = 0; nIndex < length; nIndex++)
  840. {
  841. CXTPMarkupDefinitionBase* pDefinition = pTempDefinitions[nIndex];
  843. int num11;
  844. double nMeasureSize = pDefinition->m_nMeasureSize;
  845. if (nMeasureSize == 0)
  846. {
  847. num11 = pDefinition->m_nMinSize;
  848. }
  849. else
  850. {
  851. double num13 = max((double) (finalSize - num3), (double) 0) * (nMeasureSize / pDefinition->m_nSizeCache);
  852. num11 = min((int)num13, pDefinition->GetUserMaxSize());
  853. num11 = max(pDefinition->m_nMinSize, num11);
  854. }
  855. pDefinition->m_nSizeCache = num11;
  856. num3 += num11;
  857. }
  858. }
  859. if (num3 > finalSize)
  860. {
  861. qsort(pTempDefinitions, length, sizeof(CXTPMarkupDefinitionBase*), DistributionOrderComparer);
  863. double num14 = finalSize - num3;
  864. for (int k = 0; k < pDefinitions->GetCount(); k++)
  865. {
  866. double num16 = pTempDefinitions[k]->m_nSizeCache + (num14 / ((double) (pDefinitions->GetCount() - k)));
  867. num16 = min(max(num16, pTempDefinitions[k]->m_nMinSize), pTempDefinitions[k]->m_nSizeCache);
  868. num14 -= num16 - pTempDefinitions[k]->m_nSizeCache;
  869. pTempDefinitions[k]->m_nSizeCache = num16;
  870. }
  871. }
  872. pDefinitions->GetItem(0)->m_nFinalOffset = 0;
  873. for (int j = 1; j < pDefinitions->GetCount(); j++)
  874. {
  875. pDefinitions->GetItem(j)->m_nFinalOffset = pDefinitions->GetItem(j - 1)->m_nFinalOffset + (int)pDefinitions->GetItem(j - 1)->m_nSizeCache;
  876. }
  878. delete[] pTempDefinitions;
  879. }
  882. int CXTPMarkupGrid::GetFinalSizeForRange(CXTPMarkupDefinitionCollection* pDefinitions, int start, int count)
  883. {
  884. int num = 0;
  885. for (int nIndex = start; nIndex < start + count; nIndex++)
  886. {
  887. num += (int)pDefinitions->GetItem(nIndex)->m_nSizeCache;
  888. }
  889. return num;
  890. }
  892. CSize CXTPMarkupGrid::ArrangeOverride(CSize arrangeSize)
  893. {
  894. if ((m_pColumnDefinitions->GetCount() == 0 && m_pRowDefinitions->GetCount() == 0) || (m_pCellCachesCollection == NULL))
  895. {
  896. int nCount = m_pChildren->GetCount();
  897. for (int i = 0; i < nCount; i++)
  898. {
  899. CXTPMarkupUIElement* pElement = m_pChildren->GetItem(i);
  900. if (pElement == NULL)
  901. continue;
  903. pElement->Arrange(CRect(0, 0, arrangeSize.cx, arrangeSize.cy));
  904. }
  905. return arrangeSize;
  906. }
  908. SetFinalSize(m_pDefinitionsU, arrangeSize.cx);
  909. SetFinalSize(m_pDefinitionsV, arrangeSize.cy);
  910. int nCount = m_pChildren->GetCount();
  911. for (int i = 0; i < nCount; i++)
  912. {
  913. CXTPMarkupUIElement* pElement = m_pChildren->GetItem(i);
  914. if (pElement == NULL)
  915. continue;
  917. CELLCACHE& cellCache =  m_pCellCachesCollection[i];
  919. int columnIndex = cellCache.nColumnIndex;
  920. int rowIndex = cellCache.nRowIndex;
  921. int columnSpan = cellCache.nColumnSpan;
  922. int rowSpan = cellCache.nRowSpan;
  924. CRect finalRect(CPoint(m_pDefinitionsU->GetItem(columnIndex)->m_nFinalOffset,
  925. m_pDefinitionsV->GetItem(rowIndex)->m_nFinalOffset),
  926. CSize(GetFinalSizeForRange(m_pDefinitionsU, columnIndex, columnSpan),
  927. GetFinalSizeForRange(m_pDefinitionsV, rowIndex, rowSpan)));
  929. pElement->Arrange(finalRect);
  930. }
  932. return arrangeSize;
  933. }