XTPMarkupResourceDictionary.cpp
上传用户:szled88
上传日期:2015-04-09
资源大小:43957k
文件大小:12k
源码类别:

对话框与窗口

开发平台:

Visual C++

  1. // XTPMarkupResourceDictionary.cpp: implementation of the CXTPMarkupResourceDictionary 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. /////////////////////////////////////////////////////////////////////////////
  20. #include "stdafx.h"
  21. #include "XTPMarkupResourceDictionary.h"
  22. #include "XTPMarkupFrameworkElement.h"
  23. #include "XTPMarkupBuilder.h"
  24. #ifdef _DEBUG
  25. #undef THIS_FILE
  26. static char THIS_FILE[]=__FILE__;
  27. #define new DEBUG_NEW
  28. #endif
  29. //////////////////////////////////////////////////////////////////////////
  30. // CXTPMarkupResourceDictionary
  31. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupResourceDictionary, CXTPMarkupObject)
  32. void CXTPMarkupResourceDictionary::RegisterMarkupClass()
  33. {
  34. }
  35. CXTPMarkupResourceDictionary::CXTPMarkupResourceDictionary()
  36. {
  37. }
  38. CXTPMarkupResourceDictionary::~CXTPMarkupResourceDictionary()
  39. {
  40. CXTPMarkupObject* pKey;
  41. CXTPMarkupObject* pValue;
  42. POSITION pos = m_mapDictionary.GetStartPosition();
  43. while (pos)
  44. {
  45. m_mapDictionary.GetNextAssoc(pos, pKey, pValue);
  46. MARKUP_RELEASE(pKey);
  47. MARKUP_RELEASE(pValue);
  48. }
  49. }
  50. CXTPMarkupObject* CXTPMarkupResourceDictionary::Lookup(const CXTPMarkupObject* pKey) const
  51. {
  52. CXTPMarkupObject* pValue;
  53. if (m_mapDictionary.Lookup((CXTPMarkupObject*)pKey, pValue))
  54. return pValue;
  55. return NULL;
  56. }
  57. void CXTPMarkupResourceDictionary::Add(CXTPMarkupObject* pKey, CXTPMarkupObject* pValue)
  58. {
  59. m_mapDictionary.SetAt(pKey, pValue);
  60. }
  61. CXTPMarkupObject* CXTPMarkupResourceDictionary::GetObjectKey(CXTPMarkupObject* pContent) const
  62. {
  63. if (!pContent)
  64. return NULL;
  65. CXTPMarkupObject* pKey = pContent->GetValue(m_pKeyProperty);
  66. if (pKey)
  67. return pKey;
  68. if (MARKUP_DYNAMICCAST(CXTPMarkupStyle, pContent))
  69. {
  70. return pContent->GetValue(CXTPMarkupStyle::m_pTargetTypeProperty);
  71. }
  72. return NULL;
  73. }
  74. void CXTPMarkupResourceDictionary::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  75. {
  76. CXTPMarkupObject* pKey = GetObjectKey(pContent);
  77. if (pKey == NULL)
  78. {
  79. pBuilder->ThrowBuilderException(_T("Objects added to Dictionary must have Key attribute or some other type of associated Key"));
  80. }
  81. if (Lookup(pKey))
  82. {
  83. pBuilder->ThrowBuilderException(_T("Dictionary key is already used. Key attributes must be unique."));
  84. }
  85. MARKUP_ADDREF(pKey);
  86. Add(pKey, pContent);
  87. }
  88. CXTPMarkupObject* CXTPMarkupResourceDictionary::FindResource(const CXTPMarkupObject* pElement, const CXTPMarkupObject* pKey)
  89. {
  90. if (pElement->IsKindOf(MARKUP_TYPE(CXTPMarkupResourceDictionary)))
  91. {
  92. return ((CXTPMarkupResourceDictionary*)pElement)->Lookup(pKey);
  93. }
  94. while (pElement)
  95. {
  96. CXTPMarkupResourceDictionary* pResources = MARKUP_STATICCAST(CXTPMarkupResourceDictionary, pElement->GetValue(CXTPMarkupStyle::m_pResourcesProperty));
  97. if (pResources)
  98. {
  99.  CXTPMarkupObject* pValue = pResources->Lookup(pKey);
  100.  if (pValue)
  101.  return pValue;
  102. }
  103. CXTPMarkupStyle* pStyle = MARKUP_STATICCAST(CXTPMarkupStyle, pElement->GetValue(CXTPMarkupFrameworkElement::m_pStyleProperty));
  104. if (pStyle)
  105. {
  106. CXTPMarkupObject* pValue = pStyle->FindResource(pKey);
  107. if (pValue)
  108. return pValue;
  109. }
  110. if (pElement->GetType() == MARKUP_TYPE(CXTPMarkupStyle))
  111. return NULL;
  112. pElement = pElement->GetLogicalParent();
  113. }
  114. return NULL;
  115. }
  116. //////////////////////////////////////////////////////////////////////////
  117. // CXTPMarkupSetter
  118. CXTPMarkupDependencyProperty* CXTPMarkupSetter::m_pPropertyProperty = NULL;
  119. CXTPMarkupDependencyProperty* CXTPMarkupSetter::m_pValueProperty = NULL;
  120. IMPLEMENT_MARKUPCLASS(L"Setter", CXTPMarkupSetter, CXTPMarkupObject);
  121. void CXTPMarkupSetter::RegisterMarkupClass()
  122. {
  123. m_pPropertyProperty = CXTPMarkupDependencyProperty::Register(L"Property", MARKUP_TYPE(CXTPMarkupObject), MARKUP_TYPE(CXTPMarkupSetter));
  124. m_pValueProperty = CXTPMarkupDependencyProperty::Register(L"Value", MARKUP_TYPE(CXTPMarkupObject), MARKUP_TYPE(CXTPMarkupSetter));
  125. }
  126. CXTPMarkupSetter::CXTPMarkupSetter()
  127. {
  128. }
  129. CXTPMarkupSetter::CXTPMarkupSetter(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  130. {
  131. ASSERT(pProperty && pValue);
  132. pProperty->AddRef();
  133. SetValue(m_pPropertyProperty, pProperty);
  134. SetValue(m_pValueProperty, pValue);
  135. }
  136. //////////////////////////////////////////////////////////////////////////
  137. // CXTPMarkupSetterColection
  138. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupSetterColection, CXTPMarkupCollection);
  139. void CXTPMarkupSetterColection::RegisterMarkupClass()
  140. {
  141. }
  142. CXTPMarkupSetterColection::CXTPMarkupSetterColection()
  143. {
  144. m_pElementType = MARKUP_TYPE(CXTPMarkupSetter);
  145. }
  146. //////////////////////////////////////////////////////////////////////////
  147. // CXTPMarkupStyle
  148. CXTPMarkupDependencyProperty* CXTPMarkupStyle::m_pTargetTypeProperty = NULL;
  149. CXTPMarkupDependencyProperty* CXTPMarkupStyle::m_pBasedOnProperty = NULL;
  150. CXTPMarkupDependencyProperty* CXTPMarkupStyle::m_pResourcesProperty = NULL;
  151. CXTPMarkupDependencyProperty* CXTPMarkupStyle::m_pTriggersProperty = NULL;
  152. IMPLEMENT_MARKUPCLASS(L"Style", CXTPMarkupStyle, CXTPMarkupObject)
  153. void CXTPMarkupStyle::RegisterMarkupClass()
  154. {
  155. CXTPMarkupSetter::RegisterType();
  156. CXTPMarkupTrigger::RegisterType();
  157. m_pResourcesProperty = CXTPMarkupDependencyProperty::Register(L"Resources", MARKUP_TYPE(CXTPMarkupResourceDictionary), MARKUP_TYPE(CXTPMarkupStyle));
  158. m_pTargetTypeProperty = CXTPMarkupDependencyProperty::Register(L"TargetType", MARKUP_TYPE(CXTPMarkupType), MARKUP_TYPE(CXTPMarkupStyle));
  159. m_pBasedOnProperty = CXTPMarkupDependencyProperty::Register(L"BasedOn", MARKUP_TYPE(CXTPMarkupStyle), MARKUP_TYPE(CXTPMarkupStyle));
  160. m_pTriggersProperty = CXTPMarkupDependencyProperty::Register(L"Triggers", MARKUP_TYPE(CXTPMarkupTriggerCollection), MARKUP_TYPE(CXTPMarkupStyle));
  161. }
  162. CXTPMarkupStyle::CXTPMarkupStyle()
  163. {
  164. m_pSetters = new CXTPMarkupSetterColection();
  165. m_pSetters->SetLogicalParent(this);
  166. m_bSealed = FALSE;
  167. m_pProperties = NULL;
  168. }
  169. CXTPMarkupStyle::~CXTPMarkupStyle()
  170. {
  171. if (m_pSetters)
  172. {
  173. m_pSetters->SetLogicalParent(NULL);
  174. MARKUP_RELEASE(m_pSetters);
  175. }
  176. MARKUP_RELEASE(m_pProperties);
  177. }
  178. void CXTPMarkupStyle::ResolveTriggerProperty(CXTPMarkupBuilder* pBuilder, CXTPMarkupTrigger* pTrigger)
  179. {
  180. ResolveSetterProperty(pBuilder, pTrigger);
  181. CXTPMarkupSetterColection* pSetters = pTrigger->GetSetters();
  182. int nCount = pSetters ? pSetters->GetCount() : 0;
  183. for (int i = 0; i < nCount; i++)
  184. {
  185. ResolveSetterProperty(pBuilder, pSetters->GetItem(i));
  186. }
  187. }
  188. void CXTPMarkupStyle::ResolveSetterProperty(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pSetter)
  189. {
  190. CXTPMarkupType* pTargetType = MARKUP_STATICCAST(CXTPMarkupType, GetValue(m_pTargetTypeProperty));
  191. CXTPMarkupDependencyProperty* pProperty = (CXTPMarkupDependencyProperty*)pSetter->GetValue(CXTPMarkupSetter::m_pPropertyProperty);
  192. if (!pProperty)
  193. {
  194. pBuilder->ThrowBuilderException(_T("Must specify both Property and Value for Setter."));
  195. }
  196. if (pProperty->GetType() == MARKUP_TYPE(CXTPMarkupDependencyProperty))
  197. {
  198. }
  199. else if (IsStringObject(pProperty))
  200. {
  201. LPCWSTR lpszTagName = *((CXTPMarkupString*)pProperty);
  202. pProperty = pBuilder->FindProperty(pTargetType, lpszTagName);
  203. if (pProperty == NULL)
  204. {
  205. pBuilder->ThrowBuilderException(pBuilder->FormatString(_T("Cannot find the Style Property '%ls'"), (LPCTSTR)lpszTagName));
  206. }
  207. pProperty->AddRef();
  208. pSetter->SetValue(CXTPMarkupSetter::m_pPropertyProperty, pProperty);
  209. }
  210. else
  211. {
  212. pBuilder->ThrowBuilderException(_T("Must specify both Property and Value for Setter."));
  213. }
  214. CXTPMarkupObject* pValue = pSetter->GetValue(CXTPMarkupSetter::m_pValueProperty);
  215. if (!pValue)
  216. {
  217. pBuilder->ThrowBuilderException(_T("Must specify both Property and Value for Setter."));
  218. }
  219. if (!pValue->IsKindOf(pProperty->GetPropetyType()))
  220. {
  221. CXTPMarkupObject* pNewValue = pBuilder->ConvertValue(pProperty, pValue);
  222. pSetter->SetValue(CXTPMarkupSetter::m_pValueProperty, pNewValue);
  223. }
  224. }
  225. void CXTPMarkupStyle::SetContentObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupObject* pContent)
  226. {
  227. if (pContent->IsKindOf(MARKUP_TYPE(CXTPMarkupSetter)))
  228. {
  229. ResolveSetterProperty(pBuilder, (CXTPMarkupSetter*)pContent);
  230. m_pSetters->SetContentObject(pBuilder, pContent);
  231. }
  232. else
  233. {
  234. CXTPMarkupObject::SetContentObject(pBuilder, pContent);
  235. }
  236. }
  237. void CXTPMarkupStyle::SetPropertyObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  238. {
  239. if (pProperty == m_pTriggersProperty)
  240. {
  241. if (pValue && pValue->IsKindOf(MARKUP_TYPE(CXTPMarkupTriggerCollection)))
  242. {
  243. CXTPMarkupTriggerCollection* pTriggers = (CXTPMarkupTriggerCollection*)pValue;
  244. for (int i = 0; i < pTriggers->GetCount(); i++)
  245. {
  246. ResolveTriggerProperty(pBuilder, pTriggers->GetItem(i));
  247. }
  248. }
  249. }
  250. CXTPMarkupObject::SetPropertyObject(pBuilder, pProperty, pValue);
  251. }
  252. void CXTPMarkupStyle::Seal()
  253. {
  254. if (m_bSealed)
  255. return;
  256. ASSERT(!m_pProperties);
  257. if (!m_pProperties)
  258. m_pProperties = new CXTPMarkupProperties(NULL);
  259. SetLogicalParent(NULL);
  260. CXTPMarkupStyle* pStyle = GetBasedStyle();
  261. if (pStyle)
  262. {
  263. pStyle->Seal();
  264. m_pProperties->Copy(pStyle->m_pProperties);
  265. }
  266. int nCount = m_pSetters->GetCount();
  267. for (int i = 0; i < nCount; i++)
  268. {
  269. CXTPMarkupSetter* pSetter = m_pSetters->GetItem(i);
  270. CXTPMarkupObject* pValue = pSetter->GetSetterValue();
  271. MARKUP_ADDREF(pValue);
  272. m_pProperties->Set(pSetter->GetSetterProperty(), pValue);
  273. }
  274. m_bSealed = TRUE;
  275. }
  276. CXTPMarkupObject* CXTPMarkupStyle::GetStyleValue(CXTPMarkupDependencyProperty* pProperty) const
  277. {
  278. return m_pProperties ? m_pProperties->Lookup(pProperty) : NULL;
  279. }
  280. void CXTPMarkupType::SetTypeStyle(CXTPMarkupStyle* pStyle)
  281. {
  282. if (m_pTypeStyle)
  283. {
  284. m_pTypeStyle->Release();
  285. }
  286. m_pTypeStyle = pStyle;
  287. if (pStyle)
  288. {
  289. pStyle->Seal();
  290. }
  291. }
  292. CXTPMarkupObject* CXTPMarkupStyle::FindResource(const CXTPMarkupObject* pKey) const
  293. {
  294. return CXTPMarkupResourceDictionary::FindResource(this, pKey);
  295. }
  296. //////////////////////////////////////////////////////////////////////////
  297. // CXTPMarkupTrigger
  298. CXTPMarkupDependencyProperty* CXTPMarkupTrigger::m_pPropertyProperty = NULL;
  299. CXTPMarkupDependencyProperty* CXTPMarkupTrigger::m_pSettersProperty = NULL;
  300. CXTPMarkupDependencyProperty* CXTPMarkupTrigger::m_pValueProperty = NULL;
  301. IMPLEMENT_MARKUPCLASS(L"Trigger", CXTPMarkupTrigger, CXTPMarkupObject)
  302. void CXTPMarkupTrigger::RegisterMarkupClass()
  303. {
  304. CXTPMarkupSetter::RegisterType();
  305. m_pPropertyProperty = CXTPMarkupSetter::m_pPropertyProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTrigger));
  306. m_pSettersProperty = CXTPMarkupDependencyProperty::Register(L"Setters", MARKUP_TYPE(CXTPMarkupSetterColection), MARKUP_TYPE(CXTPMarkupTrigger));
  307. m_pValueProperty = CXTPMarkupSetter::m_pValueProperty->AddOwner(MARKUP_TYPE(CXTPMarkupTrigger));
  308. }
  309. CXTPMarkupTrigger::CXTPMarkupTrigger()
  310. {
  311. }
  312. CXTPMarkupTrigger::CXTPMarkupTrigger(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  313. {
  314. ASSERT(pProperty && pValue);
  315. pProperty->AddRef();
  316. SetValue(m_pPropertyProperty, pProperty);
  317. SetValue(m_pValueProperty, pValue);
  318. }
  319. //////////////////////////////////////////////////////////////////////////
  320. // CXTPMarkupTriggerCollection
  321. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupTriggerCollection, CXTPMarkupCollection)
  322. void CXTPMarkupTriggerCollection::RegisterMarkupClass()
  323. {
  324. }
  325. CXTPMarkupTriggerCollection::CXTPMarkupTriggerCollection()
  326. {
  327. m_pElementType = MARKUP_TYPE(CXTPMarkupTrigger);
  328. }