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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupContext.cpp：源码内容
  1. // XTPMarkupContext.cpp: implementation of the CXTPMarkupContext 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/XTPToolTipContext.h"
  26. #include "XTPMarkupObject.h"
  28. #include "XTPMarkupContext.h"
  30. #include "XTPMarkupFrameworkElement.h"
  31. #include "XTPMarkupInline.h"
  33. #include "XTPMarkupUIElement.h"
  34. #include "XTPMarkupInline.h"
  35. #include "XTPMarkupBorder.h"
  36. #include "XTPMarkupStackPanel.h"
  37. #include "XTPMarkupGrid.h"
  38. #include "XTPMarkupCanvas.h"
  39. #include "XTPMarkupImage.h"
  40. #include "XTPMarkupPage.h"
  41. #include "XTPMarkupShape.h"
  42. #include "XTPMarkupTextBlock.h"
  43. #include "XTPMarkupButton.h"
  44. #include "XTPMarkupScrollViewer.h"
  45. #include "XTPMarkupResourceDictionary.h"
  47. #include "XTPMarkupBuilder.h"
  48. #include "XTPMarkupParser.h"
  49. #include "XTPMarkupDrawingContext.h"
  50. #include "XTPMarkupKeyboardNavigation.h"
  52. #ifdef _DEBUG
  53. #undef THIS_FILE
  54. static char THIS_FILE[]=__FILE__;
  55. #define new DEBUG_NEW
  56. #endif
  59. class CXTPMarkupContext::CXTPMarkupFontArray : public CXTPMarkupTypedSimpleStack<CXTPMarkupFont>
  60. {
  62. };
  64. CXTPMarkupFont::CXTPMarkupFont()
  65. {
  66. m_pMarkupContext = NULL;
  67. m_hFont = NULL;
  68. m_pNextChain = NULL;
  69. }
  71. CXTPMarkupFont::~CXTPMarkupFont()
  72. {
  73. if (m_pMarkupContext)
  74. {
  75. VERIFY(m_pMarkupContext->m_pFonts->Remove(this));
  76. }
  77. DeleteObject(m_hFont);
  78. }
  80. //////////////////////////////////////////////////////////////////////////
  81. // CXTPMarkupDelegateMap
  83. class CXTPMarkupDelegateMap
  84. {
  85. public:
  86. CXTPMarkupDelegateMap();
  87. ~CXTPMarkupDelegateMap();
  89. public:
  90. void RemoveAll();
  91. void Add(LPCWSTR lpszDelegate, CXTPMarkupDelegate* pDelegate);
  92. CXTPMarkupDelegate* Lookup(LPCWSTR lpszDelegate) const;
  94. protected:
  95. CMap<LPCWSTR, LPCWSTR, CXTPMarkupDelegate*, CXTPMarkupDelegate*> m_mapDelegates;
  96. };
  99. CXTPMarkupDelegateMap::CXTPMarkupDelegateMap()
  100. {
  101. }
  103. CXTPMarkupDelegateMap::~CXTPMarkupDelegateMap()
  104. {
  105. RemoveAll();
  106. }
  108. void CXTPMarkupDelegateMap::RemoveAll()
  109. {
  110. POSITION pos = m_mapDelegates.GetStartPosition();
  111. while (pos)
  112. {
  113. LPCWSTR lpszDelegate;
  114. CXTPMarkupDelegate* pDelegate;
  115. m_mapDelegates.GetNextAssoc(pos, lpszDelegate, pDelegate);
  117. MARKUP_RELEASE(pDelegate);
  118. }
  119. m_mapDelegates.RemoveAll();
  120. }
  122. void CXTPMarkupDelegateMap::Add(LPCWSTR lpszDelegate, CXTPMarkupDelegate* pDelegate)
  123. {
  124. m_mapDelegates.SetAt(lpszDelegate, pDelegate);
  125. }
  127. CXTPMarkupDelegate* CXTPMarkupDelegateMap::Lookup(LPCWSTR lpszDelegate) const
  128. {
  129. CXTPMarkupDelegate* pDelegate = NULL;
  130. if (!m_mapDelegates.Lookup(lpszDelegate, pDelegate))
  131. return NULL;
  133. return pDelegate;
  134. }
  136. template<> inline BOOL AFXAPI CompareElements(const LPCWSTR* pElement1, const LPCWSTR* pElement2)
  137. {
  138. return wcscmp(*pElement1, *pElement2) == 0;
  139. }
  141. class CXTPMarkupContext::CInputElementCollection : public CXTPMarkupCollection
  142. {
  143. public:
  144. CInputElementCollection()
  145. {
  146. m_pElementType = MARKUP_TYPE(CXTPMarkupInputElement);
  147. m_bLogicalParent = FALSE;
  148. }
  150. public:
  151. CXTPMarkupInputElement* GetItem(int nIndex) const {
  152. return (CXTPMarkupInputElement*)m_arrItems[nIndex];
  153. }
  154. CXTPMarkupInputElement* GetTailItem() const {
  155. return (CXTPMarkupInputElement*)m_arrItems[GetCount() - 1];
  156. }
  157. };
  159. class CXTPMarkupContext::CTooltipContext : public CXTPToolTipContext
  160. {
  161. public:
  162. CTooltipContext(CXTPMarkupContext* pMarkupContext)
  163. {
  164. m_pMarkupContext = pMarkupContext;
  165. }
  167. INT_PTR OnToolHitTest(CWnd* /*pWnd*/, CPoint point, TOOLINFO* pToolInfo)
  168. {
  169. return m_pMarkupContext->OnToolHitTest(point, pToolInfo);
  170. }
  171. protected:
  172. CXTPMarkupContext* m_pMarkupContext;
  173. };
  175. //////////////////////////////////////////////////////////////////////////
  176. // CXTPMarkupContext
  178. CXTPMarkupContext::CXTPMarkupContext()
  179. {
  180. NONCLIENTMETRICS ncm = { sizeof(NONCLIENTMETRICS) };
  181. VERIFY(::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0));
  183. m_dwRef = 1;
  184. m_logFont = ncm.lfMessageFont;
  186. m_clrForeground = 0;
  187. m_pImageManager = NULL;
  189. m_pMouseOver = NULL;
  190. m_pMouseCapture = NULL;
  191. m_pActiveElement = NULL;
  192. m_hContextWnd = NULL;
  194. m_pHandlers = NULL;
  195. m_pDelegates = NULL;
  197. m_pFonts = NULL;
  198. m_pKeyboardNavigation = new CXTPMarkupKeyboardNavigation(this);
  200. m_pTooltipContext = new CTooltipContext(this);
  201. m_pTooltipContext->SetStyle(xtpToolTipMarkup);
  204. RegisterClasses();
  205. }
  208. void CXTPMarkupContext::RegisterClasses()
  209. {
  210. static BOOL bRegistered = FALSE;
  211. if (bRegistered)
  212. return;
  214. bRegistered = TRUE;
  216. CXTPMarkupType::RegisterAll();
  218. CXTPMarkupSetter::RegisterType();
  219. CXTPMarkupFrameworkElement::RegisterType();
  220. CXTPMarkupUIElement::RegisterType();
  221. CXTPMarkupTextElement::RegisterType();
  222. CXTPMarkupBorder::RegisterType();
  223. CXTPMarkupCanvas::RegisterType();
  224. CXTPMarkupSolidColorBrush::RegisterType();
  225. CXTPMarkupGradientStop::RegisterType();
  226. CXTPMarkupLinearGradientBrush::RegisterType();
  227. CXTPMarkupColumnDefinition::RegisterType();
  228. CXTPMarkupRowDefinition::RegisterType();
  229. CXTPMarkupGrid::RegisterType();
  230. CXTPMarkupImage::RegisterType();
  231. CXTPMarkupPanel::RegisterType();
  232. CXTPMarkupControl::RegisterType();
  233. CXTPMarkupContentControl::RegisterType();
  234. CXTPMarkupButtonBase::RegisterType();
  235. CXTPMarkupToggleButton::RegisterType();
  236. CXTPMarkupButton::RegisterType();
  237. CXTPMarkupFrameworkContentElement::RegisterType();
  238. CXTPMarkupInline::RegisterType();
  239. CXTPMarkupRun::RegisterType();
  240. CXTPMarkupHyperlink::RegisterType();
  241. CXTPMarkupInputElement::RegisterType();
  242. CXTPMarkupPage::RegisterType();
  243. CXTPMarkupShape::RegisterType();
  244. CXTPMarkupPolygon::RegisterType();
  245. CXTPMarkupPolyline::RegisterType();
  246. CXTPMarkupLine::RegisterType();
  247. CXTPMarkupStackPanel::RegisterType();
  248. CXTPMarkupWrapPanel::RegisterType();
  249. CXTPMarkupTextBlock::RegisterType();
  250. CXTPMarkupScrollViewer::RegisterType();
  251. CXTPMarkupStyle::RegisterType();
  252. }
  254. CXTPMarkupContext::~CXTPMarkupContext()
  255. {
  256. if (m_pImageManager)
  257. {
  258. ((CCmdTarget*)m_pImageManager)->InternalRelease();
  259. }
  261. ASSERT(m_dwRef <= 1);
  263. MARKUP_RELEASE(m_pMouseOver);
  264. MARKUP_RELEASE(m_pKeyboardNavigation);
  266. ASSERT(m_pFonts == NULL || m_pFonts->IsEmpty());
  268. SAFE_DELETE(m_pHandlers);
  269. SAFE_DELETE(m_pDelegates);
  270. SAFE_DELETE(m_pFonts);
  272. CMDTARGET_RELEASE(m_pTooltipContext);
  273. }
  275. CXTPMarkupObject* CXTPMarkupContext::CreateMarkupObject(CXTPMarkupType* pType)
  276. {
  277. CXTPMarkupObject* pObject = pType->CreateObject();
  278. if (!pObject)
  279. return NULL;
  281. if (pObject->IsKindOf(MARKUP_TYPE(CXTPMarkupInputElement)))
  282. {
  283. ((CXTPMarkupInputElement*)pObject)->m_pMarkupContext = this;
  284. m_dwRef++;
  285. }
  287. return (CXTPMarkupObject*)pObject;
  288. }
  290. void CXTPMarkupContext::FinalizeMarkupObject(CXTPMarkupInputElement* pInputElement)
  291. {
  292. if (pInputElement == m_pMouseOver)
  293. m_pMouseOver = NULL;
  295. if (pInputElement == m_pActiveElement)
  296. m_pActiveElement = NULL;
  298. pInputElement->m_pMarkupContext = NULL;
  299. Release();
  300. }
  302. CXTPMarkupUIElement* CXTPMarkupContext::Parse(LPCSTR lpszBuffer)
  303. {
  304. if (!lpszBuffer)
  305. return NULL;
  307. CXTPMarkupParser sc;
  308. sc.SetBuffer(lpszBuffer, lpszBuffer + strlen(lpszBuffer));
  310. CXTPMarkupBuilder builder(this);
  311. return builder.Parse(&sc);
  312. }
  314. CXTPMarkupUIElement* CXTPMarkupContext::Parse(LPCWSTR lpszBuffer)
  315. {
  316. if (!lpszBuffer)
  317. return NULL;
  319. CXTPMarkupParser sc;
  320. sc.SetBuffer(lpszBuffer, lpszBuffer + wcslen(lpszBuffer));
  322. CXTPMarkupBuilder builder(this);
  323. return builder.Parse(&sc);
  324. }
  326. BOOL CXTPMarkupContext::CompareFont(LOGFONT* pLogFont1, LOGFONT* pLogFont2)
  327. {
  328. if (pLogFont1->lfHeight != pLogFont2->lfHeight)
  329. return FALSE;
  331. if (pLogFont1->lfWeight != pLogFont2->lfWeight)
  332. return FALSE;
  334. if (pLogFont1->lfItalic != pLogFont2->lfItalic)
  335. return FALSE;
  337. if (_tcscmp(pLogFont1->lfFaceName, pLogFont2->lfFaceName) != 0)
  338. return FALSE;
  340. return TRUE;
  341. }
  343. CXTPMarkupFont* CXTPMarkupContext::GetFont(LOGFONT* pLogFont)
  344. {
  345. if (m_pFonts == NULL)
  346. m_pFonts = new CXTPMarkupFontArray();
  348. CXTPMarkupFont* pFont;
  350. for (pFont = m_pFonts->GetHead(); pFont != NULL; pFont = pFont->m_pNextChain)
  351. {
  352. if (CompareFont(&pFont->m_lf, pLogFont))
  353. {
  354. pFont->AddRef();
  355. return pFont;
  356. }
  357. }
  359. pFont = new CXTPMarkupFont();
  360. m_pFonts->AddTail(pFont);
  361. pFont->m_lf = *pLogFont;
  362. pFont->m_hFont = ::CreateFontIndirect(pLogFont);
  363. pFont->m_pMarkupContext = this;
  365. return pFont;
  366. }
  368. BOOL CXTPMarkupContext::IsVisualChild(CXTPMarkupObject* pParent, CXTPMarkupObject* pChild)
  369. {
  370. while (pChild)
  371. {
  372. if (pChild == pParent)
  373. return TRUE;
  375. pChild = pChild->GetLogicalParent();
  376. }
  377. return FALSE;
  378. }
  380. void CXTPMarkupContext::BuildInputList(CXTPMarkupObject* pUIElement, CInputElementCollection* arrObjects)
  381. {
  382. CXTPMarkupObject* pParent = pUIElement;
  383. while (pParent)
  384. {
  385. if (pParent->IsKindOf(MARKUP_TYPE(CXTPMarkupInputElement)))
  386. {
  387. arrObjects->Add((CXTPMarkupInputElement*)pParent);
  388. pParent->AddRef();
  389. }
  391. pParent = pParent->GetLogicalParent();
  392. }
  393. }
  395. INT_PTR CXTPMarkupContext::OnToolHitTest(CPoint /*point*/, TOOLINFO* pToolInfo)
  396. {
  397. CInputElementCollection listMouseOver;
  398. BuildInputList(m_pMouseOver, &listMouseOver);
  400. for (int i = 0; i < listMouseOver.GetCount(); i++)
  401. {
  402. CXTPMarkupInputElement* pInputElement = listMouseOver.GetItem(i);
  404. CXTPMarkupObject* pToolTip = pInputElement->GetToolTip();
  405. if (pToolTip && IsStringObject(pToolTip))
  406. {
  407. CXTPToolTipContext::FillInToolInfo(pToolInfo, m_hContextWnd, GetClientBoundingRect(pInputElement),
  408. (INT_PTR)pInputElement, (LPCWSTR)*((CXTPMarkupString*)pToolTip));
  409. return pToolInfo->uId;
  410. }
  411. }
  413. return -1;
  414. }
  416. void CXTPMarkupContext::HandleMouseEnter(CXTPMarkupInputElement* pMouseOver, CPoint point)
  417. {
  418. if (m_pMouseOver == pMouseOver)
  419. return;
  421. if (!pMouseOver)
  422. m_pActiveElement = NULL;
  424. CInputElementCollection listOldMouseOver;
  425. CInputElementCollection listNewMouseOver;
  427. BuildInputList(m_pMouseOver, &listOldMouseOver);
  428. BuildInputList(pMouseOver, &listNewMouseOver);
  430. while (listOldMouseOver.GetCount() > 0 && listNewMouseOver.GetCount() > 0 &&
  431. listOldMouseOver.GetTailItem() == listNewMouseOver.GetTailItem())
  432. {
  433. listNewMouseOver.Remove(listNewMouseOver.GetCount() - 1);
  434. listOldMouseOver.Remove(listOldMouseOver.GetCount() - 1);
  435. }
  437. CXTPMarkupMouseEventArgs eMouseLeaveEventArgs(CXTPMarkupInputElement::m_pMouseLeaveEvent);
  438. CXTPMarkupMouseEventArgs eMouseEnterEventArgs(CXTPMarkupInputElement::m_pMouseEnterEvent);
  440. eMouseLeaveEventArgs.SetSource(m_pMouseOver);
  441. eMouseLeaveEventArgs.m_hWnd = m_hContextWnd;
  442. eMouseLeaveEventArgs.m_point = point;
  444. eMouseEnterEventArgs.SetSource(pMouseOver);
  445. eMouseEnterEventArgs.m_hWnd = m_hContextWnd;
  446. eMouseEnterEventArgs.m_point = point;
  449. MARKUP_RELEASE(m_pMouseOver);
  450. m_pMouseOver = pMouseOver;
  451. MARKUP_ADDREF(m_pMouseOver);
  453. int i;
  454. for (i = 0; i < listOldMouseOver.GetCount(); i++)
  455. {
  456. CXTPMarkupInputElement* pInputElement = listOldMouseOver.GetItem(i);
  458. pInputElement->RaiseEvent(&eMouseLeaveEventArgs);
  459. if (eMouseLeaveEventArgs.IsHandled())
  460. break;
  462. pInputElement->OnMouseLeave(&eMouseLeaveEventArgs);
  463. if (eMouseLeaveEventArgs.IsHandled())
  464. break;
  465. }
  467. for (i = 0; i < listNewMouseOver.GetCount(); i++)
  468. {
  469. CXTPMarkupInputElement* pInputElement = listNewMouseOver.GetItem(i);
  471. pInputElement->RaiseEvent(&eMouseEnterEventArgs);
  472. if (eMouseEnterEventArgs.IsHandled())
  473. break;
  475. pInputElement->OnMouseEnter(&eMouseEnterEventArgs);
  476. if (eMouseEnterEventArgs.IsHandled())
  477. break;
  478. }
  479. }
  482. void CXTPMarkupContext::HandleMouseMove(CXTPMarkupUIElement* pUIElement, CPoint point)
  483. {
  484. CXTPMarkupInputElement* pObject = pUIElement->InputHitTest(point);
  485. if (m_pMouseCapture)
  486. {
  487. if ((pObject == NULL) || !IsVisualChild(m_pMouseCapture, pObject))
  488. pObject = NULL;
  489. else
  490. pObject = m_pMouseCapture;
  491. }
  493. if (m_pMouseOver != pObject)
  494. {
  495. HandleMouseEnter(pObject, point);
  497. if (m_pMouseOver)
  498. {
  499. TRACKMOUSEEVENT tme = { sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hContextWnd, 0 };
  500. _TrackMouseEvent (&tme);
  502. }
  504. if (!HandleSetCursor())
  505. {
  506. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  507. }
  508. }
  510. m_pActiveElement = m_pMouseOver ? pUIElement : NULL;
  512. if (m_pMouseOver)
  513. {
  514. CInputElementCollection listNewMouseOver;
  515. BuildInputList(m_pMouseOver, &listNewMouseOver);
  517. CXTPMarkupMouseEventArgs eMouseMoveEventArgs(CXTPMarkupInputElement::m_pMouseMoveEvent);
  518. eMouseMoveEventArgs.SetSource(m_pMouseOver);
  519. eMouseMoveEventArgs.m_hWnd = m_hContextWnd;
  520. eMouseMoveEventArgs.m_point = point;
  522. for (int i = 0; i < listNewMouseOver.GetCount(); i++)
  523. {
  524. CXTPMarkupInputElement* pInputElement = listNewMouseOver.GetItem(i);
  526. pInputElement->RaiseEvent(&eMouseMoveEventArgs);
  527. if (eMouseMoveEventArgs.IsHandled())
  528. break;
  530. pInputElement->OnMouseMove(&eMouseMoveEventArgs);
  531. if (eMouseMoveEventArgs.IsHandled())
  532. break;
  533. }
  534. }
  535. }
  537. BOOL CXTPMarkupContext::HandleSetCursor()
  538. {
  539. if (m_pMouseOver)
  540. {
  541. CInputElementCollection listNewMouseOver;
  542. BuildInputList(m_pMouseOver, &listNewMouseOver);
  544. CXTPMarkupQueryCursorEventArgs eQueryCursorEventArgs;
  545. eQueryCursorEventArgs.SetSource(m_pMouseOver);
  547. for (int i = 0; i < listNewMouseOver.GetCount(); i++)
  548. {
  549. CXTPMarkupInputElement* pInputElement = listNewMouseOver.GetItem(i);
  551. pInputElement->OnQueryCursor(&eQueryCursorEventArgs);
  552. if (!eQueryCursorEventArgs.IsHandled())
  553. continue;
  555. if (eQueryCursorEventArgs.m_hCursor)
  556. {
  557. ::SetCursor(eQueryCursorEventArgs.m_hCursor);
  558. return TRUE;
  559. }
  561. return FALSE;
  562. }
  563. }
  564. return FALSE;
  565. }
  567. BOOL CXTPMarkupContext::HandleMouseWheel(int nDelta)
  568. {
  569. if (m_pMouseOver)
  570. {
  571. CInputElementCollection listNewMouseOver;
  572. BuildInputList(m_pMouseOver, &listNewMouseOver);
  574. CXTPMarkupMouseWheelEventArgs eMouseWheelEventArgs;
  575. eMouseWheelEventArgs.m_nDelta = nDelta;
  576. eMouseWheelEventArgs.SetSource(m_pMouseOver);
  578. for (int i = 0; i < listNewMouseOver.GetCount(); i++)
  579. {
  580. CXTPMarkupInputElement* pInputElement = listNewMouseOver.GetItem(i);
  582. pInputElement->OnMouseWheel(&eMouseWheelEventArgs);
  583. if (eMouseWheelEventArgs.IsHandled())
  584. return TRUE;
  585. }
  586. }
  587. return FALSE;
  588. }
  590. BOOL CXTPMarkupContext::HandleMouseUpDown(UINT message, WPARAM /*wParam*/, LPARAM lParam)
  591. {
  592. CXTPMarkupInputElement* pMouseOver = m_pMouseOver;
  593. if (m_pMouseCapture)
  594. pMouseOver = m_pMouseCapture;
  596. if (!pMouseOver)
  597. return FALSE;
  599. CInputElementCollection listNewMouseOver;
  600. BuildInputList(pMouseOver, &listNewMouseOver);
  602. CXTPMarkupMouseButtonEventArgs eMouseButtonEventArgs(
  603. message == WM_LBUTTONDOWN  || message == WM_LBUTTONDBLCLK ? CXTPMarkupInputElement::m_pMouseLeftButtonDownEvent :
  604. message == WM_LBUTTONUP ? CXTPMarkupInputElement::m_pMouseLeftButtonUpEvent :
  605. message == WM_RBUTTONDOWN ? CXTPMarkupInputElement::m_pMouseRightButtonDownEvent :
  606. message == WM_RBUTTONUP ? CXTPMarkupInputElement::m_pMouseRightButtonUpEvent : NULL);
  608. eMouseButtonEventArgs.SetSource(pMouseOver);
  609. eMouseButtonEventArgs.m_hWnd = m_hContextWnd;
  610. eMouseButtonEventArgs.m_point = lParam;
  612. for (int i = 0; i < listNewMouseOver.GetCount(); i++)
  613. {
  614. CXTPMarkupInputElement* pInputElement = listNewMouseOver.GetItem(i);
  616. pInputElement->RaiseEvent(&eMouseButtonEventArgs);
  617. if (eMouseButtonEventArgs.IsHandled())
  618. break;
  620. if (message == WM_LBUTTONDOWN || message == WM_LBUTTONDBLCLK)
  621. {
  622. pInputElement->OnMouseLeftButtonDown(&eMouseButtonEventArgs);
  623. }
  624. else if (message == WM_LBUTTONUP)
  625. {
  626. pInputElement->OnMouseLeftButtonUp(&eMouseButtonEventArgs);
  627. }
  628. else if (message == WM_RBUTTONDOWN)
  629. {
  630. pInputElement->OnMouseRightButtonDown(&eMouseButtonEventArgs);
  631. }
  632. else if (message == WM_RBUTTONUP)
  633. {
  634. pInputElement->OnMouseRightButtonUp(&eMouseButtonEventArgs);
  635. }
  637. if (eMouseButtonEventArgs.IsHandled())
  638. break;
  639. }
  641. return eMouseButtonEventArgs.IsHandled();
  642. }
  644. void CXTPMarkupContext::CaptureMouse(CXTPMarkupInputElement* pUIElement)
  645. {
  646. m_pMouseCapture = pUIElement;
  647. ::SetCapture(m_hContextWnd);
  648. }
  650. void CXTPMarkupContext::ReleaseMouseCapture(CXTPMarkupInputElement* /*pUIElement*/)
  651. {
  652. m_pMouseCapture = NULL;
  653. ::ReleaseCapture();
  654. }
  656. BOOL CXTPMarkupContext::OnWndMsg(CXTPMarkupUIElement* pUIElement, UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  657. {
  658. if (!m_hContextWnd)
  659. return FALSE;
  661. if (m_pActiveElement && m_pActiveElement != pUIElement)
  662. return FALSE;
  664. if (message == WM_MOUSEMOVE)
  665. {
  666. HandleMouseMove(pUIElement, CPoint(lParam));
  667. }
  669. if (message == WM_DESTROY || message == WM_MOUSELEAVE)
  670. {
  671. HandleMouseEnter(NULL, CPoint(-1, -1));
  672. }
  674. if ((message >= WM_MOUSEFIRST && message <= WM_MOUSELAST) || (message == WM_MOUSELEAVE))
  675. {
  676. m_pTooltipContext->FilterToolTipMessage(CWnd::FromHandle(m_hContextWnd), message, wParam, lParam);
  677. }
  679. if (message == WM_SETCURSOR)
  680. {
  681. if (HandleSetCursor())
  682. {
  683. *pResult = TRUE;
  684. return TRUE;
  685. }
  686. }
  688. if (message == WM_MOUSEWHEEL)
  689. {
  690. if (HandleMouseWheel((short) HIWORD(wParam)))
  691. {
  692. *pResult = TRUE;
  693. return TRUE;
  694. }
  695. }
  697. if (message == WM_LBUTTONDOWN || message == WM_RBUTTONDOWN || message == WM_LBUTTONUP || message == WM_RBUTTONUP || message == WM_LBUTTONDBLCLK)
  698. {
  699. if (HandleMouseUpDown(message, wParam, lParam))
  700. return TRUE;
  701. }
  703. if (message == WM_CAPTURECHANGED && m_pMouseCapture)
  704. {
  705. CXTPMarkupMouseEventArgs eLostMouseCaptureEventArgs(CXTPMarkupInputElement::m_pLostMouseCaptureEvent);
  706. eLostMouseCaptureEventArgs.SetSource(m_pMouseCapture);
  708. CXTPMarkupInputElement* pInputElement = m_pMouseCapture;
  710. pInputElement->RaiseEvent(&eLostMouseCaptureEventArgs);
  712. if (!eLostMouseCaptureEventArgs.IsHandled())
  713. {
  714. pInputElement->OnLostMouseCapture(&eLostMouseCaptureEventArgs);
  715. }
  716. m_pMouseCapture = NULL;
  717. }
  719. if (message == WM_KEYDOWN || message == WM_SETFOCUS || message == WM_KILLFOCUS)
  720. {
  721. if (m_pKeyboardNavigation->OnWndMsg(message, wParam, lParam, pResult))
  722. return TRUE;
  723. }
  727. return FALSE;
  728. }
  730. void CXTPMarkupContext::RaiseEvent(CXTPMarkupObject* pSource, CXTPMarkupRoutedEventArgs* pEventArgs)
  731. {
  732. if (m_pHandlers) m_pHandlers->Raise(pSource, pEventArgs);
  733. }
  735. void CXTPMarkupContext::AddHandler(CXTPMarkupRoutedEvent* pEvent, CXTPMarkupDelegate* pDelegate)
  736. {
  737. if (m_pHandlers == NULL)
  738. m_pHandlers = new CXTPMarkupEventHandlerMap();
  740. m_pHandlers->Add(pEvent, pDelegate);
  741. }
  743. void CXTPMarkupContext::SetDelegate(LPWSTR lpszHandler, CXTPMarkupDelegate* pDelegate)
  744. {
  745. if (m_pDelegates == NULL)
  746. m_pDelegates = new CXTPMarkupDelegateMap();
  748. m_pDelegates->Add(lpszHandler, pDelegate);
  749. }
  751. CXTPMarkupDelegate* CXTPMarkupContext::LookupDelegate(LPCWSTR lpszDelegate) const
  752. {
  753. if (m_pDelegates == NULL)
  754. return NULL;
  756. return m_pDelegates->Lookup(lpszDelegate);
  757. }
  759. CRect CXTPMarkupContext::GetClientBoundingRect(CXTPMarkupInputElement* pInputElement)
  760. {
  761. CRect rc(0, 0, 0, 0);
  763. if (!pInputElement)
  764. return rc;
  766. CXTPMarkupVisual* pVisual = NULL;
  767. if (pInputElement->IsKindOf(MARKUP_TYPE(CXTPMarkupVisual)))
  768. {
  769. pVisual = (CXTPMarkupVisual*)pInputElement;
  770. rc = pVisual->GetBoundRect();
  771. }
  772. else if (pInputElement->IsKindOf(MARKUP_TYPE(CXTPMarkupFrameworkContentElement)))
  773. {
  774. pVisual = ((CXTPMarkupFrameworkContentElement*)pInputElement)->GetParent();
  775. rc = ((CXTPMarkupFrameworkContentElement*)pInputElement)->GetBoundRect();
  776. }
  778. if (!pVisual)
  779. return rc;
  781. while (pVisual != 0)
  782. {
  783. rc.OffsetRect(pVisual->GetVisualOffset());
  784. pVisual = pVisual->GetVisualParent();
  785. }
  787. return rc;
  788. }
  791. void CXTPMarkupContext::OnInvalidateVisual(CXTPMarkupUIElement* pUIElement)
  792. {
  793. //TRACE(_T("OnInvalidateVisualn"));
  795. if (m_hContextWnd)
  796. {
  797. InvalidateRect(m_hContextWnd, GetClientBoundingRect(pUIElement), FALSE);
  798. }
  799. }
  801. void CXTPMarkupContext::OnInvalidateArrange(CXTPMarkupUIElement* /*pUIElement*/)
  802. {
  803. //TRACE(_T("OnInvalidateArrangen"));
  804. if (m_hContextWnd)
  805. {
  806. InvalidateRect(m_hContextWnd, NULL, FALSE);
  807. }
  808. }
  810. void CXTPMarkupContext::Release()
  811. {
  812. if (m_dwRef == 0)
  813. return;
  815. LONG lResult = InterlockedDecrement(&m_dwRef);
  816. if (lResult == 0)
  817. {
  818. delete this;
  819. }
  820. }