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

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

对话框与窗口

开发平台：

Visual C++

XTPShortcutManager.cpp：源码内容
  1. // XTPShortcutManager.cpp : implementation of the CXTPShortcutManager class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS 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"
  22. #include "Resource.h"
  24. #include "Common/XTPPropExchange.h"
  25. #include "Common/XTPVC80Helpers.h"
  26. #include "Common/XTPResourceManager.h"
  28. #include "XTPShortcutManager.h"
  29. #include "XTPCommandBars.h"
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  37. //////////////////////////////////////////////////////////////////////////
  38. // CXTPShortcutManagerAccel
  40. CXTPShortcutManagerAccel::CXTPShortcutManagerAccel()
  41. {
  42. cmd = 0;
  43. key[0].fVirt = 0;
  44. key[0].key = 0;
  45. key[1].fVirt = 0;
  46. key[1].key = 0;
  47. }
  49. CXTPShortcutManagerAccel::CXTPShortcutManagerAccel(ACCEL* pAccel)
  50. {
  51. cmd = pAccel->cmd;
  53. key[0].fVirt = pAccel->fVirt;
  54. key[0].key = pAccel->key;
  56. key[1].fVirt = 0;
  57. key[1].key = 0;
  58. }
  60. CXTPShortcutManagerAccel::CXTPShortcutManagerAccel(const CXTPShortcutManagerAccel& accel)
  61. {
  62. cmd = accel.cmd;
  64. key[0] = accel.key[0];
  65. key[1] = accel.key[1];
  66. }
  68. //////////////////////////////////////////////////////////////////////////
  69. // CXTPShortcutManagerAccelTable
  70. CXTPShortcutManagerAccelTable::CXTPShortcutManagerAccelTable()
  71. {
  73. }
  75. CXTPShortcutManagerAccelTable::~CXTPShortcutManagerAccelTable()
  76. {
  77. RemoveAll();
  78. }
  80. void CXTPShortcutManagerAccelTable::RemoveAll()
  81. {
  82. for (int i = 0; i < GetCount(); i++)
  83. {
  84. delete m_arrAccels[i];
  85. }
  86. m_arrAccels.RemoveAll();
  87. }
  89. void CXTPShortcutManagerAccelTable::RemoveAt(int nIndex)
  90. {
  91. delete m_arrAccels[nIndex];
  92. m_arrAccels.RemoveAt(nIndex);
  93. }
  95. void CXTPShortcutManagerAccelTable::Add(CXTPShortcutManagerAccel accel)
  96. {
  97. m_arrAccels.Add(new CXTPShortcutManagerAccel(accel));
  98. }
  100. void CXTPShortcutManagerAccelTable::CopyAccelTable(LPACCEL lpAccel, int nSize)
  101. {
  102. RemoveAll();
  104. for (int i = 0; i < nSize; i++)
  105. {
  106. m_arrAccels.Add(new CXTPShortcutManagerAccel(&lpAccel[i]));
  107. }
  108. }
  110. CXTPShortcutManagerAccel* CXTPShortcutManagerAccelTable::CopyAccels() const
  111. {
  112. CXTPShortcutManagerAccel* pAccels = new CXTPShortcutManagerAccel[GetCount()];
  114. for (int i = 0; i < GetCount(); i++)
  115. {
  116. pAccels[i] = *m_arrAccels[i];
  117. }
  119. return pAccels;
  120. }
  122. void CXTPShortcutManagerAccelTable::CopyAccelTable(HACCEL hAccelTable)
  123. {
  124. RemoveAll();
  126. if (hAccelTable == NULL)
  127. return;
  129. int nAccelSize = ::CopyAcceleratorTable (hAccelTable, NULL, 0);
  130. if (nAccelSize == 0)
  131. return;
  133. LPACCEL lpAccel = new ACCEL[nAccelSize];
  134. ::CopyAcceleratorTable (hAccelTable, lpAccel, nAccelSize);
  136. CopyAccelTable(lpAccel, nAccelSize);
  138. delete[] lpAccel;
  139. }
  141. int CXTPShortcutManagerAccelTable::GetCount() const
  142. {
  143. return (int)m_arrAccels.GetSize();
  144. }
  146. CXTPShortcutManagerAccel* CXTPShortcutManagerAccelTable::GetAt(int nIndex) const
  147. {
  148. return m_arrAccels.GetAt(nIndex);
  149. }
  151. void CXTPShortcutManagerAccelTable::CopyAccelTable(CXTPShortcutManagerAccelTable* pAccelTable)
  152. {
  153. RemoveAll();
  155. int nAccelSize = pAccelTable->GetCount();
  157. for (int i = 0; i < nAccelSize; i++)
  158. {
  159. m_arrAccels.Add(new CXTPShortcutManagerAccel(*pAccelTable->GetAt(i)));
  160. }
  161. }
  163. //////////////////////////////////////////////////////////////////////////
  164. // CXTPShortcutManagerKeyNameText::CXTPShortcutManagerKeyNameText
  166. CXTPShortcutManager::CKeyNameText::CKeyNameText()
  167. {
  168. static const struct
  169. {
  170. WORD    wKey;       // Virtual Key Code.
  171. LPCTSTR szKeyName;  // Display Name (i.e "CTRL").
  172. }
  173. virtKeys[] =
  174. {
  175. { _T('0'), _T("0") },
  176. { _T('1'), _T("1") },
  177. { _T('2'), _T("2") },
  178. { _T('3'), _T("3") },
  179. { _T('4'), _T("4") },
  180. { _T('5'), _T("5") },
  181. { _T('6'), _T("6") },
  182. { _T('7'), _T("7") },
  183. { _T('8'), _T("8") },
  184. { _T('9'), _T("9") },
  185. { _T('A'), _T("A") },
  186. { _T('B'), _T("B") },
  187. { _T('C'), _T("C") },
  188. { _T('D'), _T("D") },
  189. { _T('E'), _T("E") },
  190. { _T('F'), _T("F") },
  191. { _T('G'), _T("G") },
  192. { _T('H'), _T("H") },
  193. { _T('I'), _T("I") },
  194. { _T('J'), _T("J") },
  195. { _T('K'), _T("K") },
  196. { _T('L'), _T("L") },
  197. { _T('M'), _T("M") },
  198. { _T('N'), _T("N") },
  199. { _T('O'), _T("O") },
  200. { _T('P'), _T("P") },
  201. { _T('Q'), _T("Q") },
  202. { _T('R'), _T("R") },
  203. { _T('S'), _T("S") },
  204. { _T('T'), _T("T") },
  205. { _T('U'), _T("U") },
  206. { _T('V'), _T("V") },
  207. { _T('W'), _T("W") },
  208. { _T('X'), _T("X") },
  209. { _T('Y'), _T("Y") },
  210. { _T('Z'), _T("Z") },
  211. { VK_LBUTTON, _T("Left Button") },
  212. { VK_RBUTTON, _T("Right Button") },
  213. { VK_CANCEL, _T("Ctrl+Break") },
  214. { VK_MBUTTON, _T("Middle Button") },
  215. { VK_BACK, _T("Backspace") },
  216. { VK_TAB, _T("Tab") },
  217. { VK_CLEAR, _T("Clear") },
  218. { VK_RETURN, _T("Enter") },
  219. { VK_SHIFT, _T("Shift") },
  220. { VK_CONTROL, _T("Ctrl") },
  221. { VK_MENU, _T("Alt") },
  222. { VK_PAUSE, _T("Pause") },
  223. { VK_CAPITAL, _T("Caps Lock") },
  224. { VK_ESCAPE, _T("Esc") },
  225. { VK_SPACE, _T("Space") },
  226. { VK_PRIOR, _T("Page Up") },
  227. { VK_NEXT, _T("Page Down") },
  228. { VK_END, _T("End") },
  229. { VK_HOME, _T("Home") },
  230. { VK_LEFT, _T("Left Arrow") },
  231. { VK_UP, _T("Up Arrow") },
  232. { VK_RIGHT, _T("Right Arrow") },
  233. { VK_DOWN, _T("Down Arrow") },
  234. { VK_SELECT, _T("Select") },
  235. { VK_PRINT, _T("Print") },
  236. { VK_EXECUTE, _T("Execute") },
  237. { VK_SNAPSHOT, _T("Snapshot") },
  238. { VK_INSERT, _T("Ins") },
  239. { VK_DELETE, _T("Del") },
  240. { VK_HELP, _T("Help") },
  241. { VK_LWIN , _T("Win") },
  242. { VK_RWIN, _T("Win") },
  243. { VK_APPS, _T("Application") },
  244. { VK_MULTIPLY, _T("Num *") },
  245. { VK_ADD, _T("Num +") },
  246. { VK_SEPARATOR, _T("Separator") },
  247. { VK_SUBTRACT, _T("Num -") },
  248. { VK_DECIMAL, _T("Num .") },
  249. { VK_DIVIDE, _T("Num /") },
  250. { VK_F1, _T("F1") },
  251. { VK_F2, _T("F2") },
  252. { VK_F3, _T("F3") },
  253. { VK_F4, _T("F4") },
  254. { VK_F5, _T("F5") },
  255. { VK_F6, _T("F6") },
  256. { VK_F7, _T("F7") },
  257. { VK_F8, _T("F8") },
  258. { VK_F9, _T("F9") },
  259. { VK_F10, _T("F10") },
  260. { VK_F11, _T("F11") },
  261. { VK_F12, _T("F12") },
  262. { VK_NUMPAD0, _T("Num 0") },
  263. { VK_NUMPAD1, _T("Num 1") },
  264. { VK_NUMPAD2, _T("Num 2") },
  265. { VK_NUMPAD3, _T("Num 3") },
  266. { VK_NUMPAD4, _T("Num 4") },
  267. { VK_NUMPAD5, _T("Num 5") },
  268. { VK_NUMPAD6, _T("Num 6") },
  269. { VK_NUMPAD7, _T("Num 7") },
  270. { VK_NUMPAD8, _T("Num 8") },
  271. { VK_NUMPAD9, _T("Num 9") },
  272. { VK_NUMLOCK, _T("Num Lock") },
  273. { VK_SCROLL, _T("Scrl Lock") },
  274. { VK_ATTN, _T("Attn") },
  275. { VK_CRSEL, _T("Crsel") },
  276. { VK_EXSEL, _T("Exsel") },
  277. { VK_EREOF, _T("Ereof") },
  278. { VK_PLAY, _T("Play") },
  279. { VK_ZOOM, _T("Zoom") },
  280. { VK_NONAME, _T("No Name") },
  281. { VK_PA1, _T("Pa1") },
  282. { VK_OEM_CLEAR, _T("Oem Clear") },
  283. };
  285. for (int i = 0; i < _countof(virtKeys); i++)
  286. {
  287. SetAt(virtKeys[i].wKey, virtKeys[i].szKeyName);
  288. }
  289. }
  291. WORD CXTPShortcutManager::CKeyNameText::Parse(LPCTSTR lpszKey)
  292. {
  293. POSITION pos = m_mapVirtualKeys.GetStartPosition();
  294. while (pos)
  295. {
  296. WORD rKey;
  297. CString strKey;
  299. m_mapVirtualKeys.GetNextAssoc(pos, rKey, strKey);
  301. if (strKey.CompareNoCase(lpszKey) == 0)
  302. return rKey;
  303. }
  305. return 0;
  306. }
  308. CString CXTPShortcutManager::CKeyNameText::Translate(UINT nKey)
  309. {
  310. CString strKeyNameText;
  312. if (m_mapVirtualKeys.Lookup((WORD)nKey, strKeyNameText))
  313. {
  314. return strKeyNameText;
  315. }
  317. return _T("");
  318. }
  320. void CXTPShortcutManager::CKeyNameText::SetAt(UINT uiVirtKey, LPCTSTR strKeyNameText)
  321. {
  322. m_mapVirtualKeys.SetAt((WORD)uiVirtKey, strKeyNameText);
  323. }
  326. #define SAFE_DESTROY_ACCELTABLE(hAccelTable) if (hAccelTable) {::DestroyAcceleratorTable (hAccelTable); hAccelTable = NULL;}
  328. CXTPShortcutManager::CXTPShortcutManager(CXTPCommandBars* pCommandBars)
  329. {
  330. m_pCommandBars = pCommandBars;
  332. m_pAccelTable = new CXTPShortcutManagerAccelTable();
  333. m_pOriginalAccelTable = NULL;
  335. m_bAllowEscapeShortcut = FALSE;
  336. m_bUseSystemKeyNameText = FALSE;
  338. m_pKeyNameText = new CKeyNameText();
  340. m_nDisableShortcuts = 0;
  342. }
  344. CXTPShortcutManager::~CXTPShortcutManager()
  345. {
  346. SAFE_DELETE(m_pAccelTable);
  347. SAFE_DELETE(m_pOriginalAccelTable);
  349. SAFE_DELETE(m_pKeyNameText);
  351. }
  353. void CXTPShortcutManager::SetAccelerators(UINT nIDResource)
  354. {
  355. m_pAccelTable->RemoveAll();
  357. LPCTSTR lpszResourceName = MAKEINTRESOURCE(nIDResource);
  358. HINSTANCE hInst = AfxFindResourceHandle(lpszResourceName, RT_ACCELERATOR);
  360. if (hInst)
  361. {
  362. HACCEL hAccel = ::LoadAccelerators(hInst, lpszResourceName);
  364. m_pAccelTable->CopyAccelTable(hAccel);
  365. CreateOriginalAccelTable();
  366. }
  367. }
  369. void CXTPShortcutManager::SetDefaultAccelerator(HACCEL hAccelTable)
  370. {
  371. m_pAccelTable->CopyAccelTable(hAccelTable);
  372. CreateOriginalAccelTable();
  373. }
  375. void CXTPShortcutManager::CreateOriginalAccelTable()
  376. {
  377. if (m_pOriginalAccelTable == NULL)
  378. m_pOriginalAccelTable = new CXTPShortcutManagerAccelTable();
  380. m_pOriginalAccelTable->CopyAccelTable(m_pAccelTable);
  381. }
  383. void CXTPShortcutManager::Reset()
  384. {
  385. ASSERT(m_pOriginalAccelTable);
  387. if (m_pOriginalAccelTable)
  388. {
  389. m_pAccelTable->CopyAccelTable(m_pOriginalAccelTable);
  390. }
  391. }
  393. CString CXTPShortcutManager::Format(CXTPShortcutManagerAccel* lpAccel, int* pPriority)
  394. {
  395. CString str;
  396. CKeyHelper helper (lpAccel, this);
  397. helper.Format (str);
  399. if (pPriority)
  400. {
  401. *pPriority = helper.Priority();
  402. }
  404. return str;
  405. }
  407. BOOL CXTPShortcutManager::OnPreviewEditKey(CXTPShortcutManagerAccel* pAccel)
  408. {
  409. if ((pAccel->key[0].fVirt & FCONTROL) == 0
  410. && (pAccel->key[0].fVirt & FSHIFT) == 0
  411. && (pAccel->key[0].fVirt & FALT) == 0
  412. && (pAccel->key[0].fVirt & FVIRTKEY)
  413. && (pAccel->key[0].key == VK_ESCAPE) && !m_bAllowEscapeShortcut)
  414. return FALSE;
  416. return TRUE;
  417. }
  419. void CXTPShortcutManager::DisableShortcuts(BOOL bDisable)
  420. {
  421. m_nDisableShortcuts += bDisable ? +1 : -1;
  422. }
  424. BOOL CXTPShortcutManager::IsAccelMessage(CXTPShortcutManagerAccel::SHORTCUTACCEL& accel, int nKeyState, LPMSG lpMsg) const
  425. {
  426. BOOL fVirt = lpMsg->message == WM_KEYDOWN || lpMsg->message == WM_SYSKEYDOWN;
  427. WORD flags = accel.fVirt;
  429. if ( (DWORD)accel.key != lpMsg->wParam ||
  430. ((fVirt != 0) != ((flags & FVIRTKEY) != 0)))
  431. {
  432. return FALSE;
  433. }
  435. if (fVirt && ((nKeyState & (FSHIFT | FCONTROL)) != (flags & (FSHIFT | FCONTROL))))
  436. {
  437. return FALSE;
  438. }
  440. if ((nKeyState & FALT) != (flags & FALT))
  441. {
  442. return FALSE;
  443. }
  445. return TRUE;
  446. }
  448. int CXTPShortcutManager::GetAccelKeyState() const
  449. {
  450. int vkCtrl = VK_CONTROL;
  451. int vkAlt = VK_MENU;
  453. if ((GetKeyState(VK_RMENU) & 0x8000) && (GetKeyState(VK_LCONTROL) & 0x8000))
  454. {
  455. vkCtrl = VK_RCONTROL;
  456. vkAlt = VK_LMENU;
  457. }
  459. int nKeyState = 0;
  460. if (GetKeyState(vkCtrl) & 0x8000) nKeyState |= FCONTROL;
  461. if (GetKeyState(vkAlt) & 0x8000) nKeyState |= FALT;
  462. if (GetKeyState(VK_SHIFT) & 0x8000) nKeyState |= FSHIFT;
  464. return nKeyState;
  465. }
  467. BOOL CXTPShortcutManager::TranslateAccelerator(LPMSG lpMsg)
  468. {
  469. if (!m_pCommandBars || m_pCommandBars->IsCustomizeMode())
  470. return FALSE;
  472. HWND hWnd = m_pCommandBars->GetSite()->GetSafeHwnd();
  474. if (m_nDisableShortcuts > 0)
  475. return FALSE;
  477. CXTPShortcutManagerAccelTable* pAccelTable = GetDefaultAccelerator();
  479. if (pAccelTable == NULL || pAccelTable->GetCount() == 0)
  480. return FALSE;
  482. if (lpMsg->message != WM_KEYDOWN && lpMsg->message != WM_SYSKEYDOWN && lpMsg->message != WM_CHAR && lpMsg->message != WM_SYSCHAR)
  483. return FALSE;
  485. int nKeyState = GetAccelKeyState();
  487. BOOL bFound = FALSE;
  489. int nAccelSize = pAccelTable->GetCount();
  491. for (int i = 0; i < nAccelSize; i++)
  492. {
  493. CXTPShortcutManagerAccel* accel = pAccelTable->GetAt(i);
  495. if (!IsAccelMessage(accel->key[0], nKeyState, lpMsg))
  496. continue;
  498. bFound = TRUE;
  500. if (IsWindowEnabled(hWnd) && ::GetCapture() == NULL && !IsIconic(hWnd) && accel->cmd != 0)
  501. {
  502. if (accel->key[1].key != 0)
  503. {
  504. if (m_pCommandBars->GetSite()->IsFrameWnd())
  505. {
  506. CKeyHelper key(accel, this);
  507. CString strMessage, strFormat;
  509. VERIFY(XTPResourceManager()->LoadString(&strFormat, XTP_IDS_SHORTCUT_SECONDKEY));
  510. strMessage.Format(strFormat, (LPCTSTR)key.Format(&accel->key[0]));
  512. ((CFrameWnd*)m_pCommandBars->GetSite())->SetMessageText(strMessage);
  513. }
  515. BOOL bAccept = FALSE;
  517. m_nDisableShortcuts++;
  519. ::SetCapture(hWnd);
  520. while (::GetCapture() == hWnd)
  521. {
  522. MSG msg;
  523. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  525. if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN)
  526. {
  527. if (msg.wParam == VK_SHIFT || msg.wParam == VK_CONTROL || msg.wParam == VK_MENU)
  528. continue;
  530. nKeyState = GetAccelKeyState();
  532. for (int j = 0; j < nAccelSize; j++)
  533. {
  534. CXTPShortcutManagerAccel* secondAccel = pAccelTable->GetAt(j);
  536. if (secondAccel->key[0].fVirt == accel->key[0].fVirt && secondAccel->key[0].key == accel->key[0].key)
  537. {
  538. if (!IsAccelMessage(secondAccel->key[1], nKeyState, &msg))
  539. continue;
  541. bAccept = TRUE;
  542. accel = secondAccel;
  543. break;
  544. }
  545. }
  548. if (!bAccept)
  549. {
  550. MessageBeep(MB_ICONEXCLAMATION);
  551. }
  553. break;
  554. }
  556. DispatchMessage (&msg);
  558. if (msg.message == WM_COMMAND || msg.message == WM_ACTIVATE || msg.message == WM_LBUTTONDOWN ||
  559. msg.message == WM_NCACTIVATE || msg.message == WM_CLOSE || msg.message == WM_SYSCOMMAND)
  560. break;
  561. }
  562. ::ReleaseCapture();
  564. m_nDisableShortcuts--;
  566. if (IsWindow(hWnd) && m_pCommandBars->GetSite()->IsFrameWnd())
  567. {
  568. ((CFrameWnd*)m_pCommandBars->GetSite())->SetMessageText((UINT)0);
  569. }
  571. if (!bAccept)
  572. return TRUE;
  573. }
  575. SendMessage(hWnd, WM_COMMAND, accel->cmd, 0);
  576. }
  578. break;
  580. }
  582. return bFound;
  583. }
  585. BOOL CXTPShortcutManager::FindDefaultFrameAccelerator(int nCmd, CString& strShortcut)
  586. {
  587. CFrameWnd* pFrame = DYNAMIC_DOWNCAST(CFrameWnd, m_pCommandBars->GetSite());
  588. HACCEL hAccelTable = pFrame ? pFrame->m_hAccelTable : NULL;
  590. if (!hAccelTable)
  591. return FALSE;
  593. ASSERT(hAccelTable);
  595. int nAccelSize = ::CopyAcceleratorTable (hAccelTable, NULL, 0);
  597. LPACCEL lpAccel = new ACCEL[nAccelSize];
  598. ::CopyAcceleratorTable (hAccelTable, lpAccel, nAccelSize);
  600. BOOL bFound = FALSE;
  601. BOOL bEqual = FALSE;
  602. CString strFirst = _T("");
  603. int nFirstPriorety = 0;
  606. for (int i = 0; i < nAccelSize; i++)
  607. {
  608. if (lpAccel[i].cmd == nCmd)
  609. {
  610. int nPriority = 0;
  611. CXTPShortcutManagerAccel accel(&lpAccel[i]);
  612. CString str = Format(&accel, &nPriority);
  614. if (str == strShortcut)
  615. bEqual = TRUE;
  617. if (strFirst.IsEmpty() || (nFirstPriorety < nPriority))
  618. {
  619. strFirst = str;
  620. nFirstPriorety = nPriority;
  621. }
  623. bFound = TRUE;
  624. }
  625. }
  626. delete[] lpAccel;
  628. if (!bFound)
  629. strShortcut = "";
  630. else if (!bEqual)
  631. strShortcut = strFirst;
  633. return bFound;
  634. }
  636. BOOL CXTPShortcutManager::FindDefaultAccelerator(int nCmd, CString& strShortcut)
  637. {
  638. if (m_pOriginalAccelTable == NULL)
  639. return FindDefaultFrameAccelerator(nCmd, strShortcut);
  641. CXTPShortcutManagerAccelTable* pAccelTable = GetDefaultAccelerator();
  643. if (!pAccelTable || pAccelTable->GetCount() == 0)
  644. return FALSE;
  646. int nAccelSize = pAccelTable->GetCount();
  648. BOOL bFound = FALSE;
  649. BOOL bEqual = FALSE;
  650. CString strFirst = _T("");
  651. int nFirstPriorety = 0;
  653. for (int i = 0; i < nAccelSize; i++)
  654. {
  655. CXTPShortcutManagerAccel* accel = pAccelTable->GetAt(i);
  656. if (accel->cmd == (int)nCmd)
  657. {
  658. int nPriority = 0;
  659. CString str = Format(accel, &nPriority);
  661. if (str == strShortcut)
  662. bEqual = TRUE;
  664. if (strFirst.IsEmpty() || (nFirstPriorety < nPriority))
  665. {
  666. strFirst = str;
  667. nFirstPriorety = nPriority;
  668. }
  670. bFound = TRUE;
  671. }
  672. }
  674. if (!bFound)
  675. strShortcut = "";
  676. else if (!bEqual)
  677. strShortcut = strFirst;
  679. return bFound;
  680. }
  682. CXTPShortcutManager::CKeyHelper::CKeyHelper(const CXTPShortcutManagerAccel* lpAccel, CXTPShortcutManager* pManager/*= NULL*/) :
  683. m_pManager(pManager), m_lpAccel (lpAccel)
  684. {
  685. m_bAllowLocaleKey = TRUE;
  686. }
  688. CXTPShortcutManager::CKeyHelper::~CKeyHelper()
  689. {
  690. }
  692. int CXTPShortcutManager::CKeyHelper::Priority()
  693. {
  694. if (m_lpAccel == NULL)
  695. return 0;
  696. if (m_lpAccel->key[0].fVirt & FCONTROL)
  697. return 3;
  698. if (m_lpAccel->key[0].fVirt & FALT)
  699. return 2;
  700. if (m_lpAccel->key[0].fVirt & FSHIFT)
  701. return 1;
  702. return 4;
  703. }
  705. void CXTPShortcutManager::CKeyHelper::Format(CString& str) const
  706. {
  707. str.Empty ();
  709. if (m_lpAccel == NULL)
  710. {
  711. ASSERT (FALSE);
  712. return;
  713. }
  715. str = Format(&m_lpAccel->key[0]);
  717. if (m_lpAccel->key[1].key != 0)
  718. {
  719. CString str2 = Format(&m_lpAccel->key[1]);
  721. if (!str2.IsEmpty())
  722. {
  723. str += _T(", ") + str2;
  724. }
  725. }
  726. }
  728. CString CXTPShortcutManager::CKeyHelper::Format(const CXTPShortcutManagerAccel::SHORTCUTACCEL* pAccel) const
  729. {
  730. CString str;
  732. if (pAccel->key != VK_CANCEL)
  733. {
  734. if (pAccel->fVirt & FCONTROL)
  735. {
  736. AddVirtKeyStr(str, VK_CONTROL);
  737. }
  739. if (pAccel->fVirt & FSHIFT)
  740. {
  741. AddVirtKeyStr(str, VK_SHIFT);
  742. }
  744. if (pAccel->fVirt & FALT)
  745. {
  746. AddVirtKeyStr(str, VK_MENU);
  747. }
  749. if (pAccel->fVirt & 0x20)
  750. {
  751. AddVirtKeyStr (str, VK_LWIN);
  752. }
  753. }
  755. if (pAccel->key)
  756. {
  757. if (pAccel->fVirt & FVIRTKEY)
  758. {
  759. AddVirtKeyStr(str, pAccel->key, TRUE);
  760. }
  761. else if ((pAccel->key >= 1 && pAccel->key <= 26) && (pAccel->fVirt == FNOINVERT))
  762. {
  763. AddVirtKeyStr(str, VK_CONTROL);
  764. str += (char) ('A' + pAccel->key - 1);
  765. }
  766. else if (pAccel->key != VK_ESCAPE && pAccel->key != VK_TAB)
  767. {
  768. str += (char) pAccel->key;
  769. }
  770. }
  771. else if (str.GetLength() > 0)
  772. {
  773. str = str.Left(str.GetLength() - 1);
  774. }
  775. return str;
  776. }
  779. void CXTPShortcutManager::CKeyHelper::AddVirtKeyStr(CString& str, UINT uiVirtKey, BOOL bLast) const
  780. {
  781. ASSERT(m_pManager);
  782. if (!m_pManager)
  783. return;
  785. CString strKey;
  787. if (m_bAllowLocaleKey)
  788. {
  789. strKey = m_pManager->GetKeyNameText(uiVirtKey);
  790. }
  791. else
  792. {
  793. strKey = m_pManager->m_pKeyNameText->Translate(uiVirtKey);
  795. if (strKey.IsEmpty())
  796. {
  797. strKey.Format(_T("0x%x"), uiVirtKey);
  798. }
  800. }
  802. if (!strKey.IsEmpty())
  803. {
  804. str += strKey;
  806. if (!bLast)
  807. {
  808. str += '+';
  809. }
  810. }
  811. }
  813. CString CXTPShortcutManager::CKeyHelper::GetLocalKeyNameText(UINT uiVirtKey)
  814. {
  815. #define BUFFER_LEN 50
  816. TCHAR szBuffer[BUFFER_LEN + 1];
  817. ZeroMemory(szBuffer, BUFFER_LEN);
  819. if (uiVirtKey == VK_CANCEL)
  820. return _T("");
  822. UINT nScanCode = ::MapVirtualKeyEx (uiVirtKey, 0,
  823. ::GetKeyboardLayout (0)) << 16 | 0x1;
  825. if (uiVirtKey >= VK_PRIOR && uiVirtKey <= VK_HELP)
  826. {
  827. nScanCode |= 0x01000000;
  828. }
  830. ::GetKeyNameText(nScanCode, szBuffer, BUFFER_LEN);
  832. CString strKey = szBuffer;
  834. if (!strKey.IsEmpty())
  835. {
  836. strKey.MakeLower();
  838. for (int i = 0; i < strKey.GetLength(); i++)
  839. {
  840. TCHAR c = strKey[i];
  841. if (IsCharLower(c))
  842. {
  843. strKey.SetAt (i, CXTPShortcutManager::ToUpper(c));
  844. break;
  845. }
  846. }
  847. }
  849. return strKey;
  850. }
  852. BOOL CXTPShortcutManager::CompareAccelKey(TCHAR chAccel, UINT wParam)
  853. {
  854. if (wParam >= VK_NUMPAD0 && wParam <= VK_NUMPAD9)
  855. return (UINT)chAccel == (wParam + '0' - VK_NUMPAD0);
  857. TCHAR tchVirtualKey = (TCHAR)MapVirtualKey(wParam, 2);
  858. if (tchVirtualKey == NULL)
  859. return FALSE;
  861. TCHAR chAccelUpper = ToUpper(chAccel);
  863. if ((chAccel == (TCHAR)wParam) || (chAccelUpper == (TCHAR)wParam))
  864. return TRUE;
  866. UINT nLayoutCount = GetKeyboardLayoutList(0, 0);
  867. if (nLayoutCount > 1)
  868. {
  869. CArray<HKL, HKL&> arrLayoutList;
  870. arrLayoutList.SetSize(nLayoutCount);
  872. GetKeyboardLayoutList(nLayoutCount, arrLayoutList.GetData());
  874. BYTE keyState[256];
  875. if (!GetKeyboardState (keyState))
  876. return FALSE;
  878. for (UINT i = 0; i < nLayoutCount; i++)
  879. {
  880. WORD chKey = 0;
  882. #ifdef _UNICODE
  883. if (ToUnicodeEx((UINT)wParam, 0, keyState, (LPWSTR)&chKey, 1, 0, arrLayoutList[i]) == 1)
  884. #else
  885. if (ToAsciiEx((UINT)wParam, 0, keyState, &chKey, 0, arrLayoutList[i]) == 1)
  886. #endif
  887. {
  888. if ((chAccel == (TCHAR)chKey) || (chAccelUpper == ToUpper((TCHAR)chKey)))
  889. return TRUE;
  890. }
  892. BYTE ksShift = keyState[VK_SHIFT];
  893. keyState[VK_SHIFT]= 0x81;
  895. #ifdef _UNICODE
  896. if (ToUnicodeEx((UINT)wParam, 0, keyState, (LPWSTR)&chKey, 1, 0, arrLayoutList[i]) == 1)
  897. #else
  898. if (ToAsciiEx((UINT)wParam, 0, keyState, &chKey, 0, arrLayoutList[i]) == 1)
  899. #endif
  900. {
  901. if ((chAccel == (TCHAR)chKey) || (chAccelUpper == ToUpper((TCHAR)chKey)))
  902. return TRUE;
  903. }
  905. keyState[VK_SHIFT] = ksShift;
  906. }
  907. }
  909. return FALSE;
  910. }
  912. void CXTPShortcutManager::SetKeyNameText(UINT uiVirtKey, LPCTSTR strKeyNameText)
  913. {
  914. m_pKeyNameText->SetAt(uiVirtKey, strKeyNameText);
  915. }
  917. CString CXTPShortcutManager::GetKeyNameText(UINT uiVirtKey)
  918. {
  919. CString strKey;
  921. if (m_bUseSystemKeyNameText)
  922. {
  923. strKey = CKeyHelper::GetLocalKeyNameText(uiVirtKey);
  924. }
  926. if (strKey.IsEmpty())
  927. {
  928. strKey = m_pKeyNameText->Translate(uiVirtKey);
  929. }
  931. if (strKey.IsEmpty() && !m_bUseSystemKeyNameText)
  932. {
  933. strKey = CKeyHelper::GetLocalKeyNameText(uiVirtKey);
  934. }
  936. return strKey;
  937. }
  939. TCHAR CXTPShortcutManager::ToUpper(TCHAR vkTCHAR)
  940. {
  941. TCHAR szChar[2] = {vkTCHAR, _T('') };
  943. CharUpper(szChar);
  944. return szChar[0];
  945. }
  948. /////////////////////////////////////////////////////////////////////////////
  949. // CKeyAssign
  951. CXTPShortcutManager::CKeyAssign::CKeyAssign(CXTPShortcutManager* pManager/*= NULL*/)
  952. : m_keyHelper(&m_accel, pManager)
  953. {
  954. m_nKeyDefined = 0;
  955. m_bExtendedOnly = FALSE;
  957. m_bAllowDoubleKeyShortcuts = pManager ? pManager->m_bAllowDoubleKeyShortcuts : FALSE;
  959. ResetKey();
  960. }
  962. CXTPShortcutManager::CKeyAssign::~CKeyAssign()
  963. {
  964. }
  966. BOOL CXTPShortcutManager::CKeyAssign::PreTranslateMessage(MSG* pMsg)
  967. {
  968. if (pMsg->message == WM_LBUTTONDOWN || pMsg->message == WM_MBUTTONDOWN || pMsg->message == WM_RBUTTONDOWN)
  969. {
  970. SetFocus ();
  971. return TRUE;
  972. }
  974. if (pMsg->message != WM_KEYDOWN && pMsg->message != WM_SYSKEYDOWN && pMsg->message != WM_KEYUP && pMsg->message != WM_SYSKEYUP)
  975. return CEdit::PreTranslateMessage(pMsg);
  977. if (m_bAllowDoubleKeyShortcuts)
  978. return TranslateDoubleKeyShortcutsMessage(pMsg);
  980. return TranslateSingleKeyShortcutsMessage(pMsg);
  981. }
  983. BOOL CXTPShortcutManager::CKeyAssign::TranslateDoubleKeyShortcutsMessage(MSG* pMsg)
  984. {
  985. BOOL bPressed = pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN;
  986. if (!bPressed)
  987. return FALSE;
  989. BOOL bControlPressed = ::GetKeyState(VK_CONTROL) & 0x8000;
  990. BOOL bAltPressed = ::GetKeyState(VK_MENU) & 0x8000;
  992. if (!bControlPressed && !bAltPressed && (pMsg->wParam == VK_TAB))
  993. {
  994. return FALSE;
  995. }
  997. if (pMsg->wParam == VK_SHIFT || pMsg->wParam == VK_CONTROL || pMsg->wParam == VK_MENU)
  998. return FALSE;
  1000. if (pMsg->wParam == VK_BACK)
  1001. {
  1002. if (m_nKeyDefined == 2)
  1003. {
  1004. m_accel.key[1].fVirt = 0;
  1005. m_accel.key[1].key = 0;
  1006. m_nKeyDefined = 1;
  1007. }
  1008. else
  1009. {
  1010. ResetKey();
  1011. }
  1012. }
  1013. else
  1014. {
  1015. if (m_nKeyDefined > 1)
  1016. ResetKey();
  1018. // read in the actual state because we were not tracking releases if there was a
  1019. // definition
  1020. SetAccelFlag(m_nKeyDefined, FSHIFT, ::GetKeyState(VK_SHIFT) & 0x8000);
  1021. SetAccelFlag(m_nKeyDefined, FCONTROL, bControlPressed);
  1022. SetAccelFlag(m_nKeyDefined, FALT, bAltPressed);
  1024. m_accel.key[m_nKeyDefined].key = (WORD)pMsg->wParam;
  1025. SetAccelFlag(m_nKeyDefined, FVIRTKEY, TRUE);
  1027. m_nKeyDefined++;
  1028. }
  1030. if (m_keyHelper.GetShortcutManager() && !m_keyHelper.GetShortcutManager()->OnPreviewEditKey(&m_accel))
  1031. {
  1032. ResetKey();
  1033. return TRUE;
  1034. }
  1036. CString str;
  1037. m_keyHelper.Format(str);
  1039. SetWindowText(str);
  1041. SetSel(str.GetLength(), str.GetLength());
  1043. return TRUE;
  1044. }
  1046. BOOL CXTPShortcutManager::CKeyAssign::TranslateSingleKeyShortcutsMessage(MSG* pMsg)
  1047. {
  1048. BOOL bPressed = pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN;
  1050. BOOL bControlPressed = ::GetKeyState(VK_CONTROL) & 0x8000;
  1051. BOOL bAltPressed = ::GetKeyState(VK_MENU) & 0x8000;
  1052. BOOL bWinPressed = (::GetKeyState(VK_LWIN) & 0x8000) || (::GetKeyState(VK_RWIN) & 0x8000);
  1054. if (!bControlPressed && !bAltPressed && (pMsg->wParam == VK_TAB))
  1055. {
  1056. if (m_nKeyDefined == 0)
  1057. ResetKey();
  1059. return FALSE;
  1060. }
  1062. if (bPressed && !((1 << 30) & pMsg->lParam))
  1063. {
  1064. ResetKey();
  1065. }
  1067. if (m_bExtendedOnly)
  1068. {
  1069. if (bPressed)
  1070. {
  1071. SetAccelFlag(0, FSHIFT, GetKeyState(VK_SHIFT) < 0);
  1072. SetAccelFlag(0, FCONTROL, GetKeyState(VK_CONTROL) < 0);
  1073. SetAccelFlag(0, FALT, GetKeyState(VK_MENU) < 0);
  1074. SetAccelFlag(0, 0x20, bWinPressed);
  1075. }
  1076. }
  1077. else if (m_nKeyDefined == 0)
  1078. {
  1079. // read in the actual state because we were not tracking releases if there was a
  1080. // definition
  1081. SetAccelFlag(0, FSHIFT, ::GetKeyState(VK_SHIFT) & 0x8000);
  1082. SetAccelFlag(0, FCONTROL, bControlPressed);
  1083. SetAccelFlag(0, FALT, bAltPressed);
  1084. SetAccelFlag(0, 0x20, bWinPressed);
  1086. if (pMsg->wParam == VK_SHIFT
  1087. || pMsg->wParam == VK_CONTROL
  1088. || pMsg->wParam == VK_MENU
  1089. || pMsg->wParam == VK_LWIN
  1090. || pMsg->wParam == VK_RWIN
  1091. )
  1092. {
  1093. // all work is already done
  1094. }
  1095. else if (bPressed)
  1096. {
  1097. m_accel.key[0].key = (WORD)pMsg->wParam;
  1098. SetAccelFlag(0, FVIRTKEY, TRUE);
  1099. m_nKeyDefined = 1;
  1100. }
  1101. }
  1103. if (m_keyHelper.GetShortcutManager() && !m_keyHelper.GetShortcutManager()->OnPreviewEditKey(&m_accel))
  1104. {
  1105. ResetKey();
  1106. return TRUE;
  1107. }
  1109. CString str;
  1110. m_keyHelper.Format (str);
  1112. SetWindowText(str);
  1113. return TRUE;
  1114. }
  1116. void CXTPShortcutManager::CKeyAssign::ResetKey()
  1117. {
  1118. memset(&m_accel, 0, sizeof(CXTPShortcutManagerAccel));
  1119. m_nKeyDefined = 0;
  1121. if (m_hWnd != NULL)
  1122. {
  1123. SetWindowText (_T(""));
  1124. }
  1125. }
  1127. void CXTPShortcutManager::CKeyAssign::SetAccelFlag(int nKey, BYTE bFlag, BOOL bSet)
  1128. {
  1129. ASSERT(nKey == 0 || nKey == 1);
  1131. if (bSet) m_accel.key[nKey].fVirt |= bFlag;
  1132. else m_accel.key[nKey].fVirt &= ~bFlag;
  1133. }
  1135. BOOL CXTPShortcutManager::CKeyAssign::IsKeyDefined () const
  1136. {
  1137. return m_nKeyDefined != 0;
  1138. }
  1140. CXTPShortcutManagerAccel* CXTPShortcutManager::CKeyAssign::GetAccel()
  1141. {
  1142. return &m_accel;
  1143. }
  1145. void CXTPShortcutManager::CKeyAssign::SetAccel(CXTPShortcutManagerAccel* pAccel)
  1146. {
  1147. m_accel = *pAccel;
  1149. m_nKeyDefined = (m_accel.key[0].key != 0 ? 1 : 0) + (m_accel.key[1].key != 0 ? 1 : 0);
  1151. if (m_hWnd != NULL)
  1152. {
  1153. CString str;
  1154. m_keyHelper.Format (str);
  1156. SetWindowText (str);
  1157. }
  1158. }
  1160. void CXTPShortcutManager::UpdateAcellTable(LPACCEL lpAccel, int nSize)
  1161. {
  1162. m_pAccelTable->CopyAccelTable(lpAccel, nSize);
  1163. }
  1165. void CXTPShortcutManager::UpdateAcellTable(CXTPShortcutManagerAccel* lpAccel, int nSize)
  1166. {
  1167. m_pAccelTable->RemoveAll();
  1169. for (int i = 0; i < nSize; i++)
  1170. {
  1171. m_pAccelTable->Add(lpAccel[i]);
  1172. }
  1173. }
  1175. BOOL CXTPShortcutManager::GetShortcut(int ID, CXTPShortcutManagerAccel* pAccel)
  1176. {
  1177. CXTPShortcutManagerAccelTable* pAccelTable = GetDefaultAccelerator();
  1179. if (!pAccelTable)
  1180. return FALSE;
  1182. for (int i = 0; i < pAccelTable->GetCount(); i++)
  1183. {
  1184. CXTPShortcutManagerAccel* accel = pAccelTable->GetAt(i);
  1185. if (accel->cmd == ID)
  1186. {
  1187. *pAccel = *accel;
  1188. return TRUE;
  1189. }
  1190. }
  1192. return FALSE;
  1193. }
  1195. void CXTPShortcutManager::AddShortcut(long cmd, LPCTSTR strKey)
  1196. {
  1197. CXTPShortcutManagerAccel accel;
  1198. if (!ParseShortcut(strKey, &accel))
  1199. return;
  1201. accel.cmd = cmd;
  1203. m_pAccelTable->Add(accel);
  1204. }
  1206. void CXTPShortcutManager::AddShortcut(long fVirt, long key, long cmd)
  1207. {
  1208. CXTPShortcutManagerAccel accel;
  1209. accel.key[0].fVirt = (BYTE)(fVirt | FVIRTKEY);
  1210. accel.key[0].key = (WORD)key;
  1211. accel.cmd = cmd;
  1213. int nAccelSize = m_pAccelTable->GetCount();
  1215. for (int i = 0; i < nAccelSize; i++)
  1216. {
  1217. CXTPShortcutManagerAccel* accelOld = m_pAccelTable->GetAt(i);
  1218. if (CKeyHelper::EqualAccels(&accel, accelOld))
  1219. {
  1220. accelOld->cmd = cmd;
  1221. return;
  1222. }
  1223. }
  1225. m_pAccelTable->Add(accel);
  1226. }
  1228. void CXTPShortcutManager::SerializeShortcuts(CArchive& ar)
  1229. {
  1230. CXTPPropExchangeArchive px(ar);
  1231. DoPropExchange(&px);
  1232. }
  1234. void CXTPShortcutManager::SaveShortcuts(LPCTSTR lpszProfileName)
  1235. {
  1236. if (m_pOriginalAccelTable == NULL)
  1237. return;
  1239. CXTPShortcutManagerAccel* lpAccel = m_pAccelTable->CopyAccels();
  1241. AfxGetApp()->WriteProfileBinary(lpszProfileName,  _T("Accelerators"), (LPBYTE)lpAccel, m_pAccelTable->GetCount() * sizeof(CXTPShortcutManagerAccel));
  1242. AfxGetApp()->WriteProfileInt(lpszProfileName, _T("AcceleratorsVersion"), 1);
  1244. delete[] lpAccel;
  1245. }
  1247. void CXTPShortcutManager::LoadShortcuts(LPCTSTR lpszProfileName)
  1248. {
  1249. if (m_pOriginalAccelTable == NULL)
  1250. return;
  1252. int nVersion = AfxGetApp()->GetProfileInt(lpszProfileName, _T("AcceleratorsVersion"), 0);
  1254. if (nVersion == 0)
  1255. {
  1256. UINT uiSize;
  1257. LPACCEL lpAccel = 0;
  1258. if (AfxGetApp()->GetProfileBinary(lpszProfileName,  _T("Accelerators"), (LPBYTE*) &lpAccel, &uiSize))
  1259. {
  1260. int nAccelSize = uiSize / sizeof(ACCEL);
  1261. ASSERT (lpAccel != NULL);
  1263. UpdateAcellTable(lpAccel, nAccelSize);
  1265. delete[] lpAccel;
  1266. }
  1267. }
  1268. else if (nVersion == 1)
  1269. {
  1270. UINT uiSize;
  1271. CXTPShortcutManagerAccel* lpAccel = 0;
  1272. if (AfxGetApp()->GetProfileBinary(lpszProfileName,  _T("Accelerators"), (LPBYTE*) &lpAccel, &uiSize))
  1273. {
  1274. int nAccelSize = uiSize / sizeof(CXTPShortcutManagerAccel);
  1275. ASSERT (lpAccel != NULL);
  1277. UpdateAcellTable(lpAccel, nAccelSize);
  1279. delete[] lpAccel;
  1280. }
  1281. }
  1282. }
  1284. BOOL CXTPShortcutManager::ParseShortcutVirtKey(CString& strShortcutKey, int nAccel) const
  1285. {
  1286. CString str = m_pKeyNameText->Translate(nAccel) + _T('+');
  1288. int nIndex = strShortcutKey.Find(str);
  1289. if (nIndex != -1)
  1290. {
  1291. strShortcutKey = strShortcutKey.Left(nIndex) + strShortcutKey.Mid(nIndex + str.GetLength());
  1292. return TRUE;
  1293. }
  1294. return FALSE;
  1295. }
  1297. BOOL CXTPShortcutManager::ParseShortcut(CString strShortcutKey, BYTE& fVirt, WORD& key) const
  1298. {
  1299. fVirt = FVIRTKEY;
  1300. key = 0;
  1302. if (ParseShortcutVirtKey(strShortcutKey, VK_CONTROL))
  1303. {
  1304. fVirt |= FCONTROL;
  1305. }
  1307. if (ParseShortcutVirtKey(strShortcutKey, VK_MENU))
  1308. {
  1309. fVirt |= FALT;
  1310. }
  1312. if (ParseShortcutVirtKey(strShortcutKey, VK_SHIFT))
  1313. {
  1314. fVirt |= FSHIFT;
  1315. }
  1317. key = m_pKeyNameText->Parse(strShortcutKey);
  1318. if (key != 0)
  1319. return TRUE;
  1321. if (strShortcutKey.GetLength() > 3 && strShortcutKey[0] == _T('0') && strShortcutKey[1] == _T('x'))
  1322. {
  1323. SCANF_S(strShortcutKey, _T("0x%hx"), &key);
  1324. }
  1326. return key != 0;
  1327. }
  1329. BOOL CXTPShortcutManager::ParseShortcut(CString strShortcut, CXTPShortcutManagerAccel* accel)
  1330. {
  1331. int nIndex = strShortcut.Find(_T(", "));
  1332. if (nIndex == -1)
  1333. {
  1334. if (!ParseShortcut(strShortcut, accel->key[0].fVirt, accel->key[0].key))
  1335. return FALSE;
  1337. accel->key[1].fVirt = 0;
  1338. accel->key[1].key = 0;
  1339. }
  1340. else
  1341. {
  1342. if (!ParseShortcut(strShortcut.Left(nIndex), accel->key[0].fVirt, accel->key[0].key))
  1343. return FALSE;
  1345. if (!ParseShortcut(strShortcut.Mid(nIndex + 2), accel->key[1].fVirt, accel->key[1].key))
  1346. return FALSE;
  1347. }
  1350. return TRUE;
  1351. }
  1353. void CXTPShortcutManager::DoPropExchange(CXTPPropExchange* pPX)
  1354. {
  1355. pPX->ExchangeSchemaSafe();
  1357. if (pPX->IsStoring())
  1358. {
  1359. int nAccelSize = m_pAccelTable->GetCount();
  1361. if (pPX->IsAllowBlobValues())
  1362. {
  1363. CXTPShortcutManagerAccel* lpAccel = m_pAccelTable->CopyAccels();
  1365. pPX->WriteCount(nAccelSize);
  1366. pPX->Write(_T("Data"), lpAccel, nAccelSize * sizeof(CXTPShortcutManagerAccel));
  1368. delete[] lpAccel;
  1369. }
  1370. else
  1371. {
  1372. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Shortcut")));
  1373. POSITION posEnum = pEnumerator->GetPosition(nAccelSize);
  1375. for (int i = 0; i < nAccelSize; i++)
  1376. {
  1377. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1379. CXTPShortcutManagerAccel* pAccel = m_pAccelTable->GetAt(i);
  1381. CString strShortcut;
  1383. CKeyHelper keyHelper(pAccel, this);
  1384. keyHelper.m_bAllowLocaleKey = FALSE;
  1386. keyHelper.Format(strShortcut);
  1388. PX_Int(&secItem, _T("Id"), pAccel->cmd, 0);
  1389. PX_String(&secItem, _T("Key"), strShortcut);
  1390. }
  1391. }
  1392. }
  1393. else
  1394. {
  1395. m_pAccelTable->RemoveAll();
  1397. if (pPX->GetSchema() < _XTP_SCHEMA_1200)
  1398. {
  1399. if (pPX->IsAllowBlobValues())
  1400. {
  1401. int nAccelSize = (int)pPX->ReadCount();
  1402. LPACCEL lpAccel = new ACCEL[nAccelSize];
  1403. pPX->Read(_T("Data"), lpAccel, nAccelSize* sizeof(ACCEL));
  1405. UpdateAcellTable(lpAccel, nAccelSize);
  1406. delete[] lpAccel;
  1407. }
  1408. else
  1409. {
  1410. CArray<ACCEL, ACCEL&> accels;
  1411. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Accel")));
  1412. POSITION posEnum = pEnumerator->GetPosition(0);
  1413. while (posEnum)
  1414. {
  1415. ACCEL accel;
  1416. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1417. PX_UShort(&secItem, _T("Id"), (USHORT&)(accel.cmd), 0);
  1418. PX_Byte(&secItem, _T("virt"), (accel.fVirt), 0);
  1419. PX_UShort(&secItem, _T("key"), (USHORT&)(accel.key), 0);
  1420. accels.Add(accel);
  1421. }
  1422. UpdateAcellTable(accels.GetData(), (int)accels.GetSize());
  1423. }
  1425. }
  1426. else
  1427. {
  1428. if (pPX->IsAllowBlobValues())
  1429. {
  1430. int nAccelSize = (int)pPX->ReadCount();
  1431. CXTPShortcutManagerAccel* lpAccel = new CXTPShortcutManagerAccel[nAccelSize];
  1432. pPX->Read(_T("Data"), lpAccel, nAccelSize * sizeof(CXTPShortcutManagerAccel));
  1434. UpdateAcellTable(lpAccel, nAccelSize);
  1435. delete[] lpAccel;
  1436. }
  1437. else
  1438. {
  1439. CXTPPropExchangeEnumeratorPtr pEnumerator(pPX->GetEnumerator(_T("Shortcut")));
  1440. POSITION posEnum = pEnumerator->GetPosition(0);
  1441. while (posEnum)
  1442. {
  1443. CXTPShortcutManagerAccel accel;
  1444. CXTPPropExchangeSection secItem(pEnumerator->GetNext(posEnum));
  1445. PX_Int(&secItem, _T("Id"), accel.cmd, 0);
  1447. CString strShortcut;
  1448. // TODO: Add Parse Here
  1449. PX_String(&secItem, _T("Key"), strShortcut, _T(""));
  1450. if (ParseShortcut(strShortcut, &accel))
  1451. {
  1452. m_pAccelTable->Add(accel);
  1453. }
  1454. }
  1455. }
  1456. }
  1457. }
  1458. }
  1460. BOOL CXTPShortcutManager::OnBeforeAdd(CXTPShortcutManagerAccel* accel)
  1461. {
  1463. UNREFERENCED_PARAMETER(accel);
  1464. return FALSE;
  1465. }
  1467. BOOL CXTPShortcutManager::OnBeforeRemove(CXTPShortcutManagerAccel* accel)
  1468. {
  1470. UNREFERENCED_PARAMETER(accel);
  1471. return FALSE;
  1472. }