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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupObject.cpp：源码内容
  1. // XTPMarkupObject.cpp: implementation of the CXTPMarkupObject 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 "XTPMarkupObject.h"
  26. #include "XTPMarkupBuilder.h"
  27. #include "XTPMarkupContext.h"
  29. #ifdef _DEBUG
  30. #undef THIS_FILE
  31. static char THIS_FILE[]=__FILE__;
  32. #define new DEBUG_NEW
  33. #endif
  36. CXTPMarkupPropertyChangedEventArgs::CXTPMarkupPropertyChangedEventArgs(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue)
  37. {
  38. m_pProperty = pProperty;
  39. m_pOldValue = pOldValue;
  40. m_pNewValue = pNewValue;
  41. }
  43. struct CXTPMarkupFromNameKey
  44. {
  45. public:
  46. CXTPMarkupFromNameKey(LPCWSTR lpszName = 0, CXTPMarkupType* pOwnerType = 0)
  47. {
  48. m_lpszName = lpszName;
  49. m_pOwnerType = pOwnerType;
  50. }
  52. BOOL operator==(const CXTPMarkupFromNameKey& key) const
  53. {
  54. return m_pOwnerType == key.m_pOwnerType && wcscmp(m_lpszName, key.m_lpszName) == 0;
  55. }
  57. LPCWSTR m_lpszName;
  58. CXTPMarkupType* m_pOwnerType;
  59. };
  62. class CXTPMarkupPropertyFromNameMap : public CMap<CXTPMarkupFromNameKey, CXTPMarkupFromNameKey&, CXTPMarkupDependencyProperty*, CXTPMarkupDependencyProperty*>
  63. {
  64. public:
  65. CXTPMarkupPropertyFromNameMap();
  66. ~CXTPMarkupPropertyFromNameMap();
  67. };
  70. CXTPMarkupPropertyFromNameMap::CXTPMarkupPropertyFromNameMap()
  71. {
  73. }
  75. CXTPMarkupPropertyFromNameMap::~CXTPMarkupPropertyFromNameMap()
  76. {
  77. POSITION pos = GetStartPosition();
  78. while (pos)
  79. {
  80. CXTPMarkupFromNameKey key;
  81. CXTPMarkupDependencyProperty* dp;
  82. GetNextAssoc(pos, key, dp);
  83. dp->Release();
  84. }
  85. RemoveAll();
  86. }
  88. template<>
  89. AFX_INLINE UINT AFXAPI HashKey<CXTPMarkupFromNameKey&>(CXTPMarkupFromNameKey& key)
  90. {
  91. // default identity hash - works for most primitive values
  92. return HashKey<LPCWSTR>(key.m_lpszName) & ((UINT)(DWORD)(DWORD_PTR)key.m_pOwnerType) >> 16;
  93. }
  96. CXTPMarkupPropertyFromNameMap* CXTPMarkupDependencyProperty::GetPropertyMap()
  97. {
  98. static CXTPMarkupPropertyFromNameMap m_PropertyFromName;
  99. return &m_PropertyFromName;
  100. }
  102. //////////////////////////////////////////////////////////////////////////
  103. // CXTPMarkupPropertyMetadata
  104. CXTPMarkupPropertyMetadata::CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, DWORD dwFlags)
  105. {
  106. m_pDefaultValue = pDefaultValue;
  107. m_pConverter = NULL;
  108. m_dwFlags = dwFlags;
  109. m_pPropertyChanged = NULL;
  110. }
  112. CXTPMarkupPropertyMetadata::CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, PFNCONVERTFROM pConverter, DWORD dwFlags)
  113. {
  114. m_pDefaultValue = pDefaultValue;
  115. m_pConverter = pConverter;
  116. m_dwFlags = dwFlags;
  117. m_pPropertyChanged = NULL;
  118. }
  120. CXTPMarkupPropertyMetadata::CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, PFNPROPERTYCHANGED pPropertyChanged, DWORD dwFlags)
  121. {
  122. m_pDefaultValue = pDefaultValue;
  123. m_pConverter = NULL;
  124. m_dwFlags = dwFlags;
  125. m_pPropertyChanged = pPropertyChanged;
  126. }
  128. CXTPMarkupPropertyMetadata::CXTPMarkupPropertyMetadata(CXTPMarkupObject* pDefaultValue, PFNCONVERTFROM pConverter, PFNPROPERTYCHANGED pPropertyChanged, DWORD dwFlags)
  129. {
  130. m_pDefaultValue = pDefaultValue;
  131. m_pConverter = pConverter;
  132. m_dwFlags = dwFlags;
  133. m_pPropertyChanged = pPropertyChanged;
  135. }
  139. CXTPMarkupPropertyMetadata::~CXTPMarkupPropertyMetadata()
  140. {
  141. if (m_pDefaultValue)
  142. {
  143. MARKUP_RELEASE(m_pDefaultValue);
  144. }
  145. }
  147. //////////////////////////////////////////////////////////////////////////
  148. // CXTPMarkupDependencyProperty
  150. int CXTPMarkupDependencyProperty::s_nCount = 0;
  152. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupDependencyProperty, CXTPMarkupObject);
  154. void CXTPMarkupDependencyProperty::RegisterMarkupClass()
  155. {
  157. }
  159. CXTPMarkupDependencyProperty::CXTPMarkupDependencyProperty()
  160. {
  161. m_lpszName = 0;
  162. m_pPropetyType = 0;
  163. m_pOwnerType = 0;
  164. m_bAttached = FALSE;
  165. m_pMetadata = NULL;
  166. m_nIndex = -1;
  167. }
  169. CXTPMarkupDependencyProperty::~CXTPMarkupDependencyProperty()
  170. {
  171. if (m_pMetadata)
  172. {
  173. delete m_pMetadata;
  174. }
  175. }
  178. CXTPMarkupDependencyProperty* CXTPMarkupDependencyProperty::RegisterCommon(CXTPMarkupDependencyProperty* dp, LPCWSTR lpszName, CXTPMarkupType* pPropetyType, CXTPMarkupType* pOwnerType, BOOL bAttached)
  179. {
  180. CXTPMarkupFromNameKey key(lpszName, pOwnerType);
  182. dp->m_lpszName = lpszName;
  183. dp->m_pPropetyType = pPropetyType;
  184. dp->m_pOwnerType = pOwnerType;
  185. dp->m_bAttached = bAttached;
  187. CXTPMarkupPropertyFromNameMap* pPropertyFromNameMap = GetPropertyMap();
  189. if (!dp->IsEvent())
  190. {
  191. dp->m_nIndex = s_nCount++;
  192. }
  194. pPropertyFromNameMap->SetAt(key, dp);
  196. return dp;
  197. }
  199. CXTPMarkupDependencyProperty* CXTPMarkupDependencyProperty::RegisterAttached(LPCWSTR lpszName, CXTPMarkupType* pPropetyType, CXTPMarkupType* pOwnerType, CXTPMarkupPropertyMetadata* pMetadata)
  200. {
  201. CXTPMarkupDependencyProperty* dp =  RegisterCommon(new CXTPMarkupDependencyProperty(), lpszName, pPropetyType, pOwnerType, TRUE);
  202. dp->m_pMetadata = pMetadata;
  203. return dp;
  204. }
  206. CXTPMarkupDependencyProperty* CXTPMarkupDependencyProperty::Register(LPCWSTR lpszName, CXTPMarkupType* pPropetyType, CXTPMarkupType* pOwnerType, CXTPMarkupPropertyMetadata* pMetadata)
  207. {
  208. CXTPMarkupDependencyProperty* dp = RegisterCommon(new CXTPMarkupDependencyProperty(), lpszName, pPropetyType, pOwnerType, FALSE);
  209. dp->m_pMetadata = pMetadata;
  210. return dp;
  211. }
  213. CXTPMarkupDependencyProperty* CXTPMarkupDependencyProperty::AddOwner(CXTPMarkupType* pOwnerType)
  214. {
  215. CXTPMarkupFromNameKey key(m_lpszName, pOwnerType);
  217. CXTPMarkupPropertyFromNameMap* pPropertyFromNameMap = GetPropertyMap();
  218. pPropertyFromNameMap->SetAt(key, this);
  220. AddRef();
  222. return this;
  223. }
  225. CXTPMarkupDependencyProperty* CXTPMarkupDependencyProperty::FindProperty(CXTPMarkupType* pRuntimeClass, LPCWSTR lpszAttribute)
  226. {
  227. CXTPMarkupPropertyFromNameMap* pMap = CXTPMarkupDependencyProperty::GetPropertyMap();
  229. while (pRuntimeClass != NULL)
  230. {
  231. CXTPMarkupFromNameKey nameKey(lpszAttribute, pRuntimeClass);
  232. CXTPMarkupDependencyProperty* pProperty = NULL;
  234. if (pMap->Lookup(nameKey, pProperty))
  235. return pProperty;
  237. pRuntimeClass = pRuntimeClass->GetBaseType();
  239. }
  241. return NULL;
  242. }
  244. //////////////////////////////////////////////////////////////////////////
  245. // CXTPMarkupType
  247. class CXTPMarkupType::CClassList
  248. {
  249. public:
  250. CClassList();
  251. ~CClassList();
  253. public:
  254. void Add(LPCWSTR lpszTag, CXTPMarkupType* pClass);
  255. CXTPMarkupType* Lookup(LPCWSTR lpszTag);
  257. public:
  258. CMap<LPCWSTR, LPCWSTR, CXTPMarkupType*, CXTPMarkupType*> m_mapTypes;
  259. CTypedSimpleList<CXTPMarkupType*> m_classList;
  261. };
  263. template<> inline BOOL AFXAPI CompareElements(const LPCWSTR* pElement1, const LPCWSTR* pElement2)
  264. {
  265. return wcscmp(*pElement1, *pElement2) == 0;
  266. }
  269. CXTPMarkupType::CClassList::CClassList()
  270. {
  271. m_classList.Construct(offsetof(CXTPMarkupType, m_pNextType));
  272. }
  274. CXTPMarkupType::CClassList::~CClassList()
  275. {
  276. CXTPMarkupType* pType = m_classList.GetHead();
  277. while (pType)
  278. {
  279. CXTPMarkupType* pTypeDelete = pType;
  281. pType = pType->m_pNextType;
  283. MARKUP_RELEASE(pTypeDelete);
  284. }
  286. }
  289. void CXTPMarkupType::CClassList::Add(LPCWSTR lpszTag, CXTPMarkupType* pClass)
  290. {
  291. if (lpszTag && lpszTag[0] != '')
  292. {
  293. ASSERT(Lookup(lpszTag) == NULL);
  294. m_mapTypes.SetAt(lpszTag, pClass);
  295. }
  296. m_classList.AddHead(pClass);
  297. }
  299. CXTPMarkupType* CXTPMarkupType::CClassList::Lookup(LPCWSTR lpszTag)
  300. {
  301. CXTPMarkupType* pType = NULL;
  303. if (m_mapTypes.Lookup(lpszTag, pType))
  304. {
  305. return pType;
  306. }
  308. return NULL;
  309. }
  311. CXTPMarkupType::CClassList* CXTPMarkupType::GetClassList()
  312. {
  313. static CClassList list;
  314. return &list;
  315. }
  318. CXTPMarkupType* CXTPMarkupType::LookupTag(LPCWSTR lpszTag)
  319. {
  320. return GetClassList()->Lookup(lpszTag);
  321. }
  323. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupType, CXTPMarkupObject)
  325. void CXTPMarkupType::RegisterMarkupClass()
  326. {
  328. }
  330. CXTPMarkupType::CXTPMarkupType()
  331. {
  332. m_lpszTag = NULL;
  333. m_lpszClassName = NULL;
  334. m_pfnCreateObject = NULL;
  335. m_pfnGetBaseType = NULL;
  336. m_pfnRegisterMarkupClass = NULL;
  337. m_pNextType = NULL;
  338. m_bRegister = FALSE;
  339. m_pTypeStyle = NULL;
  340. }
  342. CXTPMarkupType::CXTPMarkupType(LPCWSTR lpszTag, LPCWSTR lpszClassName, PFNCREATEOBJECT pfnCreateObject, PFNGETBASETYPE pfnGetBaseType, PFNREGISTERMARKUPCLASS pfnRegisterMarkupClass)
  343. {
  344. m_lpszTag = lpszTag;
  345. m_lpszClassName = lpszClassName;
  346. m_pfnCreateObject = pfnCreateObject;
  347. m_pfnGetBaseType = pfnGetBaseType;
  348. m_pfnRegisterMarkupClass = pfnRegisterMarkupClass;
  349. m_pNextType = NULL;
  350. m_bRegister = FALSE;
  351. m_pTypeStyle = NULL;
  353. GetClassList()->Add(lpszTag, this);
  354. }
  356. CXTPMarkupObject* CXTPMarkupType::ConvertFrom(CXTPMarkupObject* pObject) const
  357. {
  358. if (IsStringObject(pObject))
  359. {
  360. LPCWSTR lpszValue = *((CXTPMarkupString*)pObject);
  362. CXTPMarkupType* pType = GetClassList()->Lookup(lpszValue);
  363. if (pType)
  364. {
  365. pType->AddRef();
  366. return pType;
  367. }
  368. }
  370. return NULL;
  371. }
  373. CXTPMarkupType::~CXTPMarkupType()
  374. {
  375. if (m_pTypeStyle)
  376. {
  377. ((CXTPMarkupObject*)m_pTypeStyle)->Release();
  378. }
  379. }
  381. CXTPMarkupObject* CXTPMarkupType::CreateObject() const
  382. {
  383. return (*m_pfnCreateObject)();
  384. }
  386. CXTPMarkupType* CXTPMarkupType::GetBaseType() const
  387. {
  388. return (*m_pfnGetBaseType)();
  389. }
  391. void CXTPMarkupType::Register()
  392. {
  393. if (m_bRegister)
  394. return;
  396. CXTPMarkupType* pType = GetBaseType();
  397. if (pType && !pType->m_bRegister)
  398. pType->Register();
  400. m_bRegister = TRUE;
  401. (*m_pfnRegisterMarkupClass)();
  402. }
  404. void AFX_CDECL CXTPMarkupType::RegisterAll()
  405. {
  406. CXTPMarkupType* pType = GetClassList()->m_classList.GetHead();
  407. while (pType)
  408. {
  409. pType->Register();
  410. pType = pType->m_pNextType;
  411. }
  412. }
  414. BOOL CXTPMarkupType::IsDerivedFrom(const CXTPMarkupType* pBaseClass) const
  415. {
  416. const CXTPMarkupType* pClassThis = this;
  417. while (pClassThis != NULL)
  418. {
  419. if (pClassThis == pBaseClass)
  420. return TRUE;
  422. pClassThis = pClassThis->GetBaseType();
  423. }
  424. return FALSE;
  425. }
  427. CXTPMarkupObject* CXTPMarkupType::DynamicDownCast(CXTPMarkupType* pType, CXTPMarkupObject* pObject)
  428. {
  429. if (pObject != NULL && pObject->IsKindOf(pType))
  430. return pObject;
  431. else
  432. return NULL;
  433. }
  435. CXTPMarkupObject* CXTPMarkupType::StaticDownCast(CXTPMarkupType* pType, CXTPMarkupObject* pObject)
  436. {
  437. pType;
  438. ASSERT(pObject == NULL || pObject->IsKindOf(pType));
  440. return pObject;
  441. }
  443. //////////////////////////////////////////////////////////////////////////
  444. // CXTPMarkupProperties
  446. CXTPMarkupProperties::CXTPMarkupProperties(CXTPMarkupObject* pOwner)
  447. {
  448. m_pOwner = pOwner;
  449. m_nTableSize = CXTPMarkupDependencyProperty::s_nCount;
  450. m_pTable = new CXTPMarkupObject*[m_nTableSize];
  451. ZeroMemory(m_pTable, m_nTableSize * sizeof(CXTPMarkupObject*));
  452. }
  454. CXTPMarkupProperties::~CXTPMarkupProperties()
  455. {
  456. for (int i = 0; i < m_nTableSize; i++)
  457. {
  458. if (m_pTable[i]) m_pTable[i]->Release();
  459. }
  460. delete[] m_pTable;
  461. }
  463. BOOL CXTPMarkupProperties::IsPropertyValid(CXTPMarkupDependencyProperty* pProperty) const
  464. {
  465. if (pProperty->m_nIndex == -1)
  466. {
  467. ASSERT(FALSE);
  468. return FALSE;
  469. }
  470. if (pProperty->m_nIndex >= m_nTableSize)
  471. {
  472. ASSERT(FALSE);
  473. return FALSE;
  474. }
  475. return TRUE;
  476. }
  478. CXTPMarkupObject* CXTPMarkupProperties::Lookup(CXTPMarkupDependencyProperty* pProperty) const
  479. {
  480. if (!IsPropertyValid(pProperty))
  481. return NULL;
  483. return m_pTable[pProperty->m_nIndex];
  484. }
  486. void CXTPMarkupProperties::Copy(CXTPMarkupProperties* pOwner)
  487. {
  488. ASSERT(pOwner->m_nTableSize == m_nTableSize);
  490. for (int i = 0; i < pOwner->m_nTableSize; i++)
  491. {
  492. if (pOwner->m_pTable[i])
  493. {
  494. m_pTable[i] = pOwner->m_pTable[i];
  495. m_pTable[i]->AddRef();
  496. }
  497. }
  498. }
  500. void CXTPMarkupProperties::Set(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  501. {
  502. if (!IsPropertyValid(pProperty))
  503. return;
  505. int nIndex = pProperty->m_nIndex;
  507. if (m_pTable[nIndex])
  508. {
  509. if (m_pOwner) m_pTable[nIndex]->SetLogicalParent(NULL);
  510. MARKUP_RELEASE(m_pTable[nIndex]);
  512. m_pTable[nIndex] = NULL;
  513. }
  515. if (pValue)
  516. {
  517. m_pTable[nIndex] = pValue;
  518. if (m_pOwner) pValue->SetLogicalParent(m_pOwner);
  519. }
  520. }
  523. //////////////////////////////////////////////////////////////////////////
  524. // CXTPMarkupObject
  526. CXTPMarkupDependencyProperty* CXTPMarkupObject::m_pNameProperty = NULL;
  527. CXTPMarkupDependencyProperty* CXTPMarkupObject::m_pKeyProperty = NULL;
  529. CXTPMarkupObject* AFX_CDECL CXTPMarkupObject::CreateMarkupObject()
  530. {
  531. return new CXTPMarkupObject();
  532. }
  534. CXTPMarkupType* CXTPMarkupObject::GetMarkupBaseType()
  535. {
  536. return NULL;
  537. }
  539. const CXTPMarkupType* CXTPMarkupObject::typeCXTPMarkupObject = new CXTPMarkupType(
  540. NULL, L"CXTPMarkupObject", &CXTPMarkupObject::CreateMarkupObject, &CXTPMarkupObject::GetMarkupBaseType, &CXTPMarkupObject::RegisterMarkupClass);
  542. CXTPMarkupType* CXTPMarkupObject::GetType() const
  543. {
  544. return MARKUP_TYPE(CXTPMarkupObject);
  545. }
  547. void CXTPMarkupObject::RegisterMarkupClass()
  548. {
  549. m_pNameProperty = CXTPMarkupDependencyProperty::Register(L"x:Name", MARKUP_TYPE(CXTPMarkupString), MARKUP_TYPE(CXTPMarkupObject));
  550. m_pKeyProperty = CXTPMarkupDependencyProperty::Register(L"x:Key", MARKUP_TYPE(CXTPMarkupObject), MARKUP_TYPE(CXTPMarkupObject));
  551. }
  554. CXTPMarkupObject::CXTPMarkupObject()
  555. {
  556. m_dwRef = 1;
  557. m_pLogicalParent = NULL;
  558. m_lpMarkupTag = NULL;
  560. m_pProperties = NULL;
  561. }
  563. CXTPMarkupObject::~CXTPMarkupObject()
  564. {
  565. ASSERT(m_dwRef <= 1);
  567. SAFE_DELETE(m_pProperties);
  569. if (m_lpMarkupTag) delete[] m_lpMarkupTag;
  570. }
  572. DWORD CXTPMarkupObject::AddRef()
  573. {
  574. return InterlockedIncrement(&m_dwRef);
  575. }
  577. void CXTPMarkupObject::OnFinalRelease()
  578. {
  579. delete this;
  580. }
  582. DWORD CXTPMarkupObject::Release()
  583. {
  584. if (m_dwRef == 0)
  585. return 0;
  587. LONG lResult = InterlockedDecrement(&m_dwRef);
  588. if (lResult == 0)
  589. {
  590. OnFinalRelease();
  591. }
  592. return lResult;
  593. }
  595. CXTPMarkupObject* CXTPMarkupObject::ConvertFrom(CXTPMarkupObject* /*pObject*/) const
  596. {
  597. return NULL;
  598. }
  600. void CXTPMarkupObject::SetValue(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  601. {
  602. if (!pProperty)
  603. return;
  605. if (pValue != NULL && !pValue->GetType()->IsDerivedFrom(pProperty->GetPropetyType()))
  606. {
  607. ASSERT(FALSE);
  608. return;
  609. }
  611. if (pValue && !m_pProperties)
  612. {
  613. m_pProperties = new CXTPMarkupProperties(this);
  614. }
  616. CXTPMarkupObject* pOldValue = GetValue(pProperty);
  618. if (m_pProperties)
  619. {
  620. m_pProperties->Set(pProperty, pValue);
  621. }
  623. CXTPMarkupObject* pNewValue = GetValue(pProperty);
  625. if (::IsEqual(pNewValue, pOldValue))
  626. return;
  628. OnPropertyChanged(pProperty, pOldValue, pNewValue);
  630. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagInherited)
  631. {
  632. RecursePropertyChanged(pProperty, pOldValue, pNewValue);
  633. }
  635. }
  637. void CXTPMarkupObject::RecursePropertyChanged(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue)
  638. {
  639. int nCount = GetLogicalChildrenCount();
  641. for (int i = 0; i < nCount; i++)
  642. {
  643. CXTPMarkupObject* pObject = GetLogicalChild(i);
  644. if (!pObject)
  645. continue;
  647. if (pObject->IsKindOf(pProperty->GetOwnerType()))
  648. {
  649. pObject->OnPropertyChanged(pProperty, pOldValue, pNewValue);
  650. }
  652. pObject->RecursePropertyChanged(pProperty, pOldValue, pNewValue);
  653. }
  655. }
  657. void CXTPMarkupObject::OnPropertyChanged(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pOldValue, CXTPMarkupObject* pNewValue)
  658. {
  659. if (pProperty->GetMetadata() && pProperty->GetMetadata()->m_pPropertyChanged != NULL)
  660. {
  661. CXTPMarkupPropertyChangedEventArgs e(pProperty, pOldValue, pNewValue);
  662. (*pProperty->GetMetadata()->m_pPropertyChanged)(this, &e);
  663. }
  664. }
  667. CXTPMarkupObject* CXTPMarkupObject::GetValueSource(CXTPMarkupDependencyProperty* pProperty) const
  668. {
  669. CXTPMarkupObject* pValue = GetValueCore(pProperty);
  670. if (pValue)
  671. {
  672. return (CXTPMarkupObject*)this;
  673. }
  675. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagInherited)
  676. {
  677. CXTPMarkupObject* pLogicalParent = GetLogicalParent();
  678. while (pLogicalParent)
  679. {
  680. pValue = pLogicalParent->GetValueCore(pProperty);
  682. if (pValue)
  683. return pLogicalParent;
  685. pLogicalParent = pLogicalParent->GetLogicalParent();
  686. }
  687. }
  689. return NULL;
  690. }
  692. CXTPMarkupObject* CXTPMarkupObject::GetValueCore(CXTPMarkupDependencyProperty* pProperty) const
  693. {
  694. CXTPMarkupObject* pValue = m_pProperties ? m_pProperties->Lookup(pProperty) : NULL;
  696. return pValue;
  697. }
  699. CXTPMarkupObject* CXTPMarkupObject::GetValue(CXTPMarkupDependencyProperty* pProperty) const
  700. {
  701. CXTPMarkupObject* pValue = GetValueCore(pProperty);
  702. if (pValue)
  703. return pValue;
  705. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagInherited)
  706. {
  707. CXTPMarkupObject* pLogicalParent = GetLogicalParent();
  708. while (pLogicalParent)
  709. {
  710. pValue = pLogicalParent->GetValueCore(pProperty);
  711. if (pValue)
  712. return pValue;
  714. pLogicalParent = pLogicalParent->GetLogicalParent();
  715. }
  716. }
  718. if (pProperty->GetMetadata() && pProperty->GetMetadata()->m_pDefaultValue)
  719. return pProperty->GetMetadata()->m_pDefaultValue;
  721. return NULL;
  722. }
  724. void CXTPMarkupObject::SetLogicalParent(CXTPMarkupObject* pObject)
  725. {
  726. m_pLogicalParent = pObject;
  727. }
  729. CXTPMarkupObject* CXTPMarkupObject::GetLogicalParent() const
  730. {
  731. return m_pLogicalParent;
  732. }
  734. void CXTPMarkupObject::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  735. {
  736. if (IsStringObject(pContent))
  737. {
  738. pBuilder->ThrowBuilderException(CXTPMarkupBuilder::FormatString(
  739. _T("Cannot convert the string '%ls' into a '%ls' object"),
  740. (LPCTSTR)(LPCWSTR)*((CXTPMarkupString*)pContent), (LPCTSTR)GetType()->m_lpszClassName));
  741. }
  742. else
  743. {
  744. pBuilder->ThrowBuilderException(CXTPMarkupBuilder::FormatString(_T("Cannot add content to an object of type '%ls'"),
  745. (LPCTSTR)GetType()->m_lpszClassName));
  746. }
  747. }
  749. BOOL CXTPMarkupObject::HasContentObject() const
  750. {
  751. return FALSE;
  752. }
  754. BOOL CXTPMarkupObject::AllowWhiteSpaceContent() const
  755. {
  756. return FALSE;
  757. }
  759. void CXTPMarkupObject::SetPropertyObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  760. {
  761. ASSERT(pValue);
  763. if (pValue != NULL && !pValue->IsKindOf(pProperty->GetPropetyType()))
  764. {
  765. CXTPMarkupObject* pNewValue = pBuilder->ConvertValue(pProperty, pValue);
  767. MARKUP_RELEASE(pValue);
  768. pValue = pNewValue;
  769. }
  771. SetValue(pProperty, pValue);
  772. }
  774. CXTPMarkupObject* CXTPMarkupObject::FindName(LPCWSTR lpszName)
  775. {
  776. CXTPMarkupString* pName = MARKUP_STATICCAST(CXTPMarkupString, GetValue(m_pNameProperty));
  777. if (pName && (wcscmp(*pName, lpszName) == 0))
  778. return this;
  780. int nCount = GetLogicalChildrenCount();
  781. for (int i = 0; i < nCount; i++)
  782. {
  783. CXTPMarkupObject* pResult = GetLogicalChild(i)->FindName(lpszName);
  784. if (pResult)
  785. {
  786. return pResult;
  787. }
  788. }
  790. return NULL;
  791. }
  793. int CXTPMarkupObject::GetLogicalChildrenCount() const
  794. {
  795. return 0;
  796. }
  798. CXTPMarkupObject* CXTPMarkupObject::GetLogicalChild(int /*nIndex*/) const
  799. {
  800. ASSERT(FALSE);
  801. return NULL;
  802. }
  806. BOOL CXTPMarkupObject::IsKindOf(const CXTPMarkupType* pClass) const
  807. {
  808. CXTPMarkupType* pTypeThis = GetType();
  809. return pTypeThis->IsDerivedFrom(pClass);
  810. }
  812. //////////////////////////////////////////////////////////////////////////
  813. // CXTPMarkupAutoPtr
  815. class CXTPMarkupAutoPtr
  816. {
  817. public:
  818. CXTPMarkupAutoPtr(CXTPMarkupObject* pObject = NULL)
  819. {
  820. m_pObject = pObject;
  821. }
  823. ~CXTPMarkupAutoPtr()
  824. {
  825. MARKUP_RELEASE(m_pObject);
  826. }
  828. CXTPMarkupObject* AddRef() const
  829. {
  830. m_pObject->AddRef();
  831. return m_pObject;
  832. }
  834. public:
  835. CXTPMarkupObject* m_pObject;
  836. };
  838. //////////////////////////////////////////////////////////////////////////
  839. // CXTPMarkupThickness
  840. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupThickness, CXTPMarkupObject);
  842. void CXTPMarkupThickness::RegisterMarkupClass()
  843. {
  845. }
  847. CXTPMarkupThickness* CXTPMarkupThickness::CreateValue()
  848. {
  849. static CXTPMarkupAutoPtr defaultValues(new CXTPMarkupThickness());
  850. return (CXTPMarkupThickness*)defaultValues.AddRef();
  851. }
  853. CXTPMarkupThickness::CXTPMarkupThickness(long uniformLength)
  854. {
  855. left = top = right = bottom = uniformLength;
  856. }
  858. CXTPMarkupThickness::CXTPMarkupThickness(long l, long t, long r, long b)
  859. {
  860. left = l;
  861. top = t;
  862. right = r;
  863. bottom = b;
  864. }
  866. CRect CXTPMarkupThickness::HelperDeflateRect(CRect rt, CXTPMarkupThickness* thick)
  867. {
  868. if (!thick)
  869. return rt;
  871. return CRect(CPoint(rt.left + thick->left, rt.top + thick->top),
  872. CSize(max(0, (rt.Width() - thick->left) - thick->right), max(0, (rt.Height() - thick->top) - thick->bottom)));
  873. }
  876. CXTPMarkupObject* CXTPMarkupThickness::ConvertFrom(CXTPMarkupObject* pObject) const
  877. {
  878. if (IsStringObject(pObject))
  879. {
  880. LPCWSTR lpszValue = *((CXTPMarkupString*)pObject);
  882. if (wcschr(lpszValue, L',') == NULL)
  883. {
  884. int nThickness = _wtoi(lpszValue);
  885. return new CXTPMarkupThickness(nThickness);
  886. }
  887. else
  888. {
  889. int left = 0, top = 0, right = 0, bottom = 0;
  890. if ( WSCANF_S(lpszValue, L"%i, %i, %i, %i", &left, &top, &right, &bottom) != 4)
  891. return NULL;
  893. return new CXTPMarkupThickness(left, top, right, bottom);
  894. }
  896. }
  898. return NULL;
  899. }
  901. BOOL CXTPMarkupThickness::IsEqual(const CXTPMarkupObject* pObject) const
  902. {
  903. if (!pObject)
  904. return FALSE;
  906. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupThickness))
  907. return FALSE;
  909. return left == ((CXTPMarkupThickness*)pObject)->left &&
  910. top == ((CXTPMarkupThickness*)pObject)->top &&
  911. right == ((CXTPMarkupThickness*)pObject)->right &&
  912. bottom == ((CXTPMarkupThickness*)pObject)->bottom;
  913. }
  915. //////////////////////////////////////////////////////////////////////////
  916. // CXTPMarkupInt
  918. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupInt, CXTPMarkupObject);
  920. void CXTPMarkupInt::RegisterMarkupClass()
  921. {
  923. }
  925. CXTPMarkupInt::CXTPMarkupInt(int nValue)
  926. {
  927. m_nValue = nValue;
  928. }
  930. CXTPMarkupObject* CXTPMarkupInt::ConvertFrom(CXTPMarkupObject* pObject) const
  931. {
  932. if (IsStringObject(pObject))
  933. {
  934. return new CXTPMarkupInt(_wtoi(*((CXTPMarkupString*)pObject)));
  935. }
  937. return NULL;
  938. }
  940. BOOL CXTPMarkupInt::IsEqual(const CXTPMarkupObject* pObject) const
  941. {
  942. if (!pObject)
  943. return FALSE;
  945. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupInt))
  946. return FALSE;
  948. return m_nValue == ((CXTPMarkupInt*)pObject)->m_nValue;
  949. }
  951. //////////////////////////////////////////////////////////////////////////
  952. // CXTPMarkupDouble
  954. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupDouble, CXTPMarkupObject);
  956. void CXTPMarkupDouble::RegisterMarkupClass()
  957. {
  959. }
  961. CXTPMarkupDouble::CXTPMarkupDouble(double dValue)
  962. {
  963. m_dValue = dValue;
  964. }
  966. CXTPMarkupObject* CXTPMarkupDouble::ConvertFrom(CXTPMarkupObject* pObject) const
  967. {
  968. if (IsStringObject(pObject))
  969. {
  970. LPCWSTR lpszValue = *(CXTPMarkupString*)pObject;
  972. float x = 0;
  973. if (WSCANF_S(lpszValue, L"%f", &x) == 1)
  974. return new CXTPMarkupDouble((double)x);
  975. }
  977. return NULL;
  978. }
  980. BOOL CXTPMarkupDouble::IsEqual(const CXTPMarkupObject* pObject) const
  981. {
  982. if (!pObject)
  983. return FALSE;
  985. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupDouble))
  986. return FALSE;
  988. return m_dValue == ((CXTPMarkupDouble*)pObject)->m_dValue;
  989. }
  991. //////////////////////////////////////////////////////////////////////////
  992. // CXTPMarkupEnum
  994. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupEnum, CXTPMarkupObject);
  996. void CXTPMarkupEnum::RegisterMarkupClass()
  997. {
  999. }
  1001. CXTPMarkupEnum::CXTPMarkupEnum(int nValue)
  1002. {
  1003. m_nValue = nValue;
  1004. }
  1006. CXTPMarkupObject* CXTPMarkupEnum::ConvertFrom(CXTPMarkupObject* /*pObject*/) const
  1007. {
  1008. return NULL;
  1009. }
  1011. BOOL CXTPMarkupEnum::IsEqual(const CXTPMarkupObject* pObject) const
  1012. {
  1013. if (!pObject)
  1014. return FALSE;
  1016. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupEnum))
  1017. return FALSE;
  1019. return m_nValue == ((CXTPMarkupEnum*)pObject)->m_nValue;
  1020. }
  1022. CXTPMarkupEnum* CXTPMarkupEnum::CreateValue(int nValue)
  1023. {
  1024. static CXTPMarkupAutoPtr defaultValues[8];
  1026. if (nValue > 7 || nValue < 0)
  1027. return new CXTPMarkupEnum(nValue);
  1029. CXTPMarkupObject*& pObject = defaultValues[nValue].m_pObject;
  1031. if (pObject == NULL)
  1032. pObject = new CXTPMarkupEnum(nValue);
  1034. pObject->AddRef();
  1035. return (CXTPMarkupEnum*)pObject;
  1036. }
  1039. //////////////////////////////////////////////////////////////////////////
  1040. // CXTPMarkupBool
  1042. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupBool, CXTPMarkupObject);
  1044. void CXTPMarkupBool::RegisterMarkupClass()
  1045. {
  1047. }
  1049. CXTPMarkupBool::CXTPMarkupBool(BOOL bValue)
  1050. {
  1051. m_bValue = bValue;
  1052. }
  1054. CXTPMarkupBool* CXTPMarkupBool::CreateTrueValue()
  1055. {
  1056. static CXTPMarkupAutoPtr defaultValue(new CXTPMarkupBool(TRUE));
  1057. return (CXTPMarkupBool*)defaultValue.AddRef();
  1058. }
  1060. CXTPMarkupBool* CXTPMarkupBool::CreateFalseValue()
  1061. {
  1062. static CXTPMarkupAutoPtr defaultValue(new CXTPMarkupBool(FALSE));
  1063. return (CXTPMarkupBool*)defaultValue.AddRef();
  1064. }
  1066. CXTPMarkupObject* CXTPMarkupBool::ConvertFrom(CXTPMarkupObject* pObject) const
  1067. {
  1068. if (IsStringObject(pObject))
  1069. {
  1070. if (_wcsicmp(*((CXTPMarkupString*)pObject), L"True") == 0)
  1071. {
  1072. return CreateTrueValue();
  1073. }
  1075. if (_wcsicmp(*((CXTPMarkupString*)pObject), L"False") == 0)
  1076. {
  1077. return CreateFalseValue();
  1078. }
  1079. }
  1080. return FALSE;
  1081. }
  1083. UINT CXTPMarkupBool::GetHashKey() const
  1084. {
  1085. return m_bValue;
  1086. }
  1088. BOOL CXTPMarkupBool::IsEqual(const CXTPMarkupObject* pObject) const
  1089. {
  1090. if (!pObject)
  1091. return FALSE;
  1093. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupBool))
  1094. return FALSE;
  1096. if (m_bValue != ((CXTPMarkupBool*)pObject)->m_bValue)
  1097. return FALSE;
  1099. return TRUE;
  1100. }
  1102. //////////////////////////////////////////////////////////////////////////
  1103. // CXTPMarkupColor
  1105. IMPLEMENT_MARKUPCLASS(L"Color", CXTPMarkupColor, CXTPMarkupObject);
  1107. void CXTPMarkupColor::RegisterMarkupClass()
  1108. {
  1110. }
  1112. CXTPMarkupColor::CXTPMarkupColor(COLORREF nValue)
  1113. {
  1114. m_nValue = nValue;
  1115. }
  1118. BOOL CXTPMarkupColor::ConvertFromString(LPCWSTR lpszValue, COLORREF& clr)
  1119. {
  1120. if (lpszValue[0] == '#' && wcslen(lpszValue) == 7)
  1121. {
  1122. COLORREF clrRed = 0, clrGreen = 0, clrBlue = 0;
  1123. if (WSCANF_S(lpszValue, L"#%2x%2x%2x", &clrRed, &clrGreen, &clrBlue) != 3)
  1124. return FALSE;
  1126. clr = RGB(clrRed, clrGreen, clrBlue);
  1127. return TRUE;
  1128. }
  1130. if (lpszValue[0] == '#' && wcslen(lpszValue) == 9)
  1131. {
  1132. COLORREF clrRed = 0, clrGreen = 0, clrBlue = 0, clrAlpha = 0;
  1133. if (WSCANF_S(lpszValue, L"#%2x%2x%2x%2x", &clrAlpha, &clrRed, &clrGreen, &clrBlue) != 4)
  1134. return FALSE;
  1136. clr = RGB(clrRed, clrGreen, clrBlue);
  1137. return TRUE;
  1138. }
  1140. if (lpszValue[0] != '#')
  1141. {
  1142. if (CXTPMarkupBuilder::ColorStringToKnownColor(lpszValue, clr))
  1143. {
  1144. return TRUE;
  1145. }
  1146. }
  1147. return FALSE;
  1148. }
  1150. CXTPMarkupObject* CXTPMarkupColor::ConvertFrom(CXTPMarkupObject* pObject) const
  1151. {
  1152. if (IsStringObject(pObject))
  1153. {
  1154. COLORREF clr;
  1155. if (ConvertFromString(*((CXTPMarkupString*)pObject), clr))
  1156. {
  1157. return new CXTPMarkupColor(clr);
  1158. }
  1159. }
  1161. return NULL;
  1162. }
  1164. BOOL CXTPMarkupColor::IsEqual(const CXTPMarkupObject* pObject) const
  1165. {
  1166. if (!pObject)
  1167. return FALSE;
  1169. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupColor))
  1170. return FALSE;
  1172. return m_nValue == ((CXTPMarkupColor*)pObject)->m_nValue;
  1173. }
  1175. void CXTPMarkupColor::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  1176. {
  1177. if (IsStringObject(pContent))
  1178. {
  1179. COLORREF clr;
  1180. if (ConvertFromString(*((CXTPMarkupString*)pContent), clr))
  1181. {
  1182. m_nValue = clr;
  1183. MARKUP_RELEASE(pContent);
  1184. return;
  1185. }
  1186. }
  1188. CXTPMarkupObject::SetContentObject(pBuilder, pContent);
  1189. }
  1192. //////////////////////////////////////////////////////////////////////////
  1193. // CXTPMarkupString
  1195. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupString, CXTPMarkupObject);
  1197. void CXTPMarkupString::RegisterMarkupClass()
  1198. {
  1200. }
  1202. CXTPMarkupString::CXTPMarkupString(LPCWSTR lpszValue, int nLength)
  1203. {
  1204. m_nLength = !lpszValue ? 0 : nLength == -1 ? (int)wcslen(lpszValue) : nLength;
  1206. m_lpszValue = new WCHAR[m_nLength + 1];
  1208. if (!lpszValue)
  1209. m_lpszValue[0] = 0;
  1210. else if (nLength == -1)
  1211. memcpy(m_lpszValue, lpszValue, (m_nLength + 1) * sizeof(WCHAR));
  1212. else
  1213. {
  1214. memcpy(m_lpszValue, lpszValue, nLength * sizeof(WCHAR));
  1215. m_lpszValue[nLength] = 0;
  1216. }
  1217. }
  1219. CXTPMarkupString* CXTPMarkupString::CreateValue(LPCWSTR lpszString, int nLength)
  1220. {
  1221. if (lpszString == 0 || nLength == 0 || lpszString[0] == 0)
  1222. {
  1223. static CXTPMarkupAutoPtr stringEmpty(new CXTPMarkupString(NULL, 0));
  1224. return (CXTPMarkupString*)stringEmpty.AddRef();
  1225. }
  1227. if (lpszString[1] != 0)
  1228. return new CXTPMarkupString(lpszString, nLength);
  1230. if (lpszString[0] == L' ')
  1231. {
  1232. static CXTPMarkupAutoPtr stringSpace(new CXTPMarkupString(L" ", 1));
  1233. return (CXTPMarkupString*)stringSpace.AddRef();
  1234. }
  1236. if (lpszString[0] == L'n')
  1237. {
  1238. static CXTPMarkupAutoPtr stringLineBreak(new CXTPMarkupString(L"n", 1));
  1239. return (CXTPMarkupString*)stringLineBreak.AddRef();
  1240. }
  1242. return new CXTPMarkupString(lpszString, nLength);
  1243. }
  1245. UINT CXTPMarkupString::GetHashKey() const
  1246. {
  1247. LPCWSTR key = m_lpszValue;
  1249. UINT nHash = 0;
  1250. while (*key)
  1251. nHash = (nHash<<5) + nHash + *key++;
  1252. return nHash;
  1253. }
  1255. BOOL CXTPMarkupString::IsEqual(const CXTPMarkupObject* pObject) const
  1256. {
  1257. if (!pObject)
  1258. return FALSE;
  1260. if (pObject->GetType() != MARKUP_TYPE(CXTPMarkupString))
  1261. return FALSE;
  1263. if (m_nLength != ((CXTPMarkupString*)pObject)->m_nLength)
  1264. return FALSE;
  1266. return wcscmp(m_lpszValue, ((CXTPMarkupString*)pObject)->m_lpszValue) == 0;
  1267. }
  1270. CXTPMarkupString::~CXTPMarkupString()
  1271. {
  1272. delete[] m_lpszValue;
  1273. }
  1275. //////////////////////////////////////////////////////////////////////////
  1276. // CXTPMarkupCollection
  1278. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupCollection, CXTPMarkupObject);
  1280. void CXTPMarkupCollection::RegisterMarkupClass()
  1281. {
  1283. }
  1285. CXTPMarkupCollection::CXTPMarkupCollection()
  1286. {
  1287. m_pElementType = NULL;
  1288. m_bLogicalParent = TRUE;
  1289. }
  1291. CXTPMarkupCollection::~CXTPMarkupCollection()
  1292. {
  1293. RemoveAll();
  1294. }
  1296. void CXTPMarkupCollection::RemoveAll()
  1297. {
  1298. for (int i = 0; i < m_arrItems.GetSize(); i++)
  1299. {
  1300. if (m_bLogicalParent) m_arrItems[i]->SetLogicalParent(NULL);
  1301. m_arrItems[i]->Release();
  1302. }
  1303. m_arrItems.RemoveAll();
  1304. }
  1306. void CXTPMarkupCollection::Remove(int nIndex)
  1307. {
  1308. if (nIndex < m_arrItems.GetSize())
  1309. {
  1310. CXTPMarkupObject* pItem = m_arrItems[nIndex];
  1311. m_arrItems.RemoveAt(nIndex);
  1313. if (m_bLogicalParent) pItem->SetLogicalParent(NULL);
  1314. pItem->Release();
  1315. }
  1316. }
  1318. void CXTPMarkupCollection::Add(CXTPMarkupObject* pElement)
  1319. {
  1320. ASSERT(pElement);
  1321. ASSERT(m_pElementType);
  1322. ASSERT(pElement->IsKindOf(m_pElementType));
  1324. if (!pElement || !pElement->IsKindOf(m_pElementType))
  1325. return;
  1327. if (m_bLogicalParent)
  1328. {
  1329. ASSERT(pElement->GetLogicalParent() == NULL);
  1330. pElement->SetLogicalParent(this);
  1331. }
  1333. int nIndex = (int)m_arrItems.Add(pElement);
  1335. OnItemAdded(pElement, nIndex);
  1336. }
  1338. int CXTPMarkupCollection::IndexOf(CXTPMarkupObject* pElement) const
  1339. {
  1340. for (int i = 0; i < m_arrItems.GetSize(); i++)
  1341. {
  1342. if (pElement == m_arrItems[i])
  1343. return i;
  1344. }
  1345. return -1;
  1346. }
  1348. void CXTPMarkupCollection::OnItemAdded(CXTPMarkupObject* /*pItem*/, int /*nIndex*/)
  1349. {
  1351. }
  1353. void CXTPMarkupCollection::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  1354. {
  1355. ASSERT(m_pElementType);
  1357. if (pContent->IsKindOf(m_pElementType))
  1358. {
  1359. Add(pContent);
  1360. }
  1361. else
  1362. {
  1363. pBuilder->ThrowBuilderException(CXTPMarkupBuilder::FormatString(_T("'%ls' object cannot be added to '%ls'. Object cannot be converted to type '%ls'"),
  1364. (LPCTSTR)pContent->GetType()->m_lpszClassName, (LPCTSTR)GetType()->m_lpszClassName, (LPCTSTR)m_pElementType->m_lpszClassName));
  1365. }
  1366. }
  1368. BOOL CXTPMarkupCollection::HasContentObject() const
  1369. {
  1370. return GetCount() > 0;
  1371. }
  1373. int CXTPMarkupCollection::GetLogicalChildrenCount() const
  1374. {
  1375. return (int)m_arrItems.GetSize();
  1376. }
  1378. CXTPMarkupObject* CXTPMarkupCollection::GetLogicalChild(int nIndex) const
  1379. {
  1380. return m_arrItems[nIndex];
  1381. }