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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupInputElement.cpp：源码内容
  1. // XTPMarkupInputElement.cpp: implementation of the CXTPMarkupInputElement 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 "XTPMarkupInputElement.h"
  24. #include "XTPMarkupContext.h"
  25. #include "XTPMarkupBuilder.h"
  26. #include "XTPMarkupUIElement.h"
  27. #include "XTPMarkupResourceDictionary.h"
  28. #include "XTPMarkupKeyboardNavigation.h"
  30. #ifdef _DEBUG
  31. #undef THIS_FILE
  32. static char THIS_FILE[]=__FILE__;
  33. #define new DEBUG_NEW
  34. #endif
  36. //////////////////////////////////////////////////////////////////////////
  37. // CXTPMarkupRoutedEvent
  39. CXTPMarkupRoutedEvent::CXTPMarkupRoutedEvent()
  40. {
  42. }
  44. CXTPMarkupRoutedEvent* CXTPMarkupRoutedEvent::RegisterRoutedEvent(LPCWSTR lpszName, RoutingStrategy routingStrategy, CXTPMarkupType* pOwnerType)
  45. {
  46. CXTPMarkupRoutedEvent* pEvent = (CXTPMarkupRoutedEvent*)RegisterCommon(new CXTPMarkupRoutedEvent(), lpszName, MARKUP_TYPE(CXTPMarkupString), pOwnerType, FALSE);
  48. if (routingStrategy != routingDirect)
  49. {
  50. pEvent->m_pMetadata = new CXTPMarkupPropertyMetadata(NULL, routingStrategy);
  51. }
  53. return pEvent;
  54. }
  56. //////////////////////////////////////////////////////////////////////////
  57. // CXTPMarkupRoutedEventArgs
  59. CXTPMarkupRoutedEventArgs::CXTPMarkupRoutedEventArgs(CXTPMarkupRoutedEvent* pEvent, CXTPMarkupObject* pSource)
  60. {
  61. m_pSource = pSource;
  62. m_pEvent = pEvent;
  63. m_bHandled = FALSE;
  64. }
  66. CXTPMarkupRoutedEventArgs::CXTPMarkupRoutedEventArgs()
  67. {
  68. m_pSource = NULL;
  69. m_pEvent = NULL;
  70. m_bHandled = FALSE;
  71. }
  73. CXTPMarkupMouseEventArgs::CXTPMarkupMouseEventArgs(CXTPMarkupRoutedEvent* pEvent)
  74. : CXTPMarkupRoutedEventArgs(pEvent, NULL)
  75. {
  76. m_hWnd = 0;
  77. m_point = 0;
  78. }
  80. CPoint CXTPMarkupMouseEventArgs::GetPosition(CXTPMarkupInputElement* relativeTo)
  81. {
  82. CPoint pt = m_point;
  84. CXTPMarkupObject* pVisual = relativeTo;
  86. while (pVisual != 0)
  87. {
  88. if (pVisual->IsKindOf(MARKUP_TYPE(CXTPMarkupVisual)))
  89. {
  90. pt -= ((CXTPMarkupVisual*)pVisual)->GetVisualOffset();
  91. }
  92. pVisual = pVisual->GetLogicalParent();
  93. }
  94. return pt;
  95. }
  98. CXTPMarkupMouseButtonEventArgs::CXTPMarkupMouseButtonEventArgs(CXTPMarkupRoutedEvent* pEvent)
  99. : CXTPMarkupMouseEventArgs(pEvent)
  100. {
  102. }
  104. CXTPMarkupQueryCursorEventArgs::CXTPMarkupQueryCursorEventArgs()
  105. : CXTPMarkupMouseEventArgs(NULL)
  106. {
  108. }
  110. CXTPMarkupMouseWheelEventArgs::CXTPMarkupMouseWheelEventArgs()
  111. : CXTPMarkupMouseEventArgs(NULL)
  112. {
  114. }
  119. //////////////////////////////////////////////////////////////////////////
  120. // CXTPMarkupEventHandlerMap
  122. CXTPMarkupEventHandlerMap::CXTPMarkupEventHandlerMap()
  123. {
  125. }
  127. CXTPMarkupEventHandlerMap::~CXTPMarkupEventHandlerMap()
  128. {
  129. RemoveAll();
  130. }
  132. void CXTPMarkupEventHandlerMap::RemoveAll()
  133. {
  134. POSITION pos = m_mapHandlers.GetStartPosition();
  135. while (pos)
  136. {
  137. CPtrList* pHandlers;
  138. CXTPMarkupRoutedEvent* pEvent;
  139. m_mapHandlers.GetNextAssoc(pos, pEvent, pHandlers);
  141. while (!pHandlers->IsEmpty())
  142. {
  143. CXTPMarkupDelegate* pDelegate = (CXTPMarkupDelegate*)pHandlers->RemoveTail();
  144. MARKUP_RELEASE(pDelegate);
  145. }
  146. delete pHandlers;
  147. }
  148. m_mapHandlers.RemoveAll();
  149. }
  151. void CXTPMarkupEventHandlerMap::Add(CXTPMarkupRoutedEvent* pEvent, CXTPMarkupDelegate* pDelegate)
  152. {
  153. CPtrList* pHandlers;
  154. if (!m_mapHandlers.Lookup(pEvent, pHandlers))
  155. {
  156. pHandlers  = new CPtrList();
  157. m_mapHandlers.SetAt(pEvent, pHandlers);
  158. }
  160. pHandlers->AddTail(pDelegate);
  161. }
  163. void CXTPMarkupEventHandlerMap::Raise(CXTPMarkupObject* pSender, CXTPMarkupRoutedEventArgs* pEventArgs)
  164. {
  165. CPtrList* pHandlers;
  166. if (!m_mapHandlers.Lookup(pEventArgs->GetEvent(), pHandlers))
  167. return;
  169. POSITION pos = pHandlers->GetHeadPosition();
  171. while (pos)
  172. {
  173. CXTPMarkupDelegate* pDelegate = (CXTPMarkupDelegate*)pHandlers->GetNext(pos);
  175. pDelegate->Execute(pSender, pEventArgs);
  176. }
  177. }
  180. //////////////////////////////////////////////////////////////////////////
  181. // CXTPMarkupInputElement
  183. CXTPMarkupDependencyProperty* CXTPMarkupInputElement::m_pCursorProperty = NULL;
  184. CXTPMarkupDependencyProperty* CXTPMarkupInputElement::m_pIsMouseOverProperty = NULL;
  185. CXTPMarkupDependencyProperty* CXTPMarkupInputElement::m_pIsKeyboardFocusedProperty = NULL;
  186. CXTPMarkupDependencyProperty* CXTPMarkupInputElement::m_pResourcesProperty = NULL;
  187. CXTPMarkupDependencyProperty* CXTPMarkupInputElement::m_pStyleProperty = NULL;
  188. CXTPMarkupDependencyProperty* CXTPMarkupInputElement::m_pIsFocusableProperty = NULL;
  189. CXTPMarkupDependencyProperty* CXTPMarkupInputElement::m_pToolTipProperty = NULL;
  191. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pMouseLeaveEvent = NULL;
  192. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pMouseEnterEvent = NULL;
  193. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pMouseLeftButtonUpEvent = NULL;
  194. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pMouseLeftButtonDownEvent = NULL;
  195. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pMouseRightButtonUpEvent = NULL;
  196. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pMouseRightButtonDownEvent = NULL;
  197. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pMouseMoveEvent = NULL;
  198. CXTPMarkupRoutedEvent* CXTPMarkupInputElement::m_pLostMouseCaptureEvent = NULL;
  201. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupInputElement, CXTPMarkupObject);
  203. void CXTPMarkupInputElement::RegisterMarkupClass()
  204. {
  205. CXTPMarkupStyle::RegisterType();
  207. m_pCursorProperty = CXTPMarkupDependencyProperty::Register(L"Cursor", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupInputElement),
  208. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertCursor));
  210. m_pIsMouseOverProperty = CXTPMarkupDependencyProperty::Register(L"IsMouseOver", MARKUP_TYPE(CXTPMarkupBool), MARKUP_TYPE(CXTPMarkupInputElement),
  211. new CXTPMarkupPropertyMetadata(CXTPMarkupBool::CreateFalseValue()));
  213. m_pResourcesProperty = CXTPMarkupStyle::m_pResourcesProperty->AddOwner(MARKUP_TYPE(CXTPMarkupInputElement));
  215. m_pStyleProperty = CXTPMarkupDependencyProperty::Register(L"Style", MARKUP_TYPE(CXTPMarkupStyle), MARKUP_TYPE(CXTPMarkupInputElement),
  216. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupInputElement::OnStylePropertyChanged));
  218. m_pIsKeyboardFocusedProperty = CXTPMarkupDependencyProperty::Register(L"IsKeyboardFocused", MARKUP_TYPE(CXTPMarkupBool), MARKUP_TYPE(CXTPMarkupInputElement),
  219. new CXTPMarkupPropertyMetadata(CXTPMarkupBool::CreateFalseValue(), CXTPMarkupPropertyMetadata::flagAffectsRender));
  221. m_pIsFocusableProperty = CXTPMarkupDependencyProperty::Register(L"IsFocusable", MARKUP_TYPE(CXTPMarkupBool), MARKUP_TYPE(CXTPMarkupInputElement),
  222. new CXTPMarkupPropertyMetadata(CXTPMarkupBool::CreateFalseValue()));
  224. m_pToolTipProperty = CXTPMarkupDependencyProperty::Register(L"ToolTip", MARKUP_TYPE(CXTPMarkupObject), MARKUP_TYPE(CXTPMarkupInputElement));
  226. m_pMouseLeaveEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"MouseLeave",
  227. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  228. m_pMouseEnterEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"MouseEnter",
  229. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  230. m_pMouseLeftButtonUpEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"MouseLeftButtonUp",
  231. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  232. m_pMouseLeftButtonDownEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"MouseLeftButtonDown",
  233. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  234. m_pMouseRightButtonUpEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"MouseRightButtonUp",
  235. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  236. m_pMouseRightButtonDownEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"MouseRightButtonDown",
  237. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  238. m_pMouseMoveEvent = CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"MouseMove",
  239. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  240. m_pLostMouseCaptureEvent= CXTPMarkupRoutedEvent::RegisterRoutedEvent(L"pLostMouseCapture",
  241. CXTPMarkupRoutedEvent::routingDirect, MARKUP_TYPE(CXTPMarkupInputElement));
  242. }
  244. CXTPMarkupInputElement::CXTPMarkupInputElement()
  245. {
  246. m_pMarkupContext = NULL;
  247. m_pHandlers = NULL;
  249. m_pActiveTriggers = NULL;
  250. m_pTriggerProperties = NULL;
  251. m_pStyleCache = NULL;
  253. }
  255. CXTPMarkupInputElement::~CXTPMarkupInputElement()
  256. {
  257. SAFE_DELETE(m_pHandlers);
  259. MARKUP_RELEASE(m_pActiveTriggers);
  260. MARKUP_RELEASE(m_pTriggerProperties);
  261. }
  263. void CXTPMarkupInputElement::OnMouseLeave(CXTPMarkupMouseEventArgs* /*e*/)
  264. {
  265. SetValue(m_pIsMouseOverProperty, NULL);
  266. }
  268. void CXTPMarkupInputElement::OnMouseEnter(CXTPMarkupMouseEventArgs* /*e*/)
  269. {
  270. SetValue(m_pIsMouseOverProperty, CXTPMarkupBool::CreateTrueValue());
  271. }
  273. void CXTPMarkupInputElement::OnMouseMove(CXTPMarkupMouseEventArgs* /*e*/)
  274. {
  275. }
  277. void CXTPMarkupInputElement::OnQueryCursor(CXTPMarkupQueryCursorEventArgs* e)
  278. {
  279. CXTPMarkupInt* pCursor = MARKUP_STATICCAST(CXTPMarkupInt, GetValue(m_pCursorProperty));
  280. if (pCursor)
  281. {
  282. e->SetHandled();
  283. e->m_hCursor = AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE((int)*pCursor));
  284. }
  285. }
  287. void CXTPMarkupInputElement::OnMouseWheel(CXTPMarkupMouseWheelEventArgs* /*e*/)
  288. {
  290. }
  292. void CXTPMarkupInputElement::OnMouseLeftButtonUp(CXTPMarkupMouseButtonEventArgs* /*e*/)
  293. {
  294. }
  296. void CXTPMarkupInputElement::OnMouseRightButtonUp(CXTPMarkupMouseButtonEventArgs* /*e*/)
  297. {
  298. }
  300. void CXTPMarkupInputElement::OnMouseLeftButtonDown(CXTPMarkupMouseButtonEventArgs* /*e*/)
  301. {
  302. }
  304. void CXTPMarkupInputElement::OnMouseRightButtonDown(CXTPMarkupMouseButtonEventArgs* /*e*/)
  305. {
  306. }
  308. void CXTPMarkupInputElement::OnLostMouseCapture(CXTPMarkupMouseEventArgs* /*e*/)
  309. {
  311. }
  313. void CXTPMarkupInputElement::RaiseEvent(CXTPMarkupRoutedEventArgs* pEventArgs)
  314. {
  315. if (pEventArgs->GetEvent() == NULL)
  316. {
  317. ASSERT(FALSE);
  318. return;
  319. }
  321. if (pEventArgs->GetEvent()->GetFlags() & CXTPMarkupRoutedEvent::routingBubble)
  322. {
  323. CXTPMarkupObject* pParent = this;
  324. while (pParent)
  325. {
  326. if (pParent->IsKindOf(MARKUP_TYPE(CXTPMarkupInputElement)))
  327. {
  328. CXTPMarkupEventHandlerMap* pHandlers = ((CXTPMarkupInputElement*)pParent)->m_pHandlers;
  329. if (pHandlers) pHandlers->Raise(pParent, pEventArgs);
  331. if (pEventArgs->IsHandled())
  332. return;
  333. }
  335. pParent = pParent->GetLogicalParent();
  336. }
  338. CXTPMarkupContext* pMarkupContext = GetMarkupContext();
  339. if (pMarkupContext)
  340. {
  341. pMarkupContext->RaiseEvent(this, pEventArgs);
  342. }
  343. }
  344. else
  345. {
  346. if (m_pHandlers) m_pHandlers->Raise(this, pEventArgs);
  347. }
  348. }
  350. void CXTPMarkupInputElement::AddHandler(CXTPMarkupRoutedEvent* pEvent, CXTPMarkupDelegate* pDelegate)
  351. {
  352. if (m_pHandlers == NULL)
  353. m_pHandlers = new CXTPMarkupEventHandlerMap();
  355. m_pHandlers->Add(pEvent, pDelegate);
  356. }
  359. CXTPMarkupInputElement* CXTPMarkupInputElement::InputHitTest(CPoint /*point*/) const
  360. {
  361. return NULL;
  362. }
  364. void CXTPMarkupInputElement::SetPropertyObject(CXTPMarkupBuilder* pBuilder, CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pValue)
  365. {
  366. if (pProperty->IsEvent())
  367. {
  368. CXTPMarkupContext* pMarkupContext = GetMarkupContext();
  369. if (!pMarkupContext)
  370. {
  371. pBuilder->ThrowBuilderException(_T("Markup Context is NULL"));
  372. }
  374. LPCWSTR lpszDelegate = (LPCWSTR)*((CXTPMarkupString*)pValue);
  376. CXTPMarkupDelegate* pDelegate = pMarkupContext->LookupDelegate(lpszDelegate);
  377. if (!pDelegate)
  378. {
  379. pBuilder->ThrowBuilderException(CXTPMarkupBuilder::FormatString(_T("'%ls' delegate not found"), (LPCTSTR)lpszDelegate));
  380. }
  382. AddHandler((CXTPMarkupRoutedEvent*)pProperty,  pDelegate);
  383. MARKUP_RELEASE(pValue);
  384. MARKUP_ADDREF(pDelegate);
  386. return;
  387. }
  389. CXTPMarkupObject::SetPropertyObject(pBuilder, pProperty, pValue);
  391. }
  392. void CXTPMarkupInputElement::OnFinalRelease()
  393. {
  394. ASSERT(m_pMarkupContext);
  396. if (m_pMarkupContext)
  397. {
  398. m_pMarkupContext->FinalizeMarkupObject(this);
  399. }
  401. CXTPMarkupObject::OnFinalRelease();
  402. }
  404. void CXTPMarkupInputElement::CaptureMouse()
  405. {
  406. m_pMarkupContext->CaptureMouse(this);
  407. }
  409. void CXTPMarkupInputElement::ReleaseMouseCapture()
  410. {
  411. m_pMarkupContext->ReleaseMouseCapture(this);
  412. }
  414. void CXTPMarkupInputElement::ApplyTree(CXTPMarkupObject* pChild)
  415. {
  416. int nCount = pChild->GetLogicalChildrenCount();
  418. for (int i = 0; i < nCount; i++)
  419. {
  420. CXTPMarkupObject* p = pChild->GetLogicalChild(i);
  422. ApplyTree(p);
  423. }
  425. if (pChild->IsKindOf(MARKUP_TYPE(CXTPMarkupInputElement)))
  426. {
  427. ((CXTPMarkupInputElement*)pChild)->OnApply();
  428. }
  429. }
  431. void CXTPMarkupInputElement::Apply()
  432. {
  433. ApplyTree(this);
  434. }
  438. CXTPMarkupObject* CXTPMarkupInputElement::FindResource(const CXTPMarkupObject* pKey) const
  439. {
  440. return CXTPMarkupResourceDictionary::FindResource(this, pKey);
  441. }
  443. void CXTPMarkupInputElement::OnApply()
  444. {
  445. if (m_pStyleCache == NULL)
  446. {
  447. CXTPMarkupType* pType = GetType();
  448. if (!pType)
  449. return;
  451. CXTPMarkupStyle* pStyle = MARKUP_DYNAMICCAST(CXTPMarkupStyle, FindResource(pType));
  452. if (pStyle)
  453. {
  454. pStyle->Seal();
  455. m_pStyleCache = pStyle;
  456. }
  457. }
  459. if (m_pStyleCache != NULL)
  460. {
  461. FireTriggers(NULL, NULL);
  462. }
  463. }
  466. class CXTPMarkupActiveTriggerCollection : public CXTPMarkupTriggerCollection
  467. {
  468. public:
  469. CXTPMarkupActiveTriggerCollection()
  470. {
  471. m_bLogicalParent = FALSE;
  472. }
  474. };
  476. BOOL CXTPMarkupInputElement::AddStyleTriggers(CXTPMarkupStyle* pStyle, CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pNewValue)
  477. {
  478. BOOL bChanged = FALSE;
  480. CXTPMarkupStyle* pBasedStyle = pStyle->GetBasedStyle();
  481. if (pBasedStyle)
  482. {
  483. bChanged = AddStyleTriggers(pBasedStyle, pProperty, pNewValue);
  484. }
  486. CXTPMarkupTriggerCollection* pTriggers = pStyle->GetTriggers();
  487. if (!pTriggers)
  488. return bChanged;
  490. BOOL bAllProperties = (pProperty == NULL);
  492. for (int i = pTriggers->GetCount() - 1; i >= 0; i--)
  493. {
  494. CXTPMarkupTrigger* pTrigger = pTriggers->GetItem(i);
  496. if (bAllProperties)
  497. {
  498. pProperty = pTrigger->GetTriggerProperty();
  499. pNewValue = GetValue(pProperty);
  500. }
  502. if (pTrigger->GetTriggerProperty() == pProperty && pTrigger->GetTriggerValue()->IsEqual(pNewValue))
  503. {
  504. if (!m_pActiveTriggers)
  505. {
  506. m_pActiveTriggers = new CXTPMarkupActiveTriggerCollection();
  507. }
  509. pTrigger->AddRef();
  510. m_pActiveTriggers->Add(pTrigger);
  511. bChanged = TRUE;
  512. }
  513. }
  515. return bChanged;
  516. }
  518. void CXTPMarkupInputElement::FireTriggers(CXTPMarkupDependencyProperty* pProperty, CXTPMarkupObject* pNewValue)
  519. {
  520. BOOL bChanged = FALSE;
  521. int i;
  523. CMap<CXTPMarkupDependencyProperty*, CXTPMarkupDependencyProperty*, CXTPMarkupObject*, CXTPMarkupObject*> mapOldValues;
  525. if (m_pActiveTriggers)
  526. {
  527. for (i = m_pActiveTriggers->GetCount() - 1; i >= 0; i--)
  528. {
  529. CXTPMarkupTrigger* pTrigger = m_pActiveTriggers->GetItem(i);
  531. if (pTrigger->GetTriggerProperty() == pProperty)
  532. {
  533. if (!pTrigger->GetTriggerValue()->IsEqual(pNewValue))
  534. {
  535. CXTPMarkupSetterColection* pSetters = pTrigger->GetSetters();
  537. for (int j = 0; j < pSetters->GetCount(); j++)
  538. {
  539. CXTPMarkupSetter* pSetter = pSetters->GetItem(j);
  540. CXTPMarkupDependencyProperty* pSetterProperty = pSetter->GetSetterProperty();
  542. CXTPMarkupObject* pOldValue = m_pTriggerProperties->Lookup(pSetterProperty);
  544. CXTPMarkupObject* pTempValue;
  545. if (!mapOldValues.Lookup(pSetterProperty, pTempValue))
  546. {
  547. MARKUP_ADDREF(pOldValue);
  548. mapOldValues.SetAt(pSetterProperty, pOldValue);
  549. }
  551. m_pTriggerProperties->Set(pSetterProperty, NULL);
  552. }
  554. m_pActiveTriggers->Remove(i);
  555. bChanged = TRUE;
  556. }
  557. }
  558. }
  559. }
  561. if (m_pStyleCache)
  562. {
  563. bChanged = AddStyleTriggers(m_pStyleCache, pProperty, pNewValue) || bChanged;
  564. }
  565. else if (GetType()->GetTypeStyle())
  566. {
  567. bChanged = AddStyleTriggers(GetType()->GetTypeStyle(), pProperty, pNewValue) || bChanged;
  568. }
  571. if (bChanged)
  572. {
  573. if (!m_pTriggerProperties)
  574. m_pTriggerProperties = new CXTPMarkupProperties(NULL);
  576. for (i = 0; i < m_pActiveTriggers->GetCount(); i++)
  577. {
  578. CXTPMarkupTrigger* pTrigger = m_pActiveTriggers->GetItem(i);
  580. CXTPMarkupSetterColection* pSetters = pTrigger->GetSetters();
  582. for (int j = 0; j < pSetters->GetCount(); j++)
  583. {
  584. CXTPMarkupSetter* pSetter = pSetters->GetItem(j);
  586. CXTPMarkupObject* pValue = pSetter->GetSetterValue();
  588. CXTPMarkupDependencyProperty* pSetterProperty = pSetter->GetSetterProperty();
  590. CXTPMarkupObject* pOldValue = m_pTriggerProperties->Lookup(pSetterProperty);
  592. if (!pValue->IsEqual(pOldValue))
  593. {
  594. CXTPMarkupObject* pTempValue;
  595. if (!mapOldValues.Lookup(pSetterProperty, pTempValue))
  596. {
  597. MARKUP_ADDREF(pOldValue);
  598. mapOldValues.SetAt(pSetterProperty, pOldValue);
  599. }
  601. pValue->AddRef();
  602. m_pTriggerProperties->Set(pSetterProperty, pValue);
  603. }
  604. }
  605. }
  606. }
  608. POSITION pos = mapOldValues.GetStartPosition();
  609. while (pos)
  610. {
  611. CXTPMarkupDependencyProperty* pProperty;
  612. CXTPMarkupObject* pOldValue;
  613. mapOldValues.GetNextAssoc(pos, pProperty, pOldValue);
  615. CXTPMarkupObject* pNewValue = m_pTriggerProperties->Lookup(pProperty);
  617. if (!::IsEqual(pNewValue, pOldValue))
  618. {
  619. OnPropertyChanged(pProperty, pOldValue, pNewValue);
  621. if (pProperty->GetFlags() & CXTPMarkupPropertyMetadata::flagInherited)
  622. {
  623. RecursePropertyChanged(pProperty, pOldValue, pNewValue);
  624. }
  625. }
  627. MARKUP_RELEASE(pOldValue);
  628. }
  629. }
  631. void CXTPMarkupInputElement::OnStylePropertyChanged(CXTPMarkupObject* d, CXTPMarkupPropertyChangedEventArgs* e)
  632. {
  633. CXTPMarkupInputElement* pElement = MARKUP_DYNAMICCAST(CXTPMarkupInputElement, d);
  634. if (!pElement)
  635. {
  636. ASSERT(FALSE);
  637. return;
  638. }
  640. CXTPMarkupStyle* pStyle = MARKUP_STATICCAST(CXTPMarkupStyle, e->m_pNewValue);
  642. if (pStyle)
  643. {
  644. pStyle->Seal();
  645. }
  647. pElement->m_pStyleCache = pStyle;
  648. }
  650. CXTPMarkupObject* CXTPMarkupInputElement::GetValueCore(CXTPMarkupDependencyProperty* pProperty) const
  651. {
  652. CXTPMarkupObject* pValue = CXTPMarkupObject::GetValueCore(pProperty);
  653. if (pValue)
  654. return pValue;
  656. if (m_pTriggerProperties)
  657. {
  658. pValue = m_pTriggerProperties->Lookup(pProperty);
  659. if (pValue)
  660. return pValue;
  661. }
  663. if (m_pStyleCache)
  664. {
  665. pValue = m_pStyleCache->GetStyleValue(pProperty);
  666. if (pValue)
  667. return pValue;
  668. }
  670. CXTPMarkupStyle* pTypeStyle = GetType()->GetTypeStyle();
  671. if (pTypeStyle)
  672. return pTypeStyle->GetStyleValue(pProperty);
  674. return NULL;
  675. }
  677. void CXTPMarkupInputElement::Focus()
  678. {
  679. if (!m_pMarkupContext)
  680. return;
  682. m_pMarkupContext->GetKeyboardNavigation()->Focus(this);
  683. }