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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneKeyboardHook.cpp：源码内容
  1. // XTPDockingPaneKeyboardHook.cpp : implementation of the CXTPDockingPaneKeyboardHook class.
  2. //
  3. // This file is a part of the XTREME DOCKINGPANE 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/XTPResourceManager.h"
  24. #include "Common/XTPDrawHelpers.h"
  25. #include "Common/Resource.h"
  26. #include "Resource.h"
  28. #include "TabManager/XTPTabPaintManager.h"
  29. #include "TabManager/XTPTabManager.h"
  31. #include "XTPDockingPaneKeyboardHook.h"
  32. #include "XTPDockingPane.h"
  33. #include "XTPDockingPanePaintManager.h"
  34. #include "XTPDockingPaneManager.h"
  35. #include "XTPDockingPaneMiniWnd.h"
  38. #ifdef _DEBUG
  39. #define new DEBUG_NEW
  40. #undef THIS_FILE
  41. static char THIS_FILE[] = __FILE__;
  42. #endif
  45. /////////////////////////////////////////////////////////////////////////////
  46. // CXTPDockingPaneWindowSelect
  47. IMPLEMENT_DYNCREATE(CXTPDockingPaneWindowSelect, CMiniFrameWnd)
  49. CXTPDockingPaneWindowSelect::CXTPDockingPaneWindowSelect()
  50. {
  51. LOGFONT lfIcon;
  52. VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
  54. lfIcon.lfWeight = FW_NORMAL;
  55. m_fnt.CreateFontIndirect(&lfIcon);
  57. lfIcon.lfWeight = FW_BOLD;
  58. m_fntBold.CreateFontIndirect(&lfIcon);
  60. XTPResourceManager()->LoadString(&m_strActiveTools, XTP_IDS_DOCKINGPANE_SELECTWINDOW_ACTIVETOOLS);
  61. XTPResourceManager()->LoadString(&m_strActiveFiles, XTP_IDS_DOCKINGPANE_SELECTWINDOW_ACTIVEFILES);
  63. m_pSelected = NULL;
  64. m_pManager = NULL;
  65. m_bActivatePanes = FALSE;
  67. m_nPaneCount = 0;
  68. m_nFirstFile = 0;
  70. m_hHandCursor = AfxGetApp()->LoadStandardCursor(MAKEINTRESOURCE(32649));
  72. if (m_hHandCursor == 0)
  73. m_hHandCursor = XTPResourceManager()->LoadCursor(XTP_IDC_HAND);
  75. m_hArrowCursor = AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  76. }
  78. CXTPDockingPaneWindowSelect::~CXTPDockingPaneWindowSelect()
  79. {
  80. for (int i = 0; i < (int)m_arrItems.GetSize(); i++)
  81. {
  82. delete m_arrItems[i];
  83. }
  84. m_arrItems.RemoveAll();
  85. }
  87. int CXTPDockingPaneWindowSelect::CalcItemHeight(CDC* pDC)
  88. {
  89. CXTPFontDC font(pDC, &m_fnt);
  90. CSize szFont = pDC->GetTextExtent(_T(" "), 1);
  92. CSize szIcon = m_pManager->GetPaintManager()->GetTabPaintManager()->m_szIcon;
  94. return max(szIcon.cy + 4, szFont.cy + 4);
  95. }
  97. CXTPDockingPaneWindowSelect::CItem* CXTPDockingPaneWindowSelect::HitTest(CPoint point) const
  98. {
  99. for (int i = 0; i < (int)m_arrItems.GetSize(); i++)
  100. {
  101. CItem* pItem = m_arrItems[i];
  102. if (pItem->rc.PtInRect(point))
  103. {
  104. return pItem;
  105. }
  106. }
  107. return 0;
  108. }
  110. CString CXTPDockingPaneWindowSelect::GetItemCaption(CItem* pItem) const
  111. {
  112. if (pItem->type == itemPane)
  113. {
  114. return pItem->pPane->GetTitle();
  115. }
  116. else
  117. {
  118. CString strCaption;
  119. CFrameWnd* pChild = DYNAMIC_DOWNCAST(CFrameWnd, CWnd::FromHandle(pItem->hWndFrame));
  120. if (pChild && pChild->GetActiveDocument())
  121. {
  122. strCaption = pChild->GetActiveDocument()->GetTitle();
  123. }
  124. else
  125. {
  126. CXTPDrawHelpers::GetWindowCaption(pItem->hWndFrame, strCaption);
  127. }
  128. return strCaption;
  129. }
  130. }
  133. CString CXTPDockingPaneWindowSelect::GetItemDescription(CItem* pItem) const
  134. {
  135. if (pItem->type == itemPane)
  136. return _T("");
  138. CFrameWnd* pChild = DYNAMIC_DOWNCAST(CFrameWnd, CWnd::FromHandle(pItem->hWndFrame));
  140. if (!pChild)
  141. return _T("");
  143. CDocument* pDocument = pChild->GetActiveDocument();
  144. if (!pDocument)
  145. return _T("");
  147. CString strTypeName;
  148. if (pDocument->GetDocTemplate() != NULL) pDocument->GetDocTemplate()->GetDocString(strTypeName, CDocTemplate::regFileTypeName);
  150. return strTypeName;
  151. }
  153. CString CXTPDockingPaneWindowSelect::GetItemPath(CItem* pItem) const
  154. {
  155. if (pItem->type == itemPane)
  156. return _T("");
  158. CFrameWnd* pChild = DYNAMIC_DOWNCAST(CFrameWnd, CWnd::FromHandle(pItem->hWndFrame));
  160. if (!pChild)
  161. return _T("");
  163. CDocument* pDocument = pChild->GetActiveDocument();
  164. if (!pDocument)
  165. return  _T("");
  167. return pDocument->GetPathName();
  168. }
  171. HWND CXTPDockingPaneWindowSelect::GetMDIClient() const
  172. {
  173. CMDIFrameWnd* pFrame = DYNAMIC_DOWNCAST(CMDIFrameWnd, m_pManager->GetSite());
  174. HWND hWndClient = pFrame ? pFrame->m_hWndMDIClient : NULL;
  175. return hWndClient;
  176. }
  178. BOOL CXTPDockingPaneWindowSelect::Reposition()
  179. {
  180. CClientDC dc(this);
  181. int nItemHeight = CalcItemHeight(&dc);
  182. int nItemWidth = 163;
  184. int y = nItemHeight + 13;
  185. int x = 9;
  186. int nRow = 0;
  187. int nColumn = 0;
  189. m_pSelected = 0;
  191. CXTPDockingPaneInfoList& paneList = m_pManager->GetPaneList();
  192. POSITION pos = paneList.GetHeadPosition();
  193. while (pos)
  194. {
  195. CXTPDockingPane* pPane = paneList.GetNext(pos);
  196. if ((pPane->GetEnabled() & xtpPaneEnableClient) == 0)
  197. continue;
  199. CItem* pItem = new CItem;
  200. pItem->pPane = pPane;
  201. pItem->type = itemPane;
  203. pItem->rc = CRect(x, y, x + nItemWidth, y + nItemHeight);
  204. y += nItemHeight + 1;
  206. pItem->nIndex = (int)m_arrItems.Add(pItem);
  207. pItem->nColumn = nColumn;
  208. pItem->nRow = nRow;
  210. if (m_pManager->GetActivePane() == pPane)
  211. m_pSelected = pItem;
  213. nRow++;
  214. }
  215. m_nPaneCount = nRow;
  217. if (m_bActivatePanes && m_nPaneCount > 0)
  218. {
  219. if (m_pSelected == 0)
  220. {
  221. m_pSelected = m_arrItems[GetKeyState(VK_SHIFT) >= 0 ? 0 : nRow - 1];
  222. }
  223. else
  224. {
  225. if (GetKeyState(VK_SHIFT) >= 0)
  226. {
  227. m_pSelected = m_arrItems[m_pSelected->nIndex >= nRow - 1 ? 0 : m_pSelected->nIndex + 1];
  228. }
  229. else
  230. {
  231. m_pSelected = m_arrItems[m_pSelected->nIndex > 0 ? m_pSelected->nIndex - 1 : nRow - 1];
  232. }
  233. }
  234. }
  237. int nTotalRow = nRow;
  239. if (m_nPaneCount > 0)
  240. {
  241. CColumn col;
  242. col.nFirst = 0;
  243. col.nLast = nRow - 1;
  244. m_arrColumns.Add(col);
  245. }
  246. else
  247. {
  248. m_bActivatePanes = FALSE;
  249. }
  251. m_nFirstFile = (int)m_arrItems.GetSize();
  252. int nFirstColumn = m_nFirstFile;
  254. nRow = 0;
  255. if (m_nPaneCount > 0)
  256. {
  257. nColumn++;
  258. x += nItemWidth + 12;
  259. y = nItemHeight + 13;
  260. }
  262. HWND hWndClient = GetMDIClient();
  263. HWND hWndActive = hWndClient ? (HWND)::SendMessage(hWndClient, WM_MDIGETACTIVE, 0, 0) : 0;
  264. if (hWndActive)
  265. {
  266. HWND hWndFrame = hWndActive;
  267. while (hWndFrame)
  268. {
  269. DWORD dwStyle = GetWindowLong(hWndFrame, GWL_STYLE);
  270. if (((dwStyle & WS_VISIBLE) != 0) && ((dwStyle & WS_DISABLED) == 0))
  271. {
  272. if (nRow > 14)
  273. {
  274. CColumn colNext;
  275. colNext.nFirst = nFirstColumn;
  276. colNext.nLast = (int)m_arrItems.GetSize() - 1;
  277. m_arrColumns.Add(colNext);
  279. nTotalRow = max(nRow, nTotalRow);
  280. nFirstColumn = (int)m_arrItems.GetSize();
  281. nRow = 0;
  282. nColumn++;
  283. y = nItemHeight + 13;
  284. x += nItemWidth + 12;
  285. }
  286. CItem* pItem = new CItem;
  287. pItem->hWndFrame = hWndFrame;
  288. pItem->type = itemMDIFrame;
  290. pItem->rc = CRect(x, y, x + nItemWidth, y + nItemHeight);
  291. y += nItemHeight + 1;
  293. pItem->nIndex = (int)m_arrItems.Add(pItem);
  294. pItem->nColumn = nColumn;
  295. pItem->nRow = nRow;
  297. if (hWndActive == hWndFrame && !m_bActivatePanes)
  298. m_pSelected = pItem;
  300. nRow++;
  301. }
  303. hWndFrame = ::GetWindow(hWndFrame, GW_HWNDNEXT);
  304. }
  305. }
  306. else if (!hWndClient)
  307. {
  308. CItem* pItem = new CItem;
  309. pItem->hWndFrame = m_pManager->GetSite()->GetSafeHwnd();
  310. pItem->type = itemSDIFrame;
  312. pItem->rc = CRect(x, y, x + nItemWidth, y + nItemHeight);
  314. pItem->nIndex = (int)m_arrItems.Add(pItem);
  315. pItem->nColumn = nColumn;
  316. pItem->nRow = nRow;
  318. if (m_pSelected == NULL)
  319. m_pSelected = pItem;
  321. m_nFirstFile++;
  322. }
  324. if (nFirstColumn < m_arrItems.GetSize())
  325. {
  326. CColumn colNext;
  327. colNext.nFirst = nFirstColumn;
  328. colNext.nLast = (int)m_arrItems.GetSize() - 1;
  329. m_arrColumns.Add(colNext);
  330. }
  332. if (m_nFirstFile < m_arrItems.GetSize() - 1 && !m_bActivatePanes)
  333. {
  334. if (GetKeyState(VK_SHIFT) >= 0)
  335. m_pSelected = m_arrItems[m_nFirstFile + 1];
  336. else
  337. m_pSelected = m_arrItems[ m_arrItems.GetSize() - 1];
  338. }
  340. nTotalRow = max(nRow, nTotalRow);
  341. int nTotalColumns = max(2, (int)m_arrColumns.GetSize());
  343. CSize sz(4 + (nItemWidth + 12) * nTotalColumns,
  344. nItemHeight + 13 + nTotalRow * (nItemHeight + 1) + 110);
  346. CXTPWindowRect rcWindow(m_pManager->GetSite());
  347. CPoint ptCenter = rcWindow.CenterPoint();
  349. CRect rect(CPoint(ptCenter.x - sz.cx / 2, ptCenter.y - sz.cy /2), sz);
  350. SetWindowPos(&CWnd::wndTopMost, rect.left, rect.top, rect.Width(), rect.Height(),
  351. SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
  353. return TRUE;
  354. }
  357. BEGIN_MESSAGE_MAP(CXTPDockingPaneWindowSelect, CMiniFrameWnd)
  358. //{{AFX_MSG_MAP(CXTPDockingPaneWindowSelect)
  359. ON_WM_KILLFOCUS()
  360. ON_WM_CAPTURECHANGED()
  361. ON_WM_PAINT()
  362. ON_WM_KEYDOWN()
  363. ON_WM_SYSKEYDOWN()
  364. ON_WM_KEYUP()
  365. ON_WM_LBUTTONDOWN()
  366. ON_WM_LBUTTONUP()
  367. ON_WM_MOUSEMOVE()
  368. ON_WM_CHAR()
  369. //}}AFX_MSG_MAP
  370. END_MESSAGE_MAP()
  372. #define CS_DROPSHADOW       0x00020000
  374. /////////////////////////////////////////////////////////////////////////////
  375. // CXTPDockingPaneWindowSelect message handlers
  377. BOOL CXTPDockingPaneWindowSelect::DoModal()
  378. {
  379. CWnd* pSite = m_pManager->GetSite();
  380. HWND hWndParent = pSite->GetSafeHwnd();
  381. HWND hwndFocus = ::GetFocus();
  383. BOOL bLayoutRTL = m_pManager->IsLayoutRTL();
  384. UINT nClassStyle = bLayoutRTL ? 0 : CS_SAVEBITS | CS_OWNDC;
  386. if (XTPSystemVersion()->IsWinXPOrGreater()) // Windows XP only
  387. {
  388. nClassStyle |= CS_DROPSHADOW;
  389. }
  391. if (!CreateEx(WS_EX_TOOLWINDOW | (bLayoutRTL ? WS_EX_LAYOUTRTL : 0),
  392. AfxRegisterWndClass(nClassStyle, m_hArrowCursor), 0,
  393. WS_POPUP | MFS_SYNCACTIVE, CRect(0, 0, 0, 0), pSite, 0))
  394. return FALSE;
  396. if (!Reposition())
  397. {
  398. DestroyWindow();
  399. return FALSE;
  400. }
  402. SetFocus();
  403. SetCapture();
  405. BOOL bEnableParent = FALSE;
  406. if (hWndParent != NULL && ::IsWindowEnabled(hWndParent))
  407. {
  408. CWnd::ModifyStyle(hWndParent, 0, WS_DISABLED, 0);
  409. bEnableParent = TRUE;
  410. }
  412. m_nFlags |= WF_CONTINUEMODAL;
  414. if (m_nFlags & WF_CONTINUEMODAL)
  415. {
  416. // enter modal loop
  417. DWORD dwFlags = MLF_SHOWONIDLE;
  419. VERIFY(RunModalLoop(dwFlags) == m_nModalResult);
  420. }
  422. // hide the window before enabling the parent, etc.
  423. if (m_hWnd != NULL)
  424. SetWindowPos(NULL, 0, 0, 0, 0, SWP_HIDEWINDOW|
  425. SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
  427. if (bEnableParent)
  428. CWnd::ModifyStyle(hWndParent, WS_DISABLED, 0, 0);
  429. if (hWndParent != NULL && ::GetActiveWindow() == m_hWnd)
  430. ::SetActiveWindow(hWndParent);
  432. if (m_nModalResult == IDOK && m_pSelected)
  433. {
  434. if (m_pSelected->type == itemPane)
  435. {
  436. m_pManager->ShowPane(m_pSelected->pPane);
  437. }
  438. else if (m_pSelected->type == itemMDIFrame)
  439. {
  440. HWND hWndClient = GetMDIClient();
  441. ::SendMessage(hWndClient, WM_MDIACTIVATE, (WPARAM)m_pSelected->hWndFrame, 0);
  443. CWnd* pWnd = CWnd::FromHandle(m_pSelected->hWndFrame);
  444. CWnd* pFocus = GetFocus();
  446. BOOL bHasFocus = pFocus->GetSafeHwnd() &&
  447. (pFocus == pWnd || pWnd->IsChild(pFocus) || (pFocus->GetOwner()->GetSafeHwnd() && pWnd->IsChild(pFocus->GetOwner())));
  449. if (!bHasFocus)
  450. pWnd->SetFocus();
  451. }
  452. }
  453. else
  454. {
  455. ::SetFocus(hwndFocus);
  456. }
  458. DestroyWindow();
  459. return TRUE;
  460. }
  462. void CXTPDockingPaneWindowSelect::OnKillFocus(CWnd* pNewWnd)
  463. {
  464. CWnd::OnKillFocus(pNewWnd);
  466. if (m_nFlags & WF_CONTINUEMODAL) EndModalLoop(IDCANCEL);
  467. }
  469. void CXTPDockingPaneWindowSelect::OnCaptureChanged(CWnd *pWnd)
  470. {
  471. if (m_nFlags & WF_CONTINUEMODAL) EndModalLoop(IDCANCEL);
  473. CWnd::OnCaptureChanged(pWnd);
  474. }
  476. void CXTPDockingPaneWindowSelect::OnPaint()
  477. {
  478. CPaintDC dcPaint(this); // device context for painting
  479. CXTPClientRect rc(this);
  481. CXTPBufferDC dc(dcPaint);
  483. dc.FillSolidRect(rc, GetSysColor(COLOR_3DFACE));
  485. dc.Draw3dRect(rc, GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER), GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER));
  487. int nItemHeight = CalcItemHeight(&dc);
  489. CXTPFontDC font(&dc, &m_fntBold);
  490. dc.SetBkMode(TRANSPARENT);
  491. dc.SetTextColor(COLOR_BTNTEXT);
  492. if (m_nPaneCount > 0)
  493. {
  494. CRect rcActiveTools(9, 0, 9 + 163, nItemHeight + 12);
  495. dc.DrawText(m_strActiveTools, rcActiveTools, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  497. CRect rcActiveFiles( 9 + 13 + 163, 0, 9 + 13 + 2 * 163, nItemHeight + 12);
  498. dc.DrawText(m_strActiveFiles, rcActiveFiles, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  499. }
  500. else
  501. {
  502. CRect rcActiveFiles( 9, 0, 9 + 2 * 163, nItemHeight + 12);
  503. dc.DrawText(m_strActiveFiles, rcActiveFiles, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  504. }
  506. font.SetFont(&m_fnt);
  508. CSize szIcon = m_pManager->GetPaintManager()->GetTabPaintManager()->m_szIcon;
  510. for (int i = 0; i < (int)m_arrItems.GetSize(); i++)
  511. {
  512. CItem* pItem = m_arrItems[i];
  514. if (m_pSelected == pItem)
  515. {
  516. dc.FillSolidRect(pItem->rc, GetXtremeColor(XPCOLOR_HIGHLIGHT));
  517. dc.Draw3dRect(pItem->rc, GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER), GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER));
  519. }
  521. if (pItem->type == itemPane)
  522. {
  523. CPoint ptIcon(pItem->rc.left + 2, pItem->rc.CenterPoint().y - szIcon.cy/2);
  525. CXTPImageManagerIcon* pImage = pItem->pPane->GetIcon(szIcon.cx);
  526. if (pImage) pImage->Draw(&dc, ptIcon, szIcon);
  527. }
  528. else
  529. {
  530. CPoint ptIcon(pItem->rc.left + 2, pItem->rc.CenterPoint().y - szIcon.cy/2);
  532. HICON hIcon = (HICON)::SendMessage(pItem->hWndFrame, WM_GETICON, ICON_SMALL, 0);
  533. if (hIcon == NULL) hIcon = (HICON)::SendMessage(pItem->hWndFrame, WM_GETICON, ICON_BIG, 0);
  534. if (hIcon == NULL) hIcon = (HICON)(ULONG_PTR)::GetClassLongPtr(pItem->hWndFrame, GCLP_HICONSM);
  536. if (hIcon)
  537. {
  538. if (GetExStyle() & WS_EX_LAYOUTRTL)
  539. ::DrawIconEx(dc, ptIcon.x + szIcon.cx, ptIcon.y, hIcon, -szIcon.cx, szIcon.cy, 0, 0, DI_NORMAL);
  540. else
  541. ::DrawIconEx(dc, ptIcon.x, ptIcon.y, hIcon, szIcon.cx, szIcon.cy, 0, 0, DI_NORMAL);
  542. }
  543. }
  545. CRect rcText(pItem->rc);
  546. rcText.left += 5 + szIcon.cx;
  547. dc.DrawText(GetItemCaption(pItem), rcText, DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS | DT_NOPREFIX);
  548. }
  550. CRect rcInfoPane(11, rc.bottom - 100, rc.right - 11, rc.bottom - 10);
  551. dc.Draw3dRect(rcInfoPane, GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER), GetXtremeColor(XPCOLOR_HIGHLIGHT_BORDER));
  553. if (!m_pSelected)
  554. return;
  556. rcInfoPane.DeflateRect(15, 13, 15, 13);
  558. font.SetFont(&m_fntBold);
  560. CRect rcCaption(rcInfoPane.left, rcInfoPane.top, rcInfoPane.right, rcInfoPane.top + rcInfoPane.Height() / 3);
  561. dc.DrawText(GetItemCaption(m_pSelected), rcCaption, DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS | DT_NOPREFIX);
  563. font.SetFont(&m_fnt);
  565. CRect rcTypeName(rcInfoPane.left, rcCaption.bottom, rcInfoPane.right, rcCaption.bottom + rcInfoPane.Height() / 3);
  566. dc.DrawText(GetItemDescription(m_pSelected), rcTypeName, DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS | DT_NOPREFIX);
  568. CRect rcPathName(rcInfoPane.left, rcTypeName.bottom, rcInfoPane.right, rcInfoPane.bottom);
  569. dc.DrawText(GetItemPath(m_pSelected), rcPathName, DT_SINGLELINE | DT_VCENTER | DT_PATH_ELLIPSIS | DT_NOPREFIX);
  570. }
  572. void CXTPDockingPaneWindowSelect::Select(int nItem)
  573. {
  574. Select(nItem >= 0 && nItem < m_arrItems.GetSize() ? m_arrItems[nItem] : NULL);
  575. }
  578. void CXTPDockingPaneWindowSelect::Select(CItem* pItem)
  579. {
  580. if (m_pSelected != pItem)
  581. {
  582. m_pSelected = pItem;
  583. Invalidate(FALSE);
  584. }
  585. }
  587. void CXTPDockingPaneWindowSelect::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  588. {
  589. CMiniFrameWnd::OnChar(nChar, nRepCnt, nFlags);
  590. }
  592. void CXTPDockingPaneWindowSelect::OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  593. {
  594. OnKeyDown(nChar, nRepCnt, nFlags);
  595. }
  597. void CXTPDockingPaneWindowSelect::OnKeyDown(UINT nChar, UINT /*nRepCnt*/, UINT /*nFlags*/)
  598. {
  599. XTPDrawHelpers()->KeyToLayout(this, nChar);
  601. if (nChar == VK_TAB)
  602. {
  603. if (GetKeyState(VK_SHIFT) >= 0)
  604. {
  605. int nSelected = m_pSelected ? m_pSelected->nIndex + 1: 0;
  606. if (nSelected >= m_arrItems.GetSize())
  607. nSelected = m_nFirstFile == m_arrItems.GetSize() ? 0 : m_nFirstFile;
  608. else if (nSelected == m_nFirstFile)
  609. nSelected = 0;
  610. Select(nSelected);
  612. }
  613. else
  614. {
  615. int nSelected = m_pSelected ? m_pSelected->nIndex - 1: (int)m_arrItems.GetSize() - 1;
  616. if (nSelected < 0)
  617. nSelected = m_nFirstFile == 0 ? (int)m_arrItems.GetSize() - 1 : m_nFirstFile - 1;
  618. else if (nSelected == m_nFirstFile - 1)
  619. nSelected = (int)m_arrItems.GetSize() - 1;
  620. Select(nSelected);
  621. }
  622. }
  623. else if (nChar == VK_LEFT)
  624. {
  625. if (m_arrColumns.GetSize() > 1 && m_pSelected)
  626. {
  627. int nColumn = m_pSelected->nColumn;
  628. int nRow = m_pSelected->nRow;
  629. CColumn& col = m_arrColumns[nColumn > 0 ? nColumn - 1 : m_arrColumns.GetSize() - 1];
  630. int nItem = col.nFirst + nRow > col.nLast ? col.nLast : col.nFirst + nRow;
  631. Select(nItem);
  632. }
  634. }
  635. else if (nChar == VK_RIGHT)
  636. {
  637. if (m_arrColumns.GetSize() > 1 && m_pSelected)
  638. {
  639. int nColumn = m_pSelected->nColumn;
  640. int nRow = m_pSelected->nRow;
  641. CColumn& col = m_arrColumns[nColumn < m_arrColumns.GetSize() - 1 ? nColumn + 1 : 0];
  642. int nItem = col.nFirst + nRow > col.nLast ? col.nLast : col.nFirst + nRow;
  643. Select(nItem);
  645. }
  646. }
  647. else if (nChar == VK_DOWN)
  648. {
  649. int nSelected = m_pSelected ? m_pSelected->nIndex + 1 : 0;
  650. Select(nSelected < m_arrItems.GetSize() ? nSelected : 0);
  651. }
  652. else if (nChar == VK_UP)
  653. {
  654. int nSelected = m_pSelected ? m_pSelected->nIndex - 1 : -1;
  655. Select(nSelected >= 0 ? nSelected : (int)m_arrItems.GetSize() - 1);
  656. }
  657. else if (nChar == VK_SHIFT)
  658. {
  660. }
  661. else
  662. {
  663. EndModalLoop(IDOK);
  664. }
  665. }
  667. void CXTPDockingPaneWindowSelect::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
  668. {
  669. if (::GetKeyState(VK_CONTROL) >= 0)
  670. {
  671. EndModalLoop(IDOK);
  672. }
  674. CWnd::OnKeyUp(nChar, nRepCnt, nFlags);
  675. }
  677. void CXTPDockingPaneWindowSelect::OnLButtonDown(UINT nFlags, CPoint point)
  678. {
  679. CXTPClientRect rc(this);
  680. if (!rc.PtInRect(point))
  681. EndModalLoop(IDCANCEL);
  683. CItem* pItem = HitTest(point);
  684. if (pItem)
  685. {
  686. Select(pItem);
  687. }
  689. CWnd::OnLButtonDown(nFlags, point);
  690. }
  692. void CXTPDockingPaneWindowSelect::OnLButtonUp(UINT nFlags, CPoint point)
  693. {
  694. CItem* pItem = HitTest(point);
  695. if (pItem)
  696. {
  697. m_pSelected = pItem;
  698. EndModalLoop(IDOK);
  699. }
  701. CWnd::OnLButtonUp(nFlags, point);
  702. }
  704. void CXTPDockingPaneWindowSelect::OnMouseMove(UINT /*nFlags*/, CPoint point)
  705. {
  706. CItem* pItem = HitTest(point);
  707. ::SetCursor(pItem ? m_hHandCursor : m_hArrowCursor);
  708. }
  710. void CXTPDockingPaneWindowSelect::PostNcDestroy()
  711. {
  713. }
  715. //////////////////////////////////////////////////////////////////////////
  716. // CXTPDockingPaneKeyboardHook
  718. CThreadLocal<CXTPDockingPaneKeyboardHook> CXTPDockingPaneKeyboardHook::_xtpKeyboardThreadState;
  722. CXTPDockingPaneKeyboardHook::CXTPDockingPaneKeyboardHook()
  723. {
  724. m_pWindowSelect = 0;
  726. m_hHookKeyboard = 0;
  728. #ifdef _AFXDLL
  729. m_pModuleState = 0;
  730. #endif
  731. }
  733. CXTPDockingPaneKeyboardHook::~CXTPDockingPaneKeyboardHook()
  734. {
  735. ASSERT(m_mapSites.IsEmpty());
  736. ASSERT(m_hHookKeyboard == 0);
  737. }
  739. CXTPDockingPaneManager* CXTPDockingPaneKeyboardHook::FindFocusedManager()
  740. {
  741. HWND hWnd = GetFocus();
  742. while (hWnd)
  743. {
  744. CXTPDockingPaneManager* pManager = Lookup(hWnd);
  745. if (pManager)
  746. {
  747. if (!pManager->GetSite()->IsWindowEnabled())
  748. return FALSE;
  750. return pManager;
  751. }
  753. LONG dwStyle = ::GetWindowLong(hWnd, GWL_STYLE);
  755. if (dwStyle & WS_CHILD)
  756. {
  757. hWnd = ::GetParent(hWnd);
  758. }
  759. else if (::GetWindowLong(hWnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW)
  760. {
  761. CXTPDockingPaneMiniWnd* pMinWnd = DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd,
  762. CWnd::FromHandle(hWnd));
  764. if (pMinWnd != NULL)
  765. return pMinWnd->GetDockingPaneManager();
  767. return NULL;
  768. }
  769. else return NULL;
  770. }
  771. return NULL;
  772. }
  774. LRESULT CALLBACK CXTPDockingPaneKeyboardHook::KeyboardProc(int code, WPARAM wParam, LPARAM lParam)
  775. {
  776. CXTPDockingPaneKeyboardHook* pKeyboardManager = GetThreadState();
  778. if (code != HC_ACTION)
  779. return CallNextHookEx(pKeyboardManager->m_hHookKeyboard, code, wParam, lParam);
  781. if ((!(HIWORD(lParam) & KF_UP)))
  782. {
  783. if (wParam == VK_TAB && GetKeyState(VK_CONTROL) < 0 && !(HIWORD(lParam) & KF_ALTDOWN))
  784. {
  785. SAFE_MANAGE_STATE(pKeyboardManager->m_pModuleState);
  787. CXTPDockingPaneWindowSelect*& pWindowSelect = pKeyboardManager->m_pWindowSelect;
  789. if (pWindowSelect)
  790. {
  791. pWindowSelect->OnKeyDown(VK_TAB, 0, 0);
  792. return TRUE;
  793. }
  795. CXTPDockingPaneManager* pManager = pKeyboardManager->FindFocusedManager();
  796. if (pManager && (pManager->IsKeyboardNavigateEnabled() & xtpPaneKeyboardUseCtrlTab))
  797. {
  798. pWindowSelect = (CXTPDockingPaneWindowSelect*)pManager->GetKeyboardWindowSelectClass()->CreateObject();
  799. pWindowSelect->m_pManager = pManager;
  800. pWindowSelect->m_bActivatePanes = FALSE;
  802. BOOL bResult = pWindowSelect->DoModal();
  804. delete pWindowSelect;
  805. pWindowSelect = 0;
  807. if (bResult)
  808. return TRUE;
  809. }
  810. }
  812. if ((HIWORD(lParam) & KF_ALTDOWN) && (wParam == VK_F7) && GetKeyState(VK_CONTROL) >= 0)
  813. {
  814. SAFE_MANAGE_STATE(pKeyboardManager->m_pModuleState);
  816. CXTPDockingPaneWindowSelect*& pWindowSelect = pKeyboardManager->m_pWindowSelect;
  818. if (pWindowSelect)
  819. {
  820. pWindowSelect->OnKeyDown(VK_TAB, 0, 0);
  821. return TRUE;
  822. }
  824. CXTPDockingPaneManager* pManager = pKeyboardManager->FindFocusedManager();
  825. if (pManager && (pManager->IsKeyboardNavigateEnabled() & xtpPaneKeyboardUseAltF7))
  826. {
  827. pWindowSelect = (CXTPDockingPaneWindowSelect*)pManager->GetKeyboardWindowSelectClass()->CreateObject();
  828. pWindowSelect->m_pManager = pManager;
  829. pWindowSelect->m_bActivatePanes = TRUE;
  831. BOOL bResult = pWindowSelect->DoModal();
  833. delete pWindowSelect;
  834. pWindowSelect = 0;
  836. if (bResult)
  837. return TRUE;
  838. }
  839. }
  841. if ((HIWORD(lParam) & KF_ALTDOWN) && (wParam == VK_F6) && GetKeyState(VK_CONTROL) >= 0) // Alt + F6
  842. {
  843. SAFE_MANAGE_STATE(pKeyboardManager->m_pModuleState);
  845. CXTPDockingPaneManager* pManager = pKeyboardManager->FindFocusedManager();
  846. if (pManager && (pManager->IsKeyboardNavigateEnabled() & xtpPaneKeyboardUseAltF6))
  847. {
  848. pManager->PostMessage(WM_SYSCOMMAND,
  849. (UINT)(GetKeyState(VK_SHIFT) >= 0 ? SC_NEXTWINDOW : SC_PREVWINDOW), 0);
  850. return TRUE;
  851. }
  852. }
  854. if ((HIWORD(lParam) & KF_ALTDOWN) && ((wParam == 0xBD || wParam == VK_SUBTRACT)) &&
  855. GetKeyState(VK_CONTROL) >= 0 && GetKeyState(VK_SHIFT) >= 0) //  Alt + '-'
  856. {
  857. SAFE_MANAGE_STATE(pKeyboardManager->m_pModuleState);
  859. CXTPDockingPaneManager* pManager = pKeyboardManager->FindFocusedManager();
  860. if (pManager && (pManager->IsKeyboardNavigateEnabled() & xtpPaneKeyboardUseAltMinus))
  861. {
  862. CXTPDockingPane* pPane = pManager->GetActivePane();
  863. if (pPane)
  864. {
  865. if (!pPane->IsClosed() && !pPane->IsHidden())
  866. pManager->PostMessage(WM_SYSCOMMAND, SC_KEYMENU, MAKELONG(TEXT('-'), 0));
  867. return TRUE;
  868. }
  869. }
  870. }
  871. }
  873. return CallNextHookEx(pKeyboardManager->m_hHookKeyboard, code, wParam, lParam);
  874. }
  876. CXTPDockingPaneManager* CXTPDockingPaneKeyboardHook::Lookup(HWND hSite) const
  877. {
  878. CXTPDockingPaneManager* pManager = NULL;
  879. if (m_mapSites.Lookup(hSite, pManager))
  880. return pManager;
  882. return NULL;
  883. }
  885. void CXTPDockingPaneKeyboardHook::SetupKeyboardHook(CXTPDockingPaneManager* pManager, BOOL bSetup)
  886. {
  887. if (!pManager->GetSite())
  888. return;
  890. if (bSetup)
  891. {
  892. if (Lookup(pManager->GetSite()->GetSafeHwnd()))
  893. return;
  895. if (m_hHookKeyboard == 0)
  896. {
  897. m_hHookKeyboard = SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, AfxGetInstanceHandle(), GetCurrentThreadId());
  898. }
  901. #ifdef _AFXDLL
  902. m_pModuleState = AfxGetModuleState();
  903. #endif
  905. m_mapSites.SetAt(pManager->GetSite()->GetSafeHwnd(), pManager);
  906. }
  907. else
  908. {
  909. if (Lookup(pManager->GetSite()->GetSafeHwnd()))
  910. {
  911. m_mapSites.RemoveKey(pManager->GetSite()->GetSafeHwnd());
  912. }
  914. if (m_hHookKeyboard && m_mapSites.IsEmpty())
  915. {
  916. UnhookWindowsHookEx(m_hHookKeyboard);
  917. m_hHookKeyboard = 0;
  918. }
  919. }
  920. }