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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupKeyboardNavigation.cpp：源码内容
  1. // XTPMarkupKeyboardNavigation.cpp: implementation of the CXTPMarkupKeyboardNavigation 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 "XTPMarkupFrameworkElement.h"
  24. #include "XTPMarkupInline.h"
  25. #include "XTPMarkupInputElement.h"
  26. #include "XTPMarkupKeyboardNavigation.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. CXTPMarkupDependencyProperty* CXTPMarkupKeyboardNavigation::m_pIsTabStopProperty = NULL;
  37. CXTPMarkupDependencyProperty* CXTPMarkupKeyboardNavigation::m_pTabNavigationProperty = NULL;
  38. CXTPMarkupDependencyProperty* CXTPMarkupKeyboardNavigation::m_pTabIndexProperty = NULL;
  40. IMPLEMENT_MARKUPCLASS(L"KeyboardNavigation", CXTPMarkupKeyboardNavigation, CXTPMarkupObject)
  42. void CXTPMarkupKeyboardNavigation::RegisterMarkupClass()
  43. {
  44. m_pIsTabStopProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"IsTabStop", MARKUP_TYPE(CXTPMarkupBool), MARKUP_TYPE(CXTPMarkupKeyboardNavigation),
  45. new CXTPMarkupPropertyMetadata(CXTPMarkupBool::CreateTrueValue()));
  47. m_pTabNavigationProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"TabNavigation", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupKeyboardNavigation),
  48. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupKeyboardNavigation::ConvertKeyboardNavigationMode));
  50. m_pTabIndexProperty = CXTPMarkupDependencyProperty::RegisterAttached(L"TabIndex", MARKUP_TYPE(CXTPMarkupInt), MARKUP_TYPE(CXTPMarkupKeyboardNavigation),
  51. new CXTPMarkupPropertyMetadata(new CXTPMarkupInt(INT_MAX)));
  52. }
  54. CXTPMarkupKeyboardNavigation::CXTPMarkupKeyboardNavigation(CXTPMarkupContext* pContext)
  55. {
  56. m_pFocused = NULL;
  57. m_pLastFocused = NULL;
  59. m_pMarkupContext = pContext;
  60. }
  62. CXTPMarkupKeyboardNavigation::~CXTPMarkupKeyboardNavigation()
  63. {
  64. MARKUP_RELEASE(m_pFocused);
  65. MARKUP_RELEASE(m_pLastFocused);
  66. }
  68. XTPMarkupKeyboardNavigationMode CXTPMarkupKeyboardNavigation::GetTabNavigation(CXTPMarkupObject* pElement)
  69. {
  70. CXTPMarkupEnum* pValue = MARKUP_STATICCAST(CXTPMarkupEnum, pElement->GetValue(m_pTabNavigationProperty));
  71. return pValue ? (XTPMarkupKeyboardNavigationMode)(int)*pValue : xtpMarkupKeyboardNavigationContinue;
  72. }
  74. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::ConvertKeyboardNavigationMode(CXTPMarkupContext* /*pContext*/, CXTPMarkupObject* pObject)
  75. {
  76. if (IsStringObject(pObject))
  77. {
  78. LPCWSTR lpszValue = *((CXTPMarkupString*)pObject);
  79. int nLength = ((CXTPMarkupString*)pObject)->GetLength();
  81. if (nLength == 8 && _wcsicmp(lpszValue, L"Continue") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupKeyboardNavigationContinue);
  82. if (nLength == 4 && _wcsicmp(lpszValue, L"Once") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupKeyboardNavigationOnce);
  83. if (nLength == 5 && _wcsicmp(lpszValue, L"Cycle") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupKeyboardNavigationCycle);
  84. if (nLength == 4 && _wcsicmp(lpszValue, L"None") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupKeyboardNavigationNone);
  85. if (nLength == 9 && _wcsicmp(lpszValue, L"Contained") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupKeyboardNavigationContained);
  86. if (nLength == 5 && _wcsicmp(lpszValue, L"Local") == 0) return CXTPMarkupEnum::CreateValue(xtpMarkupKeyboardNavigationLocal);
  87. }
  89. return NULL;
  90. }
  93. BOOL CXTPMarkupKeyboardNavigation::OnWndMsg(UINT /*message*/, WPARAM /*wParam*/, LPARAM /*lParam*/, LRESULT* /*pResult*/)
  94. {
  95. // NotImplmeneted
  96. return FALSE;
  98. #if 0
  99. if (message == WM_SETFOCUS)
  100. {
  101. if (m_pLastFocused && !m_pFocused)
  102. {
  103. Focus(m_pLastFocused);
  104. MARKUP_RELEASE(m_pLastFocused);
  105. }
  106. }
  108. if (message == WM_KILLFOCUS)
  109. {
  110. if (m_pFocused)
  111. {
  112. m_pLastFocused = m_pFocused;
  113. MARKUP_ADDREF(m_pLastFocused);
  115. Focus(NULL);
  116. }
  117. }
  119. if (message == WM_KEYDOWN)
  120. {
  121. ProcessInput((UINT)wParam);
  122. }
  124. return FALSE;
  125. #endif
  126. }
  128. BOOL CXTPMarkupKeyboardNavigation::IsInNavigationTree(CXTPMarkupObject* pVisual)
  129. {
  130. CXTPMarkupUIElement* pElement = MARKUP_DYNAMICCAST(CXTPMarkupUIElement, pVisual);
  131. if ((pElement != NULL) && (pElement->IsVisible()))
  132. {
  133. return TRUE;
  134. }
  136. return FALSE;
  137. }
  140. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetParent(CXTPMarkupObject* e)
  141. {
  142. if (!e)
  143. return NULL;
  145. if (e->IsKindOf(MARKUP_TYPE(CXTPMarkupVisual)))
  146. {
  147. CXTPMarkupVisual* reference = ((CXTPMarkupVisual*)e)->GetVisualParent();
  148. while (reference != NULL)
  149. {
  150. if (IsInNavigationTree(reference))
  151. {
  152. return reference;
  153. }
  155. reference = reference->GetVisualParent();
  156. }
  157. }
  158. else if (e->IsKindOf(MARKUP_TYPE(CXTPMarkupFrameworkContentElement)))
  159. {
  160. return (CXTPMarkupObject*)(((CXTPMarkupFrameworkContentElement*)e)->GetParent());
  161. }
  163. return NULL;
  164. }
  166. XTPMarkupKeyboardNavigationMode CXTPMarkupKeyboardNavigation::GetKeyNavigationMode(CXTPMarkupObject* pElement)
  167. {
  168. CXTPMarkupEnum* pValue = MARKUP_STATICCAST(CXTPMarkupEnum, pElement->GetValue(m_pNavigationProperty));
  169. return pValue ? (XTPMarkupKeyboardNavigationMode)(int)*pValue : xtpMarkupKeyboardNavigationContinue;
  170. }
  172. BOOL CXTPMarkupKeyboardNavigation::IsGroup(CXTPMarkupObject* e)
  173. {
  174. return (GetKeyNavigationMode(e) != xtpMarkupKeyboardNavigationContinue);
  175. }
  177. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetGroupParent(CXTPMarkupObject* e, BOOL bIncludeCurrent)
  178. {
  179. CXTPMarkupObject* obj2 = e;
  180. if (!bIncludeCurrent)
  181. {
  182. obj2 = e;
  183. e = GetParent(e);
  184. if (e == NULL)
  185. {
  186. return obj2;
  187. }
  188. }
  189. while (e != NULL)
  190. {
  191. if (IsGroup(e))
  192. {
  193. return e;
  194. }
  195. obj2 = e;
  196. e = GetParent(e);
  197. }
  198. return obj2;
  199. }
  201. BOOL CXTPMarkupKeyboardNavigation::IsTabStopOrGroup(CXTPMarkupObject* e)
  202. {
  203. return IsTabStop(e) || IsGroup(e);
  204. }
  206. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::FocusedElement(CXTPMarkupObject* /*e*/)
  207. {
  208. return NULL;
  209. }
  211. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetTreeFirstChild(CXTPMarkupObject* e)
  212. {
  213. CXTPMarkupObject* obj2 = FocusedElement(e);
  214. if (obj2 != NULL)
  215. {
  216. return obj2;
  217. }
  219. CXTPMarkupUIElement* o = MARKUP_DYNAMICCAST(CXTPMarkupUIElement, e);
  220. if (o != NULL && o->IsVisible())
  221. {
  222. CXTPMarkupVisual* reference = o;
  224. if (reference != NULL)
  225. {
  226. int childrenCount = reference->GetVisualChildrenCount();
  227. for (int i = 0; i < childrenCount; i++)
  228. {
  229. CXTPMarkupVisual* child = reference->GetVisualChild(i);
  230. if (IsInNavigationTree(child))
  231. {
  232. return child;
  233. }
  235. CXTPMarkupObject* firstChild = GetTreeFirstChild(child);
  236. if (firstChild != NULL)
  237. {
  238. return firstChild;
  239. }
  240. }
  241. }
  242. }
  243. return NULL;
  244. }
  246. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetTreeNextSibling(CXTPMarkupObject* e)
  247. {
  248. CXTPMarkupObject* parent = GetParent(e);
  250. {
  251. CXTPMarkupVisual* reference = MARKUP_DYNAMICCAST(CXTPMarkupVisual, parent);
  252. CXTPMarkupObject* obj4 = MARKUP_DYNAMICCAST(CXTPMarkupVisual, e);
  254. if ((reference != NULL) && obj4)
  255. {
  256. int childrenCount = reference->GetVisualChildrenCount();
  257. int childIndex = 0;
  258. while (childIndex < childrenCount)
  259. {
  260. if (reference->GetVisualChild(childIndex) == obj4)
  261. {
  262. break;
  263. }
  264. childIndex++;
  265. }
  266. childIndex++;
  267. while (childIndex < childrenCount)
  268. {
  269. CXTPMarkupObject* child = reference->GetVisualChild(childIndex);
  271. if (IsInNavigationTree(child))
  272. {
  273. return child;
  274. }
  275. childIndex++;
  276. }
  277. }
  278. }
  279. return NULL;
  280. }
  282. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetNextInTree(CXTPMarkupObject* e, CXTPMarkupObject* container)
  283. {
  284. CXTPMarkupObject* firstChild = NULL;
  285. if ((e == container) || !IsGroup(e))
  286. {
  287. firstChild = GetTreeFirstChild(e);
  288. }
  289. if ((firstChild != NULL) || (e == container))
  290. {
  291. return firstChild;
  292. }
  293. CXTPMarkupObject* parent = e;
  294. do
  295. {
  296. CXTPMarkupObject* nextSibling = GetTreeNextSibling(parent);
  297. if (nextSibling != NULL)
  298. {
  299. return nextSibling;
  300. }
  301. parent = GetParent(parent);
  302. }
  303. while ((parent != NULL) && (parent != container));
  304. return NULL;
  305. }
  307. int CXTPMarkupKeyboardNavigation::GetTabIndexHelper(CXTPMarkupObject* d)
  308. {
  309. CXTPMarkupInt* pValue = MARKUP_STATICCAST(CXTPMarkupInt, d->GetValue(m_pTabIndexProperty));
  310. return pValue ? (int)*pValue : INT_MAX;
  311. }
  313. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetFirstTabInGroup(CXTPMarkupObject* container)
  314. {
  315. CXTPMarkupObject* obj2 = NULL;
  316. int num = INT_MIN;
  317. CXTPMarkupObject* e = container;
  318. while ((e = GetNextInTree(e, container)) != NULL)
  319. {
  320. if (IsTabStopOrGroup(e))
  321. {
  322. int tabIndexHelper = GetTabIndexHelper(e);
  323. if ((tabIndexHelper < num) || (obj2 == NULL))
  324. {
  325. num = tabIndexHelper;
  326. obj2 = e;
  327. }
  328. }
  329. }
  330. return obj2;
  331. }
  333. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetNextTabWithSameIndex(CXTPMarkupObject* e, CXTPMarkupObject* container)
  334. {
  335. int tabIndexHelper = GetTabIndexHelper(e);
  336. CXTPMarkupObject* obj2 = e;
  337. while ((obj2 = GetNextInTree(obj2, container)) != NULL)
  338. {
  339. if (IsTabStopOrGroup(obj2) && (GetTabIndexHelper(obj2) == tabIndexHelper))
  340. {
  341. return obj2;
  342. }
  343. }
  344. return NULL;
  345. }
  347. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetNextTabWithNextIndex(CXTPMarkupObject* e, CXTPMarkupObject* container, XTPMarkupKeyboardNavigationMode tabbingType)
  348. {
  349. CXTPMarkupObject* obj2 = NULL;
  350. CXTPMarkupObject* obj3 = NULL;
  351. int num = INT_MIN;
  352. int num2 = INT_MIN;
  353. int tabIndexHelper = GetTabIndexHelper(e);
  354. CXTPMarkupObject* obj4 = container;
  355. while ((obj4 = GetNextInTree(obj4, container)) != NULL)
  356. {
  357. if (IsTabStopOrGroup(obj4))
  358. {
  359. int num4 = GetTabIndexHelper(obj4);
  360. if ((num4 > tabIndexHelper) && ((num4 < num2) || (obj2 == NULL)))
  361. {
  362. num2 = num4;
  363. obj2 = obj4;
  364. }
  365. if ((num4 < num) || (obj3 == NULL))
  366. {
  367. num = num4;
  368. obj3 = obj4;
  369. }
  370. }
  371. }
  372. if ((tabbingType == xtpMarkupKeyboardNavigationCycle) && (obj2 == NULL))
  373. {
  374. obj2 = obj3;
  375. }
  376. return obj2;
  377. }
  380. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetNextTabInGroup(CXTPMarkupObject* e, CXTPMarkupObject* container, XTPMarkupKeyboardNavigationMode tabbingType)
  381. {
  382. if (tabbingType == xtpMarkupKeyboardNavigationNone)
  383. {
  384. return NULL;
  385. }
  386. if ((e == NULL) || (e == container))
  387. {
  388. return GetFirstTabInGroup(container);
  389. }
  390. if (tabbingType == xtpMarkupKeyboardNavigationOnce)
  391. {
  392. return NULL;
  393. }
  394. CXTPMarkupObject* nextTabWithSameIndex = GetNextTabWithSameIndex(e, container);
  395. if (nextTabWithSameIndex != NULL)
  396. {
  397. return nextTabWithSameIndex;
  398. }
  399. return GetNextTabWithNextIndex(e, container, tabbingType);
  400. }
  402. AFX_INLINE BOOL GetBoolValue(CXTPMarkupObject* e, CXTPMarkupDependencyProperty* p)
  403. {
  404. CXTPMarkupBool* pValue = MARKUP_STATICCAST(CXTPMarkupBool, e->GetValue(p));
  405. return pValue ? (BOOL)*pValue : FALSE;
  406. }
  408. BOOL CXTPMarkupKeyboardNavigation::IsTabStop(CXTPMarkupObject* e)
  409. {
  410. if (e->IsKindOf(MARKUP_TYPE(CXTPMarkupFrameworkElement)))
  411. {
  412. CXTPMarkupFrameworkElement* pElement = (CXTPMarkupFrameworkElement*)e;
  413. return pElement->IsFocusable() && GetBoolValue(pElement, m_pIsTabStopProperty) && pElement->IsEnabled() && pElement->IsVisible();
  414. }
  415. else if (e->IsKindOf(MARKUP_TYPE(CXTPMarkupFrameworkContentElement)))
  416. {
  417. return FALSE;
  418. }
  420. return FALSE;
  421. }
  424. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetTabOnceActiveElement(CXTPMarkupObject* /*d*/)
  425. {
  426. return NULL;
  427. }
  429. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetActiveElement(CXTPMarkupObject* d)
  430. {
  431. return GetTabOnceActiveElement(d);
  432. }
  434. CXTPMarkupObject* CXTPMarkupKeyboardNavigation::GetNextTab(CXTPMarkupObject* e, CXTPMarkupObject* pContainer, BOOL goDownOnly)
  435. {
  436. XTPMarkupKeyboardNavigationMode keyNavigationMode = GetKeyNavigationMode(pContainer);
  437. if (e == NULL)
  438. {
  439. if (IsTabStop(pContainer))
  440. {
  441. return pContainer;
  442. }
  443. CXTPMarkupObject* pActiveElement = GetActiveElement(pContainer);
  444. if (pActiveElement)
  445. {
  446. return GetNextTab(NULL, pActiveElement, TRUE);
  447. }
  448. }
  449. else if (((keyNavigationMode == xtpMarkupKeyboardNavigationOnce) || (keyNavigationMode == xtpMarkupKeyboardNavigationNone)) && (pContainer != e))
  450. {
  451. if (goDownOnly)
  452. {
  453. return NULL;
  454. }
  455. CXTPMarkupObject* groupParent = GetGroupParent(pContainer);
  456. return GetNextTab(pContainer, groupParent, goDownOnly);
  457. }
  458. CXTPMarkupObject* obj4 = NULL;
  459. CXTPMarkupObject* obj5 = e;
  460. XTPMarkupKeyboardNavigationMode tabbingType = keyNavigationMode;
  461. while ((obj5 = GetNextTabInGroup(obj5, pContainer, tabbingType)) != NULL)
  462. {
  463. if (obj4 == obj5)
  464. {
  465. break;
  466. }
  467. if (obj4 == NULL)
  468. {
  469. obj4 = obj5;
  470. }
  471. CXTPMarkupObject* obj6 = GetNextTab(NULL, obj5, TRUE);
  472. if (obj6 != NULL)
  473. {
  474. return obj6;
  475. }
  476. if (tabbingType == xtpMarkupKeyboardNavigationOnce)
  477. {
  478. tabbingType = xtpMarkupKeyboardNavigationContained;
  479. }
  480. }
  481. if ((!goDownOnly && (tabbingType != xtpMarkupKeyboardNavigationContained)) && (GetParent(pContainer) != NULL))
  482. {
  483. return GetNextTab(pContainer, GetGroupParent(pContainer), FALSE);
  484. }
  485. return NULL;
  486. }
  488. void CXTPMarkupKeyboardNavigation::Navigate(CXTPMarkupInputElement* pCurrentElement, XTPMarkupFocusNavigationDirection direction)
  489. {
  490. CXTPMarkupObject* pNextInDirection = NULL;
  491. switch (direction)
  492. {
  493. case xtpMarkupFocusNavigationDirectionNext:
  494. m_pNavigationProperty = m_pTabNavigationProperty;
  495. pNextInDirection = GetNextTab(pCurrentElement, GetGroupParent(pCurrentElement, TRUE), FALSE);
  496. break;
  498.    /*case xtpMarkupFocusNavigationDirectionPrevious:
  499. m_pNavigationProperty = m_pTabNavigationProperty;
  500. pNextInDirection = GetPrevTab(pCurrentElement, NULL, FALSE);
  501. break;*/
  502. }
  504. if (pNextInDirection != NULL)
  505. {
  506. if (pNextInDirection->IsKindOf(MARKUP_TYPE(CXTPMarkupInputElement)))
  507. {
  508. ((CXTPMarkupInputElement*)pNextInDirection)->Focus();
  509. }
  510. }
  511. }
  513. void CXTPMarkupKeyboardNavigation::Navigate(CXTPMarkupInputElement* pSourceElement, UINT nChar)
  514. {
  515. if (nChar == VK_TAB)
  516. {
  517. Navigate(pSourceElement, (::GetKeyState(VK_SHIFT) & 0x8000) == 0 ? xtpMarkupFocusNavigationDirectionNext : xtpMarkupFocusNavigationDirectionPrevious);
  518. }
  519. }
  521. void CXTPMarkupKeyboardNavigation::ProcessInput(UINT nChar)
  522. {
  523. if (!m_pFocused)
  524. return;
  526. if (nChar == VK_TAB)
  527. {
  528. Navigate(m_pFocused, nChar);
  529. }
  530. }
  532. void CXTPMarkupKeyboardNavigation::Focus(CXTPMarkupInputElement* /*pInputElement*/)
  533. {
  534. // NotImplmeneted
  535. return;
  537. #if 0
  538. if (!m_pMarkupContext->m_hContextWnd)
  539. return;
  541. if (m_pFocused == pInputElement)
  542. return;
  544. if (m_pFocused)
  545. {
  546. m_pFocused->SetValue(CXTPMarkupInputElement::m_pIsKeyboardFocusedProperty, NULL);
  548. MARKUP_RELEASE(m_pFocused);
  549. }
  551. m_pFocused = pInputElement;
  553. if (m_pFocused)
  554. {
  555. m_pFocused->SetValue(CXTPMarkupInputElement::m_pIsKeyboardFocusedProperty, CXTPMarkupBool::CreateTrueValue());
  557. MARKUP_ADDREF(m_pFocused);
  559. ::SetFocus(m_pMarkupContext->m_hContextWnd);
  560. }
  561. #endif
  562. }