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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneManager.cpp：源码内容
  1. // XTPDockingPaneManager.cpp : implementation of the CXTPDockingPaneManager 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"
  22. #include "Common/XTPColorManager.h"
  23. #include "Common/XTPDrawHelpers.h"
  24. #include "Common/XTPImageManager.h"
  25. #include "Common/XTPToolTipContext.h"
  26. #include "Common/XTPPropExchange.h"
  27. #include "TabManager/XTPTabManager.h"
  29. #include "XTPDockingPaneManager.h"
  30. #include "XTPDockingPaneLayout.h"
  31. #include "XTPDockingPaneBase.h"
  32. #include "XTPDockingPane.h"
  33. #include "XTPDockingPaneSplitterContainer.h"
  34. #include "XTPDockingPaneTabbedContainer.h"
  35. #include "XTPDockingPaneMiniWnd.h"
  36. #include "XTPDockingPanePaintManager.h"
  37. #include "XTPDockingPaneLayout.h"
  38. #include "XTPDockingPaneAutoHidePanel.h"
  39. #include "XTPDockingPaneSidePanel.h"
  40. #include "XTPDockingPaneContext.h"
  41. #include "XTPDockingPaneKeyboardHook.h"
  43. #ifdef _DEBUG
  44. #define new DEBUG_NEW
  45. #undef THIS_FILE
  46. static char THIS_FILE[] = __FILE__;
  47. #endif
  50. CXTPDockingPaneManager::CXTPDockingPaneManager()
  51. {
  52. m_pSite = 0;
  53. m_pLayout = 0;
  55. m_nSplitterGap = 22;
  56. m_nClientMargin = 0;
  58. m_dwDefaultPaneOptions = 0;
  60. m_bAttachingPane = FALSE;
  62. m_bHideClient = FALSE;
  63. m_bUseSplitterTracker = TRUE;
  65. m_pPaintManager = NULL;
  66. SetTheme(xtpPaneThemeDefault);
  68. m_pImageManager = new CXTPImageManager();
  70. m_bLockSplitters = FALSE;
  72. m_bThemedFloatingFrames = FALSE;
  74. m_pDockingContext = new CXTPDockingPaneContext();
  75. m_pDockingContext->m_pManager = this;
  77. m_bAlphaDockingContext = FALSE;
  78. m_bShowDockingContextStickers = FALSE;
  79. m_nDockingContextStickerStyle = xtpPaneStickerStyleWhidbey;
  81. m_bCloseGroupOnButtonClick = FALSE;
  82. m_bHideGroupOnButtonClick = TRUE;
  83. m_pPreviewLayout = 0;
  84. m_bSyncActiveFloatingFrames = TRUE;
  86. m_captionDirection = xtpPaneCaptionHorizontal;
  88. m_pToolTipContext = new CXTPToolTipContext();
  90. m_pActivePane = 0;
  91. m_bShowMaximizeButton = FALSE;
  92. m_bLayoutCreated = FALSE;
  94. m_bShowContentsWhileDragging = FALSE;
  96. m_bShowSizeCursorWhileDragging = FALSE;
  97. m_bInitialUpdateCalled = FALSE;
  99. m_ptMinClientSize = CPoint(60, 60);
  101. m_hwndLastFocus = NULL;
  103. m_bStickyFloatingFrames = FALSE;
  104. m_nStickyGap = 15;
  105. m_nFloatingFramesOpacity = 255;
  106. m_rcSideDockingMargin.SetRect(0, 0, 0, 0);
  108. m_bSideDocking = FALSE;
  110. m_bKeyboardEnabled = xtpPaneKeyboardUnused;
  112. HMODULE hLib = GetModuleHandle(_T("USER32"));
  113. if (hLib)
  114. {
  115. m_pfnSetLayeredWindowAttributes = (PFNSETLAYEREDWINDOWATTRIBUTES)::GetProcAddress(hLib, "SetLayeredWindowAttributes");
  116. }
  118. XTPDrawHelpers()->RegisterWndClass(0, _T("XTPDockingPaneSplitter"), 0);
  119. XTPDrawHelpers()->RegisterWndClass(0, _T("XTPDockingPaneTabbedContainer"), CS_DBLCLKS);
  120. XTPDrawHelpers()->RegisterWndClass(0, _T("XTPDockingPaneManager"), 0);
  121. XTPDrawHelpers()->RegisterWndClass(0, _T("XTPDockingPaneAutoHidePanel"), 0);
  122. XTPDrawHelpers()->RegisterWndClass(0, _T("XTPDockingPaneMiniWnd"), CS_DBLCLKS);
  123. XTPDrawHelpers()->RegisterWndClass(0, _T("XTPDockingPaneSidePanel"), CS_DBLCLKS);
  125. m_pWindowSelectClass = RUNTIME_CLASS(CXTPDockingPaneWindowSelect);
  127. OleInitialize(NULL);
  129. EnableAutomation();
  130. }
  132. CXTPDockingPaneManager::~CXTPDockingPaneManager()
  133. {
  134. CMDTARGET_RELEASE(m_pLayout);
  136. CMDTARGET_RELEASE(m_pActivePane);
  138. CMDTARGET_RELEASE(m_pPaintManager);
  140. CMDTARGET_RELEASE(m_pToolTipContext);
  142. delete m_pDockingContext;
  144. CMDTARGET_RELEASE(m_pImageManager);
  146. OleUninitialize();
  147. }
  149. void CXTPDockingPaneManager::HideClient(BOOL bHide)
  150. {
  151. RecalcFrameLayout(NULL);
  153. m_bHideClient = bHide;
  154. m_pLayout->m_pTopContainer->OnParentContainerChanged(m_pLayout->m_pTopContainer);
  156. RedrawPanes();
  157. }
  159. BEGIN_MESSAGE_MAP(CXTPDockingPaneManager, CWnd)
  160. ON_MESSAGE(WM_SIZEPARENT, OnSizeParent)
  161. ON_MESSAGE(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  162. ON_WM_SYSCOLORCHANGE()
  163. ON_WM_SETTINGCHANGE()
  164. ON_MESSAGE_VOID(WM_INITIALUPDATE, OnInitialUpdate)
  165. ON_MESSAGE(WM_GETOBJECT, OnGetObject)
  166. END_MESSAGE_MAP()
  168. void CXTPDockingPaneManager::OnSysColorChange()
  169. {
  170. RefreshXtremeColors();
  172. m_pPaintManager->RefreshMetrics();
  175. _Redraw();
  176. }
  178. void CXTPDockingPaneManager::OnSettingChange(UINT /*uFlags*/, LPCTSTR /*lpszSection*/)
  179. {
  180. m_pPaintManager->RefreshMetrics();
  181. _Redraw();
  182. }
  184. void CXTPDockingPaneManager::SetFloatingFramesOpacity(int nOpacity)
  185. {
  186. m_nFloatingFramesOpacity = nOpacity;
  188. POSITION pos = GetPaneStack().GetHeadPosition();
  189. while (pos)
  190. {
  191. CXTPDockingPaneBase* pPane = GetPaneStack().GetNext(pos);
  193. if (pPane->GetType() == xtpPaneTypeMiniWnd)
  194. {
  195. ((CXTPDockingPaneMiniWnd*)pPane)->UpdateWindowOpacity();
  196. }
  197. }
  198. }
  200. void CXTPDockingPaneManager::UpdatePanes()
  201. {
  202. HWND hWndFocus = ::GetFocus();
  204. if (m_hwndLastFocus == hWndFocus)
  205. return;
  207. m_hwndLastFocus = hWndFocus;
  209. POSITION pos = GetPaneStack().GetHeadPosition();
  210. while (pos)
  211. {
  212. CXTPDockingPaneBase* pPane = GetPaneStack().GetNext(pos);
  214. if (pPane->GetType() == xtpPaneTypeTabbedContainer || pPane->GetType() == xtpPaneTypeMiniWnd  || pPane->GetType() == xtpPaneTypeSidePanel)
  215. {
  216. pPane->OnFocusChanged();
  217. }
  218. }
  219. }
  221. void CXTPDockingPaneManager::OnInitialUpdate()
  222. {
  223. if (m_pSite && m_pSite->IsFrameWnd() && ((CFrameWnd*)m_pSite)->m_nIdleFlags & CFrameWnd::idleLayout)
  224. {
  225. RecalcFrameLayout(NULL);
  226. }
  228. OnIdleUpdateCmdUI(TRUE, 0L);
  231. if (m_pLayout)
  232. {
  233. POSITION pos = m_pLayout->m_lstStack.GetHeadPosition();
  234. while (pos)
  235. {
  236. CXTPDockingPaneBase* pPane = m_pLayout->m_lstStack.GetNext(pos);
  237. if (pPane->GetType() == xtpPaneTypeMiniWnd)
  238. {
  239. CXTPDockingPaneMiniWnd* pMiniFrame = (CXTPDockingPaneMiniWnd*)pPane;
  241. if (pMiniFrame->GetSafeHwnd())
  242. {
  243. if (pMiniFrame->m_nIdleFlags & CFrameWnd::idleLayout)
  244. {
  245. pMiniFrame->RecalcLayout();
  246. }
  248. pMiniFrame->SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);
  249. }
  250. }
  251. }
  252. }
  254. m_bInitialUpdateCalled = TRUE;
  255. }
  258. LRESULT CXTPDockingPaneManager::OnIdleUpdateCmdUI(WPARAM /*wParam*/, LPARAM /*lParam*/)
  259. {
  260. UpdatePanes();
  261. return 0;
  262. }
  264. void CXTPDockingPaneManager::SyncPanesState()
  265. {
  266. POSITION pos = GetPaneList().GetHeadPosition();
  267. while (pos)
  268. {
  269. XTP_DOCKINGPANE_INFO& info = GetPaneList().GetNext(pos);
  270. CXTPDockingPaneBase* pContainer = info.pPane->m_pParentContainer;
  272. if (info.pPane->GetDockingSite() && pContainer)
  273. {
  274. if (pContainer->m_pParentContainer == 0 || pContainer->m_pParentContainer->GetType() != xtpPaneTypeAutoHidePanel)
  275. {
  277. if (DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, info.pPane->GetDockingSite()))
  278. {
  279. info.pLastHolder = info.pFloatingHolder = pContainer;
  280. }
  281. else
  282. {
  283. info.pLastHolder = info.pDockingHolder = pContainer;
  284. }
  285. }
  286. }
  287. }
  288. }
  290. LRESULT CXTPDockingPaneManager::OnSizeParent(WPARAM, LPARAM lParam)
  291. {
  292. if (GetTopPane() != NULL)
  293. {
  294. AFX_SIZEPARENTPARAMS* lpLayout = (AFX_SIZEPARENTPARAMS*)lParam;
  296. m_pLayout->OnSizeParent(m_pSite, lpLayout->rect, lpLayout);
  298. SyncPanesState();
  300. m_bLayoutCreated = TRUE;
  301. }
  302. return 0;
  303. }
  305. CXTPDockingPaneBase* CXTPDockingPaneManager::_Clone(CXTPDockingPaneBase* pPane)
  306. {
  307. return (CXTPDockingPaneBase*)pPane->Clone(m_pLayout, 0);
  308. }
  310. BOOL CXTPDockingPaneManager::NotifyAction(XTPDockingPaneAction action, CXTPDockingPane* pPane, CXTPDockingPaneBase* pDockContainer /*= NULL*/, XTPDockingPaneDirection dockDirection /*= xtpPaneDockLeft*/)
  311. {
  312. XTP_DOCKINGPANE_ACTION dpAction(action);
  313. dpAction.pPane = pPane;
  314. dpAction.pDockContainer = pDockContainer;
  315. dpAction.dockDirection = dockDirection;
  317. if ((pPane->GetEnabled() & xtpPaneEnableActions) == 0)
  318. dpAction.bCancel = TRUE;
  320. NotifyOwner(XTP_DPN_ACTION, (LPARAM)&dpAction);
  322. return dpAction.bCancel;
  323. }
  325. void CXTPDockingPaneManager::LockSplitters(BOOL bLock /*= TRUE*/)
  326. {
  327. m_bLockSplitters = bLock;
  329. POSITION pos = GetPaneList().GetHeadPosition();
  330. while (pos)
  331. {
  332. CXTPDockingPane* pPane = GetPaneList().GetNext(pos);
  333. if (pPane->GetContainer())
  334. SAFE_CALLPTR(pPane->GetContainer()->GetContainer(), OnChildContainerChanged(pPane));
  335. }
  336. }
  338. CXTPDockingPaneSidePanel* CXTPDockingPaneManager::DockSidePane(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CRect rc)
  339. {
  340. CXTPDockingPaneSidePanel* pMiniFrame = (CXTPDockingPaneSidePanel*)OnCreatePane(xtpPaneTypeSidePanel, m_pLayout);
  341. pMiniFrame->Init(pPane, direction, rc);
  343. SyncPanesState();
  344. m_hwndLastFocus = 0;
  346. RecalcFrameLayout(NULL, TRUE);
  348. return pMiniFrame;
  349. }
  351. CXTPDockingPaneMiniWnd* CXTPDockingPaneManager::FloatPane(CXTPDockingPaneBase* pPane, CRect rc)
  352. {
  353. ASSERT(pPane->GetType() == xtpPaneTypeDockingPane || pPane->GetType() == xtpPaneTypeTabbedContainer);
  355. if (pPane->GetType() == xtpPaneTypeDockingPane)
  356. {
  357. _RemovePane(pPane);
  358. }
  359. else
  360. {
  361. pPane = pPane->Clone(m_pLayout, 0);
  362. }
  364. CXTPDockingPaneMiniWnd* pMiniFrame = (CXTPDockingPaneMiniWnd*)OnCreatePane(xtpPaneTypeMiniWnd, m_pLayout);
  365. pMiniFrame->Init(pPane, rc);
  367. SyncPanesState();
  368. m_hwndLastFocus = 0;
  370. return pMiniFrame;
  371. }
  373. CXTPDockingPane* CXTPDockingPaneManager::CreatePane(UINT nID, CRect rc, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour)
  374. {
  375. ASSERT(GetTopPane());
  376. CXTPDockingPane* pPane = (CXTPDockingPane*)OnCreatePane(xtpPaneTypeDockingPane, m_pLayout);
  377. ASSERT(pPane);
  378. if (!pPane)
  379. return NULL;
  381. pPane->SetID(nID);
  382. pPane->SetWindowRect(rc);
  385. XTP_DOCKINGPANE_INFO pane(pPane);
  386. GetPaneList().AddTail(pane);
  388. _InsertPane(pPane, direction, pNeighbour);
  390. SyncPanesState();
  392. return pPane;
  393. }
  396. CXTPDockingPaneBase* CXTPDockingPaneManager::OnCreatePane(XTPDockingPaneType type, CXTPDockingPaneLayout* pLayout)
  397. {
  398. CXTPDockingPaneBase* pPane = NULL;
  399. switch (type)
  400. {
  401. case xtpPaneTypeDockingPane:
  402. pPane = new CXTPDockingPane(pLayout);
  403. break;
  405. case xtpPaneTypeSplitterContainer:
  406. pPane = new CXTPDockingPaneSplitterContainer(pLayout);
  407. break;
  409. case xtpPaneTypeTabbedContainer:
  410. pPane = new CXTPDockingPaneTabbedContainer(pLayout);
  411. break;
  413. case xtpPaneTypeClient:
  414. pPane = new CXTPDockingPaneClientContainer(pLayout);
  415. break;
  417. case xtpPaneTypeMiniWnd:
  418. pPane = new CXTPDockingPaneMiniWnd(pLayout);
  419. break;
  421. case xtpPaneTypeAutoHidePanel:
  422. pPane = new CXTPDockingPaneAutoHidePanel(pLayout);
  423. break;
  425. case xtpPaneTypeSidePanel:
  426. pPane = new CXTPDockingPaneSidePanel(pLayout);
  427. break;
  428. }
  429. ASSERT(pPane);
  430. return pPane;
  431. }
  434. void CXTPDockingPaneManager::DockPane(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour)
  435. {
  436. if (pPane->GetType() == xtpPaneTypeSplitterContainer)
  437. {
  438. CXTPDockingPaneBaseList lst;
  439. pPane->FindPane(xtpPaneTypeTabbedContainer, &lst);
  441. if (lst.GetCount() == 1)
  442. {
  443. pPane = lst.GetHead();
  444. }
  445. }
  447. if (pPane->GetType() == xtpPaneTypeDockingPane)
  448. {
  449. _RemovePane(pPane);
  450. }
  451. else
  452. {
  453. pPane = _Clone((CXTPDockingPaneBase*)pPane);
  454. }
  455. _InsertPane(pPane, direction, pNeighbour);
  457. m_pLayout->_FreeEmptyPanes();
  458. m_hwndLastFocus = 0;
  459. }
  461. void CXTPDockingPaneManager::_RemovePane(CXTPDockingPaneBase* pPane)
  462. {
  463. if (!pPane)
  464. return;
  466. if (!pPane->m_pParentContainer)
  467. return;
  469. pPane->m_pParentContainer->RemovePane(pPane);
  470. }
  472. void CXTPDockingPaneManager::AttachPane(CXTPDockingPaneBase* pPane, CXTPDockingPaneBase* pNeighbour)
  473. {
  474. _AttachPane(pPane, pNeighbour);
  475. SyncPanesState();
  476. }
  478. void CXTPDockingPaneManager::_AttachPane(CXTPDockingPaneBase* pPane, CXTPDockingPaneBase* pNeighbour)
  479. {
  480. ASSERT(pNeighbour);
  481. if (!pNeighbour)
  482. return;
  484. if (pNeighbour->GetType() == xtpPaneTypeDockingPane)
  485. {
  486. pNeighbour = pNeighbour->m_pParentContainer;
  487. ASSERT(pNeighbour);
  488. }
  489. if (!pNeighbour)
  490. return;
  491. ASSERT(pNeighbour->GetType() == xtpPaneTypeTabbedContainer);
  493. if (pPane->GetType() == xtpPaneTypeDockingPane)
  494. {
  495. _RemovePane(pPane);
  496. ((CXTPDockingPaneTabbedContainer*)pNeighbour)->_InsertPane((CXTPDockingPane*)pPane);
  497. }
  498. else
  499. {
  500. ASSERT(pPane->GetType() == xtpPaneTypeSplitterContainer || pPane->GetType() == xtpPaneTypeTabbedContainer);
  502. CXTPDockingPaneBaseList lst;
  503. ((CXTPDockingPaneBase*)pPane)->FindPane(xtpPaneTypeDockingPane, &lst);
  505. ASSERT(lst.GetCount() > 0);
  506. POSITION pos = lst.GetHeadPosition();
  507. while (pos)
  508. {
  509. CXTPDockingPaneBase* pListPane = lst.GetNext(pos);
  510. ASSERT(pListPane->GetType() == xtpPaneTypeDockingPane);
  512. _RemovePane(pListPane);
  513. ((CXTPDockingPaneTabbedContainer*)pNeighbour)->_InsertPane((CXTPDockingPane*)pListPane);
  514. }
  516. }
  517. m_hwndLastFocus = NULL;
  518. }
  520. CRect CXTPDockingPaneManager::_CalculateResultDockingRect(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour)
  521. {
  522. if (pNeighbour == NULL)
  523. {
  524. pNeighbour = GetTopPane();
  525. }
  527. ASSERT(pNeighbour);
  528. if (!pNeighbour)
  529. return CRect(0, 0, 0, 0);
  531. BOOL bHoriz = (direction == xtpPaneDockLeft || direction == xtpPaneDockRight);
  533. if (pNeighbour == GetTopPane())
  534. {
  535. CXTPDockingPaneSplitterContainer* pSplitter = (CXTPDockingPaneSplitterContainer*)pNeighbour;
  537. return CXTPDockingPaneSplitterContainer::_CalculateResultDockingRectChild(pSplitter, pPane, direction);
  538. }
  539. else
  540. {
  541. ASSERT(pNeighbour->m_pParentContainer);
  542. if (!pNeighbour->m_pParentContainer)
  543. return CRect(0, 0, 0, 0);
  545. if (pNeighbour->m_pParentContainer->GetType() == xtpPaneTypeTabbedContainer)
  546. {
  547. pNeighbour = pNeighbour->m_pParentContainer;
  548. ASSERT(pNeighbour->m_pParentContainer != NULL);
  549. if (!pNeighbour->m_pParentContainer)
  550. return CRect(0, 0, 0, 0);
  551. }
  553. ASSERT(pNeighbour->m_pParentContainer);
  554. ASSERT(pNeighbour->m_pParentContainer->GetType() == xtpPaneTypeSplitterContainer);
  556. CXTPDockingPaneSplitterContainer* pSplitter = (CXTPDockingPaneSplitterContainer*)pNeighbour->m_pParentContainer;
  558. if (pSplitter->m_bHoriz == bHoriz)
  559. return pSplitter->_CalculateResultDockingRectSelf(pPane, direction, pNeighbour);
  561. return CXTPDockingPaneSplitterContainer::_CalculateResultDockingRectChild(pNeighbour, pPane, direction);
  562. }
  563. }
  565. void CXTPDockingPaneManager::_InsertPane(CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour)
  566. {
  567. ASSERT(pPane->m_pParentContainer == NULL);
  569. if (pNeighbour == NULL || (pNeighbour->GetType() == xtpPaneTypeDockingPane &&
  570. (IsPaneHidden((CXTPDockingPane*)pNeighbour) || IsPaneClosed((CXTPDockingPane*)pNeighbour))))
  571. {
  572. pNeighbour = GetTopPane();
  573. }
  575. ASSERT(pNeighbour);
  576. if (!pNeighbour)
  577. return;
  579. CWnd* pParentFrame = pNeighbour->GetDockingSite();
  580. ASSERT(pParentFrame != NULL);
  582. BOOL bHoriz = (direction == xtpPaneDockLeft || direction == xtpPaneDockRight);
  583. BOOL bAfter = (direction == xtpPaneDockRight || direction == xtpPaneDockBottom);
  585. if (pPane->GetType() == xtpPaneTypeDockingPane)
  586. {
  587. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)OnCreatePane(xtpPaneTypeTabbedContainer, m_pLayout);
  588. pContainer->Init((CXTPDockingPane*)pPane, pParentFrame);
  590. pPane = pContainer;
  591. }
  593. if (pNeighbour == GetTopPane())
  594. {
  595. CXTPDockingPaneSplitterContainer* pSplitter = (CXTPDockingPaneSplitterContainer*)pNeighbour;
  597. if (pSplitter->m_bHoriz == bHoriz)
  598. pSplitter->_InsertPane(pPane, NULL, bAfter);
  599. else
  600. {
  601. CXTPDockingPaneSplitterContainer* pChildSplitter = (CXTPDockingPaneSplitterContainer*)OnCreatePane(xtpPaneTypeSplitterContainer, m_pLayout);
  602. pChildSplitter->Init(pSplitter, bHoriz, pParentFrame);
  604. pChildSplitter->_InsertPane(pPane, NULL, bAfter);
  605. m_pLayout->m_pTopContainer = pChildSplitter;
  606. }
  607. }
  608. else
  609. {
  610. ASSERT(pNeighbour->m_pParentContainer);
  611. if (!pNeighbour->m_pParentContainer)
  612. return;
  614. if (pNeighbour->m_pParentContainer->GetType() == xtpPaneTypeTabbedContainer)
  615. {
  616. pNeighbour = pNeighbour->m_pParentContainer;
  617. ASSERT(pNeighbour->m_pParentContainer != NULL);
  618. if (!pNeighbour->m_pParentContainer)
  619. return;
  620. }
  622. ASSERT(pNeighbour->m_pParentContainer);
  623. ASSERT(pNeighbour->m_pParentContainer->GetType() == xtpPaneTypeSplitterContainer);
  625. CXTPDockingPaneSplitterContainer* pSplitter = (CXTPDockingPaneSplitterContainer*)pNeighbour->m_pParentContainer;
  627. if (pSplitter->m_bHoriz == bHoriz)
  628. {
  629. pSplitter->_InsertPane(pPane, pNeighbour, bAfter);
  630. }
  631. else
  632. {
  633. CXTPDockingPaneSplitterContainer* pChildSplitter = (CXTPDockingPaneSplitterContainer*)OnCreatePane(xtpPaneTypeSplitterContainer, m_pLayout);
  634. pChildSplitter->Init(pNeighbour, bHoriz, pParentFrame);
  636. pChildSplitter->_InsertPane(pPane, pNeighbour, bAfter);
  637. pSplitter->_Replace(pNeighbour, pChildSplitter);
  638. }
  641. }
  642. RecalcFrameLayout(pNeighbour, TRUE);
  643. }
  645. CXTPDockingPaneBase* CXTPDockingPaneManager::_GetHolder(CXTPDockingPaneBase* pPane, BOOL bFloating)
  646. {
  647. POSITION pos = GetPaneList().GetHeadPosition();
  648. while (pos)
  649. {
  650. XTP_DOCKINGPANE_INFO& info = GetPaneList().GetNext(pos);
  651. if (info.pPane == pPane)
  652. return bFloating ? info.pFloatingHolder : info.pDockingHolder;
  653. }
  654. return NULL;
  655. }
  657. void CXTPDockingPaneManager::ToggleAutoHide(CXTPDockingPaneBase* pPane)
  658. {
  659. if (pPane == NULL)
  660. return;
  662. if (pPane->IsHidden())
  663. {
  664. if (pPane->GetType() == xtpPaneTypeDockingPane && m_bHideGroupOnButtonClick)
  665. {
  666. pPane = pPane->m_pParentContainer;
  667. }
  669. ToggleDocking(pPane);
  670. }
  671. else
  672. {
  673. HidePane(pPane);
  674. }
  675. }
  677. void CXTPDockingPaneManager::ToggleDocking(CXTPDockingPaneBase* pPane)
  678. {
  679. ASSERT(pPane);
  680. if (!pPane)
  681. return;
  682. BOOL bFloating = DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, pPane->GetDockingSite()) != NULL;
  683. BOOL bHidden = pPane->IsHidden();
  684. BOOL bDocking = !bFloating && !bHidden;
  686. if (pPane->GetType() == xtpPaneTypeSplitterContainer || pPane->GetType() == xtpPaneTypeTabbedContainer)
  687. {
  689. CXTPDockingPaneBaseList lst;
  690. ((CXTPDockingPaneBase*)pPane)->FindPane(xtpPaneTypeDockingPane, &lst);
  692. int nIDSelected = 0, nIDFocused = 0;
  694. POSITION pos = lst.GetHeadPosition();
  695. while (pos)
  696. {
  697. CXTPDockingPane* pListPane = (CXTPDockingPane*)lst.GetNext(pos);
  698. if (pListPane->IsSelected()) nIDSelected = pListPane->GetID();
  699. if (pListPane->IsFocus()) nIDFocused = pListPane->GetID();
  700. }
  702. pos = lst.GetHeadPosition();
  703. CXTPDockingPaneBase* pLastHolder = NULL;
  704. while (pos)
  705. {
  706. CXTPDockingPane* pListPane = (CXTPDockingPane*)lst.GetNext(pos);
  708. CXTPDockingPaneTabbedContainer* pHolder = (CXTPDockingPaneTabbedContainer*)_GetHolder(pListPane, bDocking);
  709. if (!_ToggleDocking(pListPane, pHolder ? pHolder : pLastHolder))
  710. {
  711. if (pListPane->GetID() == nIDSelected) nIDSelected = 0;
  712. if (pListPane->GetID() == nIDFocused) nIDFocused = 0;
  713. }
  715. pLastHolder = pHolder ? pHolder : pListPane->GetContainer();
  716. }
  718. if (nIDFocused > 0)
  719. ShowPane(nIDFocused);
  720. else if (nIDSelected > 0)
  721. ShowPane(nIDSelected);
  722. }
  723. else if (pPane->GetType() == xtpPaneTypeDockingPane)
  724. {
  725. CXTPDockingPaneTabbedContainer* pHolder = (CXTPDockingPaneTabbedContainer*)_GetHolder(pPane, bDocking);
  726. _ToggleDocking((CXTPDockingPane*)pPane, pHolder);
  727. }
  728. else
  729. {
  730. ASSERT(FALSE);
  731. }
  734. m_pLayout->_FreeEmptyPanes();
  735. m_hwndLastFocus = 0;
  736. }
  740. BOOL CXTPDockingPaneManager::_ToggleDocking(CXTPDockingPane* pPane, CXTPDockingPaneBase* pHolder)
  741. {
  742. BOOL bFloating = DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, pPane->GetDockingSite()) != NULL;
  743. BOOL bHidden = pPane->IsHidden();
  744. BOOL bDocking = !bFloating && !bHidden;
  747. if (bFloating && (pPane->GetOptions() & xtpPaneNoDockable))
  748. return FALSE;
  750. if (bDocking && (pPane->GetOptions() & xtpPaneNoFloatable))
  751. return FALSE;
  753. if (NotifyAction(bHidden ? xtpPaneActionPinning : !bDocking ? xtpPaneActionDocking : xtpPaneActionFloating, pPane, pHolder))
  754. return FALSE;
  756. if (pHolder)
  757. {
  758. m_bAttachingPane = TRUE;
  759. AttachPane(pPane, pHolder);
  760. m_bAttachingPane = FALSE;
  761. }
  762. else
  763. {
  764. FloatPane(pPane, pPane->GetContainer()->GetPaneWindowRect());
  765. }
  767. NotifyAction(bHidden ? xtpPaneActionPinned : !bDocking ? xtpPaneActionDocked : xtpPaneActionFloated, pPane);
  769. return TRUE;
  770. }
  772. void CXTPDockingPaneManager::EnableKeyboardNavigate(DWORD options)
  773. {
  774. CXTPDockingPaneKeyboardHook::GetThreadState()->SetupKeyboardHook(this, options != xtpPaneKeyboardUnused);
  775. m_bKeyboardEnabled = options;
  776. }
  778. bool CXTPDockingPaneManager::InstallDockingPanes(CWnd* pSite, bool bClipChildren/*=true*/)
  779. {
  780. #ifdef _DEBUG
  781. // must be a valid frame window.
  782. ASSERT(::IsWindow(pSite->GetSafeHwnd()));
  784. // should not be initialized yet.
  785. ASSERT(m_pLayout == 0);
  786. ASSERT(m_pSite == 0);
  787. #endif
  789. if (!::IsWindow(pSite->GetSafeHwnd()) || m_pSite != 0)
  790. {
  791. // if the docking site is not a valid frame window handle,
  792. // or the docking site is already initialized, return false.
  793. return false;
  794. }
  796. // Frame windows must have the WS_CLIPCHILDREN and WS_CLIPSIBLINGS
  797. // styles for panes to be drawn correctly when they are displayed
  798. // from a hidden state. WS_CLIPSIBLINGS should already be set by
  799. // default for most frames, however we will include it here just
  800. // in case.
  802. if (bClipChildren /*&& DYNAMIC_DOWNCAST(CMDIFrameWnd, pSite) == 0*/)
  803. {
  804. long lStyle = ::GetWindowLong(pSite->GetSafeHwnd(), GWL_STYLE);
  805. if ((lStyle & WS_CLIPSIBLINGS) == 0 || (lStyle & WS_CLIPCHILDREN) == 0)
  806. {
  807. ::SetWindowLong(pSite->GetSafeHwnd(), GWL_STYLE,
  808. lStyle | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  809. }
  810. }
  812. if (!Create(_T("XTPDockingPaneManager"), _T(""), WS_CHILD, CRect(0, 0, 0, 0), pSite, 0))
  813. return false;
  815. m_pSite = pSite;
  816. m_pLayout = CreateLayout();
  817. m_pLayout->m_bUserLayout = FALSE;
  820. CMenu* pMenu = m_pSite->GetSystemMenu(FALSE);
  821. if (pMenu)
  822. {
  823. pMenu->GetMenuString(SC_MOVE, m_strMove, MF_BYCOMMAND);
  824. if (m_strMove.IsEmpty()) m_strMove = _T("&Move");
  825. }
  827. return true;
  828. }
  830. CXTPDockingPane* CXTPDockingPaneManager::FindPane(int nID) const
  831. {
  832. if (!m_pLayout)
  833. return NULL;
  835. POSITION pos = GetPaneList().GetHeadPosition();
  836. while (pos)
  837. {
  838. CXTPDockingPane* pPane = GetPaneList().GetNext(pos);
  839. if (pPane->GetID() == nID)
  840. return pPane;
  841. }
  843. return NULL;
  844. }
  846. BOOL CXTPDockingPaneManager::SetIcons(UINT nIDResource, const int* nIDs, int nCount, COLORREF clrMask)
  847. {
  848. CImageList il;
  849. il.Create(16, 16, ILC_COLOR24 | ILC_MASK, nCount, 1);
  851. CBitmap bmp;
  852. bmp.LoadBitmap(nIDResource);
  853. il.Add(&bmp, clrMask);
  855. ASSERT(il.GetImageCount() == nCount); // Icons must be 16x16.
  856. if (il.GetImageCount() != nCount)
  857. return FALSE;
  859. for (int i = 0; i < nCount; i++)
  860. {
  861. HICON hIcon = il.ExtractIcon(i);
  862. if (nIDs[i] > 0)
  863. {
  864. SetIcon(nIDs[i], hIcon);
  865. }
  866. DestroyIcon(hIcon);
  867. }
  869. return TRUE;
  870. }
  872. void CXTPDockingPaneManager::SetImageManager(CXTPImageManager* pImageManager)
  873. {
  874. if (pImageManager)
  875. {
  876. m_pImageManager->InternalRelease();
  878. m_pImageManager = pImageManager;
  879. }
  880. }
  882. void CXTPDockingPaneManager::ShowPane(CXTPDockingPane* pPane, BOOL bSetFocus /*= TRUE*/)
  883. {
  884. if (pPane == NULL || m_pLayout == NULL) return;
  886. if (pPane->m_pParentContainer == NULL)
  887. {
  888. POSITION pos = GetPaneList().GetHeadPosition();
  889. while (pos)
  890. {
  891. XTP_DOCKINGPANE_INFO& info = GetPaneList().GetNext(pos);
  892. if (info.pPane == pPane && info.pLastHolder != NULL)
  893. {
  894. ((CXTPDockingPaneTabbedContainer*)info.pLastHolder)->_InsertPane(pPane, bSetFocus);
  895. }
  896. }
  897. }
  898. else
  899. {
  900. ((CXTPDockingPaneTabbedContainer*)pPane->m_pParentContainer)->ShowPane(pPane, bSetFocus);
  901. }
  903. if (bSetFocus && m_bLayoutCreated)
  904. {
  905. pPane->ShowWindow(TRUE);
  906. }
  908. if (bSetFocus)
  909. {
  910. pPane->SetFocus();
  911. }
  912. }
  914. LRESULT CXTPDockingPaneManager::NotifyOwner(UINT nCode, LPARAM lParam)
  915. {
  916. CWnd* pOwner = m_hWndOwner != NULL ? GetOwner() : m_pSite;
  917. ASSERT_VALID(pOwner);
  919. return pOwner->SendMessage(XTPWM_DOCKINGPANE_NOTIFY,
  920. (WPARAM)nCode, lParam);
  921. }
  923. void CXTPDockingPaneManager::ClosePane(CXTPDockingPane* pPane)
  924. {
  925. if (pPane == NULL)
  926. return;
  928. pPane->InternalAddRef();
  930. if (NotifyOwner(XTP_DPN_CLOSEPANE, (LPARAM)pPane) != XTP_ACTION_NOCLOSE)
  931. {
  932. SAFE_CALLPTR(pPane->m_pParentContainer, RemovePane(pPane));
  933. }
  935. pPane->InternalRelease();
  936. }
  939. void CXTPDockingPaneManager::HidePane(CXTPDockingPaneBase* pPane)
  940. {
  941. if (pPane == NULL) return;
  943. if (pPane->GetType() == xtpPaneTypeDockingPane && m_bHideGroupOnButtonClick)
  944. {
  945. pPane = pPane->m_pParentContainer;
  946. }
  948. if (pPane == NULL || pPane->GetContainer() == NULL)
  949. return;
  951. if (pPane->GetContainer()->GetType() == xtpPaneTypeAutoHidePanel)
  952. {
  953. ((CXTPDockingPaneAutoHidePanel*)pPane->GetContainer())->CloseActiveWindow();
  954. return;
  955. }
  957. m_pLayout->HidePane(pPane);
  959. RecalcFrameLayout(NULL, TRUE);
  960. }
  962. void CXTPDockingPaneManager::DestroyPane(CXTPDockingPane* pPane)
  963. {
  964. if (m_pLayout && pPane)
  965. {
  966. m_pLayout->DestroyPane(pPane);
  967. RecalcFrameLayout(NULL);
  968. }
  969. }
  971. BOOL CXTPDockingPaneManager::IsPaneClosed(CXTPDockingPane* pPane) const
  972. {
  973. return pPane == NULL || pPane->IsClosed();
  974. }
  976. BOOL CXTPDockingPaneManager::IsPaneHidden(CXTPDockingPane* pPane) const
  977. {
  978. return pPane != NULL && pPane->IsHidden();
  979. }
  981. BOOL CXTPDockingPaneManager::IsPaneSelected(CXTPDockingPane* pPane) const
  982. {
  983. return pPane != NULL && pPane->IsSelected();
  984. }
  986. void CXTPDockingPaneManager::_Redraw()
  987. {
  988. if (!m_hWnd)
  989. return;
  991. POSITION pos = GetPaneList().GetHeadPosition();
  992. while (pos)
  993. {
  994. CXTPDockingPane* pPane = GetPaneList().GetNext(pos);
  995. RecalcFrameLayout(pPane, TRUE);
  997. CWnd* pFrame = pPane->GetDockingSite();
  999. if (DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, pFrame))
  1000. {
  1001. ((CXTPDockingPaneMiniWnd*)pFrame)->OnThemedChanged();
  1002. }
  1004. if (pPane->GetContainer())
  1005. {
  1006. pPane->GetContainer()->InvalidatePane(FALSE);
  1007. }
  1008. }
  1009. }
  1011. void CXTPDockingPaneManager::SyncActiveFloatingFrames(BOOL bSyncActiveFloatingFrames)
  1012. {
  1013. if (m_bSyncActiveFloatingFrames == bSyncActiveFloatingFrames)
  1014. return;
  1016. m_bSyncActiveFloatingFrames = bSyncActiveFloatingFrames;
  1018. POSITION pos = GetPaneStack().GetHeadPosition();
  1019. while (pos)
  1020. {
  1021. CXTPDockingPaneBase* pPane = GetPaneStack().GetNext(pos);
  1022. if (pPane->GetType() == xtpPaneTypeMiniWnd)
  1023. {
  1024. CXTPDockingPaneMiniWnd* pFrame = (CXTPDockingPaneMiniWnd*)pPane;
  1025. if (pFrame->m_hWnd)
  1026. {
  1027. pFrame->ModifyStyle(bSyncActiveFloatingFrames ? 0: MFS_SYNCACTIVE, bSyncActiveFloatingFrames ? MFS_SYNCACTIVE : SWP_FRAMECHANGED);
  1028. }
  1029. }
  1030. }
  1031. }
  1034. void CXTPDockingPaneManager::SetTheme(XTPDockingPanePaintTheme paintTheme)
  1035. {
  1036. if (m_pPaintManager != NULL)
  1037. m_pPaintManager->InternalRelease();
  1039. if (paintTheme == xtpPaneThemeOffice) m_pPaintManager = new CXTPDockingPaneOfficeTheme();
  1040. else if (paintTheme == xtpPaneThemeGrippered) m_pPaintManager = new CXTPDockingPaneGripperedTheme();
  1041. else if (paintTheme == xtpPaneThemeVisio) m_pPaintManager = new CXTPDockingPaneVisioTheme();
  1042. else if (paintTheme == xtpPaneThemeOffice2003) m_pPaintManager = new CXTPDockingPaneOffice2003Theme();
  1043. else if (paintTheme == xtpPaneThemeNativeWinXP) m_pPaintManager = new CXTPDockingPaneNativeXPTheme();
  1044. else if (paintTheme == xtpPaneThemeWhidbey) m_pPaintManager = new CXTPDockingPaneWhidbeyTheme();
  1045. else if (paintTheme == xtpPaneThemeVisualStudio2005) m_pPaintManager = new CXTPDockingPaneVisualStudio2005Theme();
  1046. else if (paintTheme == xtpPaneThemeShortcutBar2003) m_pPaintManager = new CXTPDockingPaneShortcutBar2003Theme();
  1047. else if (paintTheme == xtpPaneThemeExplorer) m_pPaintManager = new CXTPDockingPaneExplorerTheme();
  1048. else if (paintTheme == xtpPaneThemeOffice2007) m_pPaintManager = new CXTPDockingPaneOffice2007Theme();
  1049. else if (paintTheme == xtpPaneThemeWord2007) m_pPaintManager = new CXTPDockingPaneWord2007Theme();
  1050. else m_pPaintManager = new CXTPDockingPaneDefaultTheme();
  1052. m_pPaintManager->m_themeCurrent = paintTheme;
  1053. m_pPaintManager->RefreshMetrics();
  1055. _Redraw();
  1057. if (paintTheme == xtpPaneThemeVisualStudio2005)
  1058. {
  1059. SetDockingContextStickerStyle(xtpPaneStickerStyleVisualStudio2005);
  1060. }
  1061. }
  1063. void CXTPDockingPaneManager::SetCustomTheme(CXTPDockingPanePaintManager* pTheme)
  1064. {
  1065. ASSERT(pTheme);
  1066. if (!pTheme)
  1067. return;
  1069. if (m_pPaintManager != NULL)
  1070. m_pPaintManager->InternalRelease();
  1072. m_pPaintManager = pTheme;
  1073. m_pPaintManager->m_themeCurrent = xtpPaneThemeCustom;
  1074. m_pPaintManager->RefreshMetrics();
  1076. _Redraw();
  1077. }
  1080. XTPDockingPanePaintTheme CXTPDockingPaneManager::GetCurrentTheme() const
  1081. {
  1082. return m_pPaintManager->m_themeCurrent;
  1083. }
  1085. CXTPDockingPaneLayout* CXTPDockingPaneManager::CreateLayout()
  1086. {
  1087. return new CXTPDockingPaneLayout(this);
  1088. }
  1091. void CXTPDockingPaneManager::GetLayout(CXTPDockingPaneLayout* pLayout) const
  1092. {
  1093. ASSERT(pLayout);
  1094. if (!pLayout)
  1095. return;
  1097. pLayout->Copy(m_pLayout);
  1098. }
  1100. void CXTPDockingPaneManager::_DetachAll()
  1101. {
  1102. POSITION pos = GetPaneList().GetHeadPosition();
  1103. while (pos)
  1104. {
  1105. CXTPDockingPane* pPane = GetPaneList().GetNext(pos);
  1106. pPane->Detach();
  1107. }
  1108. }
  1110. void CXTPDockingPaneManager::SetLayout(const CXTPDockingPaneLayout* pLayout)
  1111. {
  1112. ASSERT(pLayout);
  1114. if (!pLayout || !pLayout->IsValid())
  1115. return;
  1117. _DetachAll();
  1119. m_pLayout->Copy(pLayout);
  1120. _Redraw();
  1121. }
  1123. void CXTPDockingPaneManager::DestroyAll()
  1124. {
  1125. if (m_pLayout)
  1126. {
  1127. m_pLayout->InternalRelease();
  1128. m_pLayout = CreateLayout();
  1129. m_pLayout->m_bUserLayout = FALSE;
  1130. }
  1131. }
  1132. void CXTPDockingPaneManager::CloseAll()
  1133. {
  1134. CXTPDockingPaneInfoList& paneList = GetPaneList();
  1135. POSITION pos = paneList.GetHeadPosition();
  1136. while (pos)
  1137. {
  1138. CXTPDockingPane* pPane = paneList.GetNext(pos);
  1139. pPane->Close();
  1140. }
  1141. }
  1144. CXTPDockingPaneBaseList& CXTPDockingPaneManager::GetPaneStack() const
  1145. {
  1146. return m_pLayout->m_lstStack;
  1147. }
  1149. CXTPDockingPaneInfoList& CXTPDockingPaneManager::GetPaneList() const
  1150. {
  1151. return m_pLayout->m_lstPanes;
  1152. }
  1154. CXTPDockingPaneBase* CXTPDockingPaneManager::GetClientPane() const
  1155. {
  1156. return m_pLayout ? m_pLayout->m_pClient : NULL;
  1157. }
  1159. CXTPDockingPaneBase* CXTPDockingPaneManager::GetTopPane() const
  1160. {
  1161. return m_pLayout ? (CXTPDockingPaneBase*)m_pLayout->m_pTopContainer : NULL;
  1162. }
  1164. void CXTPDockingPaneManager::SetIcon(UINT nID, CXTPImageManagerIconHandle hIcon)
  1165. {
  1166. m_pImageManager->SetIcon(hIcon, nID, 0, xtpImageNormal);
  1167. }
  1169. CXTPImageManagerIcon* CXTPDockingPaneManager::GetIcon(UINT nID, int nWidth) const
  1170. {
  1171. return m_pImageManager->GetImage(nID, nWidth);
  1172. }
  1174. void CXTPDockingPaneManager::ClearIconMap()
  1175. {
  1176. m_pImageManager->RemoveAll();
  1177. }
  1179. void CXTPDockingPaneManager::SetThemedFloatingFrames(BOOL bThemedFloatingFrames)
  1180. {
  1181. m_bThemedFloatingFrames = bThemedFloatingFrames;
  1183. if (!m_pLayout)
  1184. return;
  1186. POSITION pos = GetPaneList().GetHeadPosition();
  1187. while (pos)
  1188. {
  1189. CXTPDockingPane* pPane = GetPaneList().GetNext(pos);
  1190. CWnd* pFrame = pPane->GetDockingSite();
  1192. if (DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, pFrame))
  1193. {
  1194. ((CXTPDockingPaneMiniWnd*)pFrame)->OnThemedChanged();
  1195. }
  1196. }
  1198. }
  1202. void CXTPDockingPaneManager::SetAnimationDelay(double dAnimationDelay /*= -1*/, int nAnimationDuration /*= 128*/, int nAnimationInterval /*= 16*/)
  1203. {
  1204. CXTPDockingPaneAutoHideWnd::m_dAnimationDelay = dAnimationDelay;
  1205. CXTPDockingPaneAutoHideWnd::m_nAnimationDuration = nAnimationDuration;
  1206. CXTPDockingPaneAutoHideWnd::m_nAnimationInterval = nAnimationInterval;
  1207. }
  1208. double CXTPDockingPaneManager::GetAnimationDelay(int* pAnimationDuration /*= NULL*/, int* pAnimationInterval /*= NULL*/) const
  1209. {
  1210. if (pAnimationDuration) *pAnimationDuration = CXTPDockingPaneAutoHideWnd::m_nAnimationDuration;
  1211. if (pAnimationInterval) *pAnimationInterval = CXTPDockingPaneAutoHideWnd::m_nAnimationInterval;
  1213. return CXTPDockingPaneAutoHideWnd::m_dAnimationDelay;
  1214. }
  1216. BOOL CXTPDockingPaneManager::IsLayoutRTL() const
  1217. {
  1218. return (GetSite()->GetExStyle() & WS_EX_LAYOUTRTL) != 0;
  1219. }
  1221. XTPDockingPaneDirection CXTPDockingPaneManager::GetRTLDirection(XTPDockingPaneDirection direction) const
  1222. {
  1223. if (IsLayoutRTL())
  1224. {
  1225. if (direction == xtpPaneDockLeft) direction = xtpPaneDockRight;
  1226. else if (direction == xtpPaneDockRight) direction = xtpPaneDockLeft;
  1227. }
  1228. return direction;
  1229. }
  1231. XTPDockingPaneDirection CXTPDockingPaneManager::GetPaneDirection(const CXTPDockingPaneBase* pPane) const
  1232. {
  1233. ASSERT(m_pLayout);
  1234. if (!m_pLayout)
  1235. return xtpPaneDockTop;
  1237. return m_pLayout->_GetPaneDirection(pPane);
  1238. }
  1240. void CXTPDockingPaneManager::SetDockingContext(CXTPDockingPaneContext* pDockingContext)
  1241. {
  1242. delete m_pDockingContext;
  1243. m_pDockingContext = pDockingContext;
  1244. m_pDockingContext->m_pManager = this;
  1245. }
  1249. void CXTPDockingPaneManager::NormalizeSplitters()
  1250. {
  1251. CXTPDockingPaneBaseList& lst = GetPaneStack();
  1252. POSITION pos = lst.GetHeadPosition();
  1254. while (pos)
  1255. {
  1256. CXTPDockingPaneBase* pPane = lst.GetNext(pos);
  1258. if (pPane->GetType() == xtpPaneTypeSplitterContainer)
  1259. {
  1260. ((CXTPDockingPaneSplitterContainer*)pPane)->NormalizeDockingSize();
  1261. }
  1262. }
  1263. }
  1265. void CXTPDockingPaneManager::RecalcFramesLayout()
  1266. {
  1267. CXTPDockingPaneBaseList& lst = GetPaneStack();
  1268. POSITION pos = lst.GetHeadPosition();
  1270. while (pos)
  1271. {
  1272. CXTPDockingPaneBase* pPane = lst.GetNext(pos);
  1274. if (pPane->GetType() == xtpPaneTypeMiniWnd)
  1275. {
  1276. CXTPDockingPaneMiniWnd* pMiniWnd = (CXTPDockingPaneMiniWnd*)pPane;
  1278. if (pMiniWnd->m_hWnd && pMiniWnd->GetStyle() & WS_VISIBLE)
  1279. {
  1280. pMiniWnd->RecalcLayout(TRUE);
  1281. pMiniWnd->MoveWindow(CXTPWindowRect(pMiniWnd));
  1282. }
  1283. }
  1284. }
  1285. RecalcFrameLayout(NULL);
  1286. }
  1288. void CXTPDockingPaneManager::EnsureVisible(CXTPDockingPaneBase* pPane)
  1289. {
  1290. if (!pPane)
  1291. return;
  1293. if (pPane->GetType() == xtpPaneTypeDockingPane)
  1294. {
  1295. ShowPane((CXTPDockingPane*)pPane, FALSE);
  1296. pPane = pPane->GetContainer();
  1297. }
  1299. if (pPane->GetType() == xtpPaneTypeTabbedContainer)
  1300. {
  1301. ((CXTPDockingPaneTabbedContainer*)pPane)->Show(FALSE);
  1302. }
  1304. CWnd* pSite = pPane->GetDockingSite();
  1305. if (DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, pSite))
  1306. {
  1307. pSite->BringWindowToTop();
  1308. }
  1309. }
  1311. void CXTPDockingPaneManager::OnSetPreviewMode(BOOL bPreview)
  1312. {
  1314. // Toggle Docking Panes.
  1315. if (bPreview)
  1316. {
  1317. ASSERT(m_pPreviewLayout == NULL);
  1318. m_pPreviewLayout = CreateLayout();
  1319. GetLayout(m_pPreviewLayout);
  1320. CloseAll();
  1321. }
  1322. else
  1323. {
  1324. ASSERT(m_pPreviewLayout != NULL);
  1325. SetLayout(m_pPreviewLayout);
  1327. CMDTARGET_RELEASE(m_pPreviewLayout);
  1328. }
  1329. }
  1331. void CXTPDockingPaneManager::OnActivatePane(BOOL bActive, CXTPDockingPane* pPane)
  1332. {
  1333. if (bActive && m_pActivePane != pPane)
  1334. {
  1335. if (m_pActivePane)
  1336. {
  1337. NotifyAction(xtpPaneActionDeactivated, m_pActivePane);
  1338. m_pActivePane->InternalRelease();
  1339. }
  1341. m_pActivePane = pPane;
  1343. if (m_pActivePane)
  1344. {
  1345. m_pActivePane->InternalAddRef();
  1346. NotifyAction(xtpPaneActionActivated, m_pActivePane);
  1347. }
  1348. }
  1349. else if (!bActive && pPane && m_pActivePane == pPane)
  1350. {
  1351. m_pActivePane = 0;
  1352. NotifyAction(xtpPaneActionDeactivated, pPane);
  1354. pPane->InternalRelease();
  1355. }
  1356. }
  1358. BOOL CXTPDockingPaneManager::DoPropExchange(CXTPPropExchange* pPX)
  1359. {
  1360. if (pPX->IsStoring())
  1361. {
  1362. CXTPDockingPaneLayout layoutNormal(this);
  1363. GetLayout(&layoutNormal);
  1364. layoutNormal.DoPropExchange(pPX);
  1365. }
  1366. else
  1367. {
  1368. CXTPDockingPaneLayout layoutNormal(this);
  1369. if (!layoutNormal.DoPropExchange(pPX))
  1370. return FALSE;
  1371. SetLayout(&layoutNormal);
  1372. }
  1373. return TRUE;
  1374. }
  1376. void CXTPDockingPaneManager::RecalcFrameLayout(CXTPDockingPaneBase* pPane, BOOL bDelay)
  1377. {
  1378. CWnd* pSite = pPane ? pPane->GetDockingSite() : GetSite();
  1379. if (!pSite || !IsWindow(pSite->GetSafeHwnd()))
  1380. return;
  1382. CFrameWnd* pFrame = pSite->IsFrameWnd() ? (CFrameWnd*)pSite : NULL;
  1384. if (pFrame)
  1385. {
  1386. if (bDelay)
  1387. {
  1388. pFrame->DelayRecalcLayout(FALSE);
  1389. pFrame->PostMessage(WM_IDLEUPDATECMDUI);
  1390. }
  1391. else
  1392. pFrame->RecalcLayout(FALSE);
  1393. }
  1394. else
  1395. {
  1396. CXTPClientRect rc(pSite);
  1397. if (bDelay)
  1398. {
  1399. MSG msg;
  1400. if (PeekMessage(&msg, pSite->GetSafeHwnd(), WM_SIZE, WM_SIZE, PM_NOREMOVE))
  1401. return;
  1403. pSite->PostMessage(WM_SIZE, 0, MAKELPARAM(rc.Width(), rc.Height()));
  1404. }
  1405. else
  1406. pSite->SendMessage(WM_SIZE, 0, MAKELPARAM(rc.Width(), rc.Height()));
  1407. }
  1408. }
  1410. void CXTPDockingPaneManager::_TrackPopupContextMenu(CXTPDockingPane* pPane)
  1411. {
  1412. CPoint pt(0, 0);
  1413. CXTPDockingPaneBase* pContainer = pPane->GetContainer();
  1415. if (pPane->IsFloating())
  1416. {
  1417. pPane->GetDockingSite()->ClientToScreen(&pt);
  1418. pContainer = ((CXTPDockingPaneMiniWnd*)pPane->GetDockingSite())->GetTopPane();
  1419. }
  1420. else
  1421. {
  1422. CRect rc = pContainer->GetPaneWindowRect();
  1423. GetPaintManager()->AdjustCaptionRect((CXTPDockingPaneTabbedContainer*)pContainer, rc);
  1424. pt = rc.TopLeft();
  1425. }
  1427. CMenu menu;
  1428. menu.CreatePopupMenu();
  1429. menu.InsertMenu(0, MF_BYPOSITION | MF_STRING, SC_MOVE, m_strMove);
  1431. BOOL nCommand = TrackPopupMenu(menu, TPM_RETURNCMD, pt.x, pt.y, 0, GetSite()->GetSafeHwnd(), NULL);
  1433. if (nCommand == SC_MOVE)
  1434. {
  1435. CXTPDockingPaneContext* pContext = GetDockingContext();
  1436. pContext->Drag(pContainer, CPoint(-1, -1));
  1437. }
  1438. }
  1440. BOOL CXTPDockingPaneManager::ActivateNextPane(CXTPDockingPane* pPaneActive, BOOL bForward)
  1441. {
  1442. if (!m_pLayout)
  1443. return FALSE;
  1445. CXTPDockingPaneInfoList& paneList = m_pLayout->GetPaneList();
  1446. if (paneList.IsEmpty())
  1447. return FALSE;
  1449. BOOL bActive = (pPaneActive != NULL);
  1451. POSITION posFirst = bForward ? paneList.GetHeadPosition() : paneList.GetTailPosition();
  1452. POSITION pos = posFirst;
  1454. while (pos)
  1455. {
  1456. CXTPDockingPane* pPane = bForward ? paneList.GetNext(pos) : paneList.GetPrev(pos);
  1458. if (pos == NULL && bActive)
  1459. {
  1460. pos = posFirst;
  1461. bActive = FALSE;
  1462. }
  1464. if (!pPaneActive)
  1465. {
  1466. if ((pPane->GetEnabled() & xtpPaneEnableClient) == 0)
  1467. continue;
  1469. ShowPane(pPane);
  1470. return TRUE;
  1471. }
  1472. else if (pPane == pPaneActive)
  1473. {
  1474. pPaneActive = NULL;
  1475. }
  1476. }
  1477. return FALSE;
  1478. }
  1480. BOOL CXTPDockingPaneManager::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1481. {
  1482. if (message == WM_DESTROY && m_bKeyboardEnabled)
  1483. {
  1484. m_bKeyboardEnabled = FALSE;
  1485. CXTPDockingPaneKeyboardHook::GetThreadState()->SetupKeyboardHook(this, FALSE);
  1486. }
  1488. if (message == WM_SYSCOMMAND && wParam == SC_KEYMENU && LOWORD(lParam) == TEXT('-'))
  1489. {
  1490. CXTPDockingPane* pPane = GetActivePane();
  1491. if (pPane && !pPane->IsClosed() && !pPane->IsHidden())
  1492. {
  1493. _TrackPopupContextMenu(pPane);
  1494. return TRUE;
  1495. }
  1496. }
  1498. if (message == WM_SYSCOMMAND && (wParam == SC_NEXTWINDOW || wParam == SC_PREVWINDOW))
  1499. {
  1500. return ActivateNextPane(GetActivePane(), wParam == SC_NEXTWINDOW);
  1501. }
  1503. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  1504. }
  1507. //////////////////////////////////////////////////////////////////////////
  1508. // Accessible
  1510. CCmdTarget* CXTPDockingPaneManager::GetAccessible()
  1511. {
  1512. return this;
  1513. }
  1515. HRESULT CXTPDockingPaneManager::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  1516. {
  1517. if (GetSafeHwnd())
  1518. {
  1519. return AccessibleObjectFromWindow(GetSafeHwnd(), OBJID_WINDOW, IID_IDispatch, (void**)ppdispParent);
  1520. }
  1521. return E_FAIL;
  1522. }
  1524. HRESULT CXTPDockingPaneManager::GetAccessibleChildCount(long FAR* pChildCount)
  1525. {
  1526. if (pChildCount == 0)
  1527. return E_INVALIDARG;
  1529. *pChildCount = (long)m_pLayout->GetPaneList().GetCount();
  1531. return S_OK;
  1532. }
  1534. HRESULT CXTPDockingPaneManager::GetAccessibleChild(VARIANT varChild, IDispatch* FAR* ppdispChild)
  1535. {
  1536. *ppdispChild = NULL;
  1537. int nChild = GetChildIndex(&varChild);
  1539. if (nChild > 0 && nChild <= m_pLayout->GetPaneList().GetCount())
  1540. {
  1541. CXTPDockingPane* pPane = m_pLayout->GetPaneList().GetAt(m_pLayout->GetPaneList().FindIndex(nChild - 1));
  1542. if (pPane)
  1543. {
  1544. *ppdispChild = pPane->GetIDispatch(TRUE);
  1545. }
  1546. }
  1548. return S_OK;
  1549. }
  1551. HRESULT CXTPDockingPaneManager::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  1552. {
  1553. int nChild = GetChildIndex(&varChild);
  1555. if (nChild == CHILDID_SELF || nChild == -1)
  1556. {
  1557. *pszName = SysAllocString(L"XTPDockingPaneManager");
  1558. return S_OK;
  1559. }
  1561. return E_INVALIDARG;
  1562. }
  1564. HRESULT CXTPDockingPaneManager::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  1565. {
  1566. pvarRole->vt = VT_EMPTY;
  1567. int nChild = GetChildIndex(&varChild);
  1569. if (nChild == CHILDID_SELF)
  1570. {
  1571. pvarRole->vt = VT_I4;
  1572. pvarRole->lVal = ROLE_SYSTEM_PROPERTYPAGE;
  1573. return S_OK;
  1574. }
  1576. return E_INVALIDARG;
  1577. }
  1579. HRESULT CXTPDockingPaneManager::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  1580. {
  1581. int nChild = GetChildIndex(&varChild);
  1583. if (nChild == CHILDID_SELF || nChild == -1)
  1584. {
  1585. pvarState->vt = VT_I4;
  1586. pvarState->lVal = 0;
  1587. return S_OK;
  1588. }
  1590. return E_INVALIDARG;
  1592. }
  1595. HRESULT CXTPDockingPaneManager::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT /*varChild*/)
  1596. {
  1597. *pxLeft = *pyTop = 0;
  1598. *pcxWidth = *pcyHeight = 10;
  1600. return S_OK;
  1601. }
  1603. HRESULT CXTPDockingPaneManager::AccessibleHitTest(long /*xLeft*/, long /*yTop*/, VARIANT* /*pvarID*/)
  1604. {
  1605. return S_FALSE;
  1606. }
  1609. LRESULT CXTPDockingPaneManager::OnGetObject(WPARAM wParam, LPARAM lParam)
  1610. {
  1611. if (lParam != OBJID_CLIENT)
  1612. return (LRESULT)Default();
  1614. LPUNKNOWN lpUnknown = GetInterface(&IID_IAccessible);
  1615. if (!lpUnknown)
  1616. return E_FAIL;
  1618. return LresultFromObject(IID_IAccessible, wParam, lpUnknown);
  1619. }
  1621. BEGIN_INTERFACE_MAP(CXTPDockingPaneManager, CCmdTarget)
  1622. INTERFACE_PART(CXTPDockingPaneManager, IID_IAccessible, ExternalAccessible)
  1623. END_INTERFACE_MAP()