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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneLayout.cpp：源码内容
  1. // XTPDockingPaneLayout.cpp : implementation of the CXTPDockingPaneLayout 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/XTPVC80Helpers.h"
  23. #include "TabManager/XTPTabManager.h"
  24. #include "Common/XTPPropExchange.h"
  26. #include "XTPDockingPaneLayout.h"
  27. #include "XTPDockingPaneBase.h"
  28. #include "XTPDockingPaneSplitterContainer.h"
  29. #include "XTPDockingPaneTabbedContainer.h"
  30. #include "XTPDockingPane.h"
  31. #include "XTPDockingPaneMiniWnd.h"
  32. #include "XTPDockingPaneManager.h"
  33. #include "XTPDockingPaneAutoHidePanel.h"
  34. #include "XTPDockingPaneSidePanel.h"
  36. #ifdef _DEBUG
  37. #define new DEBUG_NEW
  38. #undef THIS_FILE
  39. static char THIS_FILE[] = __FILE__;
  40. #endif
  42. AFX_STATIC_DATA const TCHAR _xtRootSection[] = _T("DockingPaneLayouts");
  43. AFX_STATIC_DATA const TCHAR _xtPaneSection[] = _T("Pane-%d");
  44. AFX_STATIC_DATA const TCHAR _xtPanes[] = _T("Panes");
  45. AFX_STATIC_DATA const TCHAR _xtSummary[] = _T("Summary");
  47. CXTPDockingPaneLayout::CXTPDockingPaneLayout(CXTPDockingPaneManager* pManager)
  48. : m_pManager(pManager)
  49. {
  50. m_bUserLayout = TRUE;
  52. memset(m_wndPanels, 0, sizeof(m_wndPanels));
  53. memset(m_wndMargins, 0, sizeof(m_wndMargins));
  55. m_pClient = m_pManager->OnCreatePane(xtpPaneTypeClient, this);
  56. m_pTopContainer = (CXTPDockingPaneSplitterContainer*)m_pManager->OnCreatePane(xtpPaneTypeSplitterContainer, this);
  57. m_pTopContainer->Init(m_pClient, TRUE, m_pManager->GetSite());
  59. }
  61. CXTPDockingPaneLayout::~CXTPDockingPaneLayout()
  62. {
  63. Free();
  64. }
  66. BOOL CXTPDockingPaneLayout::IsValid() const
  67. {
  68. return (m_pTopContainer != NULL) && (m_pClient != NULL)
  69. && (m_pClient->GetType() == xtpPaneTypeClient) && (m_pManager != NULL);
  70. }
  72. void CXTPDockingPaneLayout::Free()
  73. {
  74. m_pTopContainer = 0;
  75. m_pClient = 0;
  77. while (!m_lstStack.IsEmpty())
  78. {
  79. CXTPDockingPaneBase* pPane = m_lstStack.RemoveTail();
  80. pPane->DeletePane();
  81. }
  83. m_lstPanes.RemoveAll();
  85. memset(m_wndPanels, 0, sizeof(m_wndPanels));
  87. for (int i = 0; i < 4; i++)
  88. {
  89. SAFE_DELETE(m_wndMargins[i]);
  90. }
  91. }
  93. BOOL CXTPDockingPaneLayout::_Load(CXTPPropExchange* pPX)
  94. {
  95. if (!pPX->OnBeforeExchange())
  96. return FALSE;
  98. ASSERT(pPX->IsLoading());
  100. Free();
  102. CXTPPropExchangeSection secSummary(pPX->GetSection(_xtSummary));
  104. int nCount = 0;
  105. PX_Int(&secSummary, _xtPanes, nCount);
  107. if (nCount < 2)
  108. return FALSE;
  110. pPX->ExchangeSchema();
  113. TCHAR szSection[256];
  114. CXTPPaneIndexToPaneMap map;
  116. for (int i = 1; i <= nCount; i++)
  117. {
  118. wsprintf(szSection, _xtPaneSection, i);
  120. CXTPPropExchangeSection secPane(pPX->GetSection(szSection));
  122. int nType = -1;
  123. PX_Int(&secPane, _T("Type"), nType, -1);
  125. CXTPDockingPaneBase* pPane = m_pManager->OnCreatePane((XTPDockingPaneType)nType, this);
  127. if (!pPane)
  128. {
  129. return FALSE;
  130. }
  131. pPane->m_nIndex = i;
  132. map.SetAt(i, pPane);
  133. }
  135. ASSERT(map.GetCount() == m_lstStack.GetCount());
  137. POSITION pos = m_lstStack.GetHeadPosition();
  138. while (pos)
  139. {
  140. CXTPDockingPaneBase* pPane = m_lstStack.GetNext(pos);
  142. wsprintf(szSection, _xtPaneSection, pPane->m_nIndex);
  144. CXTPPropExchangeSection secPane(pPX->GetSection(szSection));
  145. secPane->m_dwData = (DWORD_PTR)&map;
  147. if (!pPane->DoPropExchange(&secPane))
  148. {
  149. return FALSE;
  150. }
  151. }
  153. int nIndex = 0;
  154. if (!PX_Int(&secSummary, _T("TopContainer"), nIndex))
  155. return FALSE;
  157. m_pTopContainer = (CXTPDockingPaneSplitterContainer*)map[nIndex];
  158. if (!m_pTopContainer)
  159. return FALSE;
  161. if (!PX_Int(&secSummary, _T("Client"), nIndex))
  162. return FALSE;
  164. m_pClient = (CXTPDockingPaneBase*)map[nIndex];
  165. if (!m_pClient || m_pClient->GetType() != xtpPaneTypeClient)
  166. return FALSE;
  168. return TRUE;
  170. }
  172. // The main difference between the .Net versions and the normal versions of _Save is that in the .Net
  173. // versions all the save is done is done in the exact same order of the load.
  175. void CXTPDockingPaneLayout::_Save(CXTPPropExchange* pPX)
  176. {
  177. ASSERT(!pPX->IsLoading());
  179. pPX->EmptySection();
  181. _FreeEmptyPanes();
  183. CXTPPropExchangeSection secSummary(pPX->GetSection(_xtSummary));
  185. int nCount = (int)m_lstStack.GetCount();
  186. PX_Int(&secSummary, _xtPanes, nCount);
  188. pPX->ExchangeSchema();
  191. TCHAR szSection[256];
  193. // Assign an unique value to each pane
  194. int nIndex = 1;  // important
  196. POSITION pos = m_lstPanes.GetHeadPosition();
  197. while (pos)
  198. {
  199. CXTPDockingPane* pPane = m_lstPanes.GetNext(pos);
  200. pPane->m_nIndex = nIndex++;
  202. wsprintf(szSection, _xtPaneSection, pPane->m_nIndex);
  204. CXTPPropExchangeSection secPane(pPX->GetSection(szSection));
  205. int nType = pPane->m_type;
  206. PX_Int(&secPane, _T("Type"), nType);
  207. }
  209. pos = m_lstStack.GetHeadPosition();
  210. while (pos)
  211. {
  212. CXTPDockingPaneBase* pPane = m_lstStack.GetNext(pos);
  213. if (pPane->GetType() == xtpPaneTypeDockingPane) continue;
  214. pPane->m_nIndex = nIndex++;
  216. wsprintf(szSection, _xtPaneSection, pPane->m_nIndex);
  218. CXTPPropExchangeSection secPane(pPX->GetSection(szSection));
  219. int nType = pPane->m_type;
  220. PX_Int(&secPane, _T("Type"), nType);
  221. }
  223. pos = m_lstPanes.GetHeadPosition();
  224. while (pos)
  225. {
  226. CXTPDockingPane* pPane = m_lstPanes.GetNext(pos);
  227. wsprintf(szSection, _xtPaneSection, pPane->m_nIndex);
  229. CXTPPropExchangeSection secPane(pPX->GetSection(szSection));
  230. pPane->DoPropExchange(&secPane);
  231. }
  233. // Save all panes
  234. pos = m_lstStack.GetHeadPosition();
  235. while (pos)
  236. {
  237. CXTPDockingPaneBase* pPane = m_lstStack.GetNext(pos);
  238. if (pPane->GetType() == xtpPaneTypeDockingPane) continue;
  239. wsprintf(szSection, _xtPaneSection, pPane->m_nIndex);
  241. CXTPPropExchangeSection secPane(pPX->GetSection(szSection));
  242. pPane->DoPropExchange(&secPane);
  243. }
  245. PX_Int(&secSummary, _T("TopContainer"), m_pTopContainer->m_nIndex);
  246. PX_Int(&secSummary, _T("Client"), m_pClient->m_nIndex);
  248. }
  251. BOOL CXTPDockingPaneLayout::DoPropExchange(CXTPPropExchange* pPX)
  252. {
  253. if (pPX->IsLoading())
  254. return _Load(pPX);
  256. _Save(pPX);
  257. return TRUE;
  258. }
  260. BOOL CXTPDockingPaneLayout::Load(LPCTSTR strSection)
  261. {
  262. CXTPPropExchangeSection pxRoot(TRUE, _xtRootSection);
  263. CXTPPropExchangeSection pxSection(pxRoot->GetSection(strSection));
  265. return DoPropExchange(&pxSection);
  266. }
  268. void CXTPDockingPaneLayout::Save(LPCTSTR strSection)
  269. {
  270. CXTPPropExchangeSection pxRoot(FALSE, _xtRootSection);
  271. CXTPPropExchangeSection pxSection(pxRoot->GetSection(strSection));
  273. DoPropExchange(&pxSection);
  274. }
  276. void CXTPDockingPaneLayout::Serialize(CArchive& ar)
  277. {
  278. CXTPPropExchangeArchive px(ar);
  279. DoPropExchange(&px);
  280. }
  283. #ifndef _XTP_EXCLUDE_XML
  285. BOOL CXTPDockingPaneLayout::LoadFromNode(CXTPDOMNodePtr xmlNode, LPCTSTR strSection)
  286. {
  287. if (xmlNode == 0)
  288. return FALSE;
  290. CXTPPropExchangeXMLNode px(TRUE, xmlNode, strSection);
  291. return DoPropExchange(&px);
  292. }
  294. BOOL CXTPDockingPaneLayout::LoadFromFile(LPCTSTR strFileName, LPCTSTR strSection)
  295. {
  296. CXTPPropExchangeXMLNode px(TRUE, 0, _xtRootSection);
  297. if (!px.LoadFromFile(strFileName))
  298. return FALSE;
  300. CXTPPropExchangeSection pxSection(px.GetSection(strSection));
  301. if (!pxSection->OnBeforeExchange())
  302. return FALSE;
  304. return DoPropExchange(&pxSection);
  305. }
  307. void CXTPDockingPaneLayout::SaveToNode (CXTPDOMNodePtr xmlNode, LPCTSTR strSection)
  308. {
  309. if (xmlNode == 0)
  310. return;
  312. CXTPPropExchangeXMLNode px(FALSE, xmlNode, strSection);
  313. DoPropExchange(&px);
  314. }
  316. void CXTPDockingPaneLayout::SaveToFile (LPCTSTR strFileName, LPCTSTR strSection)
  317. {
  318. CXTPPropExchangeXMLNode px(FALSE, 0, _xtRootSection);
  320. CXTPPropExchangeSection pxSection(px.GetSection(strSection));
  321. DoPropExchange(&pxSection);
  323. px.SaveToFile(strFileName);
  324. }
  326. #endif
  330. BOOL CXTPDockingPaneBase::DoPropExchange(CXTPPropExchange* pPX)
  331. {
  332. PX_Long(pPX, _T("DockingCX"), m_szDocking.cx, 0);
  333. PX_Long(pPX, _T("DockingCY"), m_szDocking.cy, 0);
  335. return TRUE;
  336. }
  338. BOOL CXTPDockingPane::DoPropExchange(CXTPPropExchange* pPX)
  339. {
  340. CXTPDockingPaneBase::DoPropExchange(pPX);
  342. PX_String(pPX, _T("Title"), m_strTitle);
  343. PX_Int(pPX, _T("ID"), m_nID, 0);
  345. PX_Int(pPX, _T("IconID"), m_nIconID, -1);
  346. PX_ULong(pPX, _T("Options"), m_dwOptions, 0);
  348. int nIndex = 0;
  349. CXTPPaneIndexToPaneMap* pMap = (CXTPPaneIndexToPaneMap*)pPX->m_dwData;
  351. if (!pPX->IsLoading())
  352. {
  353. XTP_DOCKINGPANE_INFO* pInfo = m_pLayout->FindPane(this);
  354. ASSERT(pInfo);
  355. if (pInfo)
  356. {
  358. nIndex = pInfo->pDockingHolder ? pInfo->pDockingHolder->m_nIndex : 0;
  359. PX_Int(pPX, _T("DockingHolder"), nIndex, 0);
  360. nIndex = pInfo->pFloatingHolder ? pInfo->pFloatingHolder->m_nIndex : 0;
  361. PX_Int(pPX, _T("FloatingHolder"), nIndex, 0);
  362. nIndex = pInfo->pLastHolder ? pInfo->pLastHolder->m_nIndex : 0;
  363. PX_Int(pPX, _T("LastHolder"), nIndex, 0);
  364. }
  365. }
  366. else
  367. {
  368. XTP_DOCKINGPANE_INFO info (this);
  370. PX_Int(pPX, _T("DockingHolder"), nIndex, 0);
  371. if (nIndex) info.pDockingHolder = (CXTPDockingPaneBase*)(*pMap)[nIndex];
  372. PX_Int(pPX, _T("FloatingHolder"), nIndex, 0);
  373. if (nIndex) info.pFloatingHolder = (CXTPDockingPaneBase*)(*pMap)[nIndex];
  374. PX_Int(pPX, _T("LastHolder"), nIndex, 0);
  375. if (nIndex) info.pLastHolder = (CXTPDockingPaneBase*)(*pMap)[nIndex];
  376. m_pLayout->m_lstPanes.AddTail(info);
  378. }
  380. PX_Long(pPX, _T("MinTrackX"), m_ptMinTrackSize.x, 0);
  381. PX_Long(pPX, _T("MinTrackY"), m_ptMinTrackSize.y, 0);
  382. PX_Long(pPX, _T("MaxTrackX"), m_ptMaxTrackSize.x, 32000);
  383. PX_Long(pPX, _T("MaxTrackY"), m_ptMaxTrackSize.y, 32000);
  385. if (pPX->GetSchema() > _XTP_SCHEMA_97)
  386. {
  387. PX_DWord(pPX, _T("TabColor"), (DWORD&)m_clrItemTab, COLORREF_NULL);
  388. PX_Int(pPX, _T("HelpId"), m_nIDHelp, 0);
  390. DWORD dwData = (DWORD)m_dwData;
  391. PX_DWord(pPX, _T("Tag"), dwData, 0);
  392. if (pPX->IsLoading()) m_dwData = dwData;
  393. }
  395. return m_nID > 0;
  396. }
  398. BOOL CXTPDockingPaneSplitterContainer::DoPropExchange(CXTPPropExchange* pPX)
  399. {
  400. CXTPDockingPaneBase::DoPropExchange(pPX);
  402. PX_Bool(pPX, _T("Horiz"), m_bHoriz, FALSE);
  404. int nCount = 0;
  406. if (!pPX->IsLoading())
  407. {
  408. nCount = (int)m_lstPanes.GetCount();
  409. PX_Int(pPX, _xtPanes, nCount);
  411. int nIndex = 1;
  412. TCHAR szPane[256];
  413. POSITION pos = m_lstPanes.GetHeadPosition();
  414. while (pos)
  415. {
  416. CXTPDockingPaneBase* pPane = m_lstPanes.GetNext(pos);
  417. wsprintf(szPane, _xtPaneSection, nIndex++);
  419. PX_Int(pPX, szPane, pPane->m_nIndex);
  420. }
  421. }
  422. else
  423. {
  424. PX_Int(pPX, _xtPanes, nCount, 0);
  426. int nIndex = 0;
  427. TCHAR szPane[256];
  428. CXTPPaneIndexToPaneMap* pMap = (CXTPPaneIndexToPaneMap*)pPX->m_dwData;
  430. for (int i = 1; i <= nCount; i++)
  431. {
  432. wsprintf(szPane, _xtPaneSection, i);
  433. PX_Int(pPX, szPane, nIndex, 0);
  434. ASSERT(nIndex > 0);
  436. CXTPDockingPaneBase* pPane = NULL;
  437. ASSERT(pMap->Lookup(nIndex, pPane));
  439. pPane = (CXTPDockingPaneBase*)((*pMap)[nIndex]);
  440. if (!pPane) return FALSE;
  442. _InsertPane(pPane);
  443. }
  445. ASSERT(nCount > 0);
  447. }
  448. return TRUE;
  449. }
  451. BOOL CXTPDockingPaneSidePanel::DoPropExchange(CXTPPropExchange* pPX)
  452. {
  453. CXTPDockingPaneBase::DoPropExchange(pPX);
  454. int direction = m_direction;
  456. PX_Int(pPX, _T("Direction"), direction);
  457. PX_Rect(pPX, _T("WindowRect"), m_rcWindow, CRect(0, 0, 0, 0));
  458. PX_Bool(pPX, _T("Collapsed"), m_bCollapsed, FALSE);
  460. if (!pPX->IsLoading())
  461. {
  462. int nTopContainer = GetTopContainer() ? GetTopContainer()->m_nIndex : 0;
  463. PX_Int(pPX, _T("TopContaner"), nTopContainer);
  464. }
  465. else
  466. {
  467. m_direction = (XTPDockingPaneDirection)direction;
  469. int nTopContainer = 0;
  470. PX_Int(pPX, _T("TopContaner"), nTopContainer);
  472. if (nTopContainer == 0)
  473. return FALSE;
  475. CXTPPaneIndexToPaneMap* pMap = (CXTPPaneIndexToPaneMap*)pPX->m_dwData;
  477. CXTPDockingPaneBase* pTop = (CXTPDockingPaneBase*)(*pMap)[nTopContainer];
  478. if (!pTop || pTop->GetType() != xtpPaneTypeTabbedContainer)
  479. return FALSE;
  481. _InsertPane(pTop);
  483. }
  485. return TRUE;
  486. }
  488. BOOL CXTPDockingPaneAutoHidePanel::DoPropExchange(CXTPPropExchange* pPX)
  489. {
  490. CXTPDockingPaneBase::DoPropExchange(pPX);
  492. int direction = m_direction;
  493. PX_Int(pPX, _T("Direction"), direction);
  495. int nCount = 0;
  497. if (!pPX->IsLoading())
  498. {
  499. nCount = (int)m_lstPanes.GetCount();
  500. PX_Int(pPX, _xtPanes, nCount);
  502. int nIndex = 1;
  503. TCHAR szPane[256];
  504. POSITION pos = m_lstPanes.GetHeadPosition();
  505. while (pos)
  506. {
  507. CXTPDockingPaneBase* pPane = m_lstPanes.GetNext(pos);
  508. wsprintf(szPane, _xtPaneSection, nIndex++);
  509. PX_Int(pPX, szPane, pPane->m_nIndex);
  510. }
  511. }
  512. else
  513. {
  514. m_direction = (XTPDockingPaneDirection)direction;
  516. PX_Int(pPX, _xtPanes, nCount, 0);
  518. int nIndex = 0;
  519. TCHAR szPane[256];
  520. CXTPPaneIndexToPaneMap* pMap = (CXTPPaneIndexToPaneMap*)pPX->m_dwData;
  522. for (int i = 1; i <= nCount; i++)
  523. {
  524. wsprintf(szPane, _xtPaneSection, i);
  525. PX_Int(pPX, szPane, nIndex, 0);
  526. ASSERT(nIndex > 0);
  528. CXTPDockingPaneBase* pPane = NULL;
  529. ASSERT(pMap->Lookup(nIndex, pPane));
  531. pPane = (CXTPDockingPaneBase*)((*pMap)[nIndex]);
  532. if (!pPane) return FALSE;
  534. _InsertPane(pPane);
  535. }
  537. m_pLayout->m_wndPanels[m_direction] = this;
  538. }
  540. return TRUE;
  541. }
  543. BOOL CXTPDockingPaneTabbedContainer::DoPropExchange(CXTPPropExchange* pPX)
  544. {
  545. CXTPDockingPaneBase::DoPropExchange(pPX);
  547. int nCount, nSelected;
  549. if (!pPX->IsLoading())
  550. {
  551. nCount = (int)m_lstPanes.GetCount();
  552. PX_Int(pPX, _xtPanes, nCount);
  554. nSelected = m_pSelectedPane ? m_pSelectedPane->m_nIndex : 0;
  555. PX_Int(pPX, _T("Selected"), nSelected, 0);
  557. PX_Bool(pPX, _T("Maximized"), m_bMaximized, FALSE);
  559. POSITION pos = m_lstPanes.GetHeadPosition();
  560. int nIndex = 1;
  561. while (pos)
  562. {
  563. CXTPDockingPaneBase* pPane = m_lstPanes.GetNext(pos);
  565. TCHAR szPane[256];
  566. wsprintf(szPane, _xtPaneSection, nIndex++);
  568. PX_Int(pPX, szPane, pPane->m_nIndex);
  569. }
  571. }
  572. else
  573. {
  574. PX_Int(pPX, _xtPanes, nCount);
  575. PX_Int(pPX, _T("Selected"), nSelected, 0);
  577. if (pPX->GetSchema() > _XTP_SCHEMA_1122)
  578. {
  579. PX_Bool(pPX, _T("Maximized"), m_bMaximized, FALSE);
  580. }
  582. TCHAR szPane[256];
  583. CXTPDockingPane* pSelected = NULL;
  584. int nIndex = 0;
  585. CXTPPaneIndexToPaneMap* pMap = (CXTPPaneIndexToPaneMap*)pPX->m_dwData;
  587. for (int i = 1; i <= nCount; i++)
  588. {
  589. wsprintf(szPane, _xtPaneSection, i);
  590. PX_Int(pPX, szPane, nIndex, 0);
  591. ASSERT(nIndex > 0);
  593. CXTPDockingPaneBase* pPane = NULL;
  594. ASSERT(pMap->Lookup(nIndex, pPane));
  596. pPane = (CXTPDockingPaneBase*)((*pMap)[nIndex]);
  598. if (!pPane || pPane->GetType() != xtpPaneTypeDockingPane) return FALSE;
  600. _InsertPane((CXTPDockingPane*)pPane);
  602. if (nIndex == nSelected) pSelected = (CXTPDockingPane*)pPane;
  603. }
  605. if (pSelected)
  606. {
  607. SelectPane(pSelected);
  608. }
  609. }
  611. return TRUE;
  612. }
  614. BOOL CXTPDockingPaneMiniWnd::DoPropExchange(CXTPPropExchange* pPX)
  615. {
  616. CXTPDockingPaneBase::DoPropExchange(pPX);
  618. PX_Long(pPX, _T("WindowRectTopPos"), m_rcWindow.top);
  619. PX_Long(pPX, _T("WindowRectBottomPos"), m_rcWindow.bottom);
  620. PX_Long(pPX, _T("WindowRectLeftPos"), m_rcWindow.left);
  621. PX_Long(pPX, _T("WindowRectRightPos"), m_rcWindow.right);
  622. PX_Bool(pPX, _T("Collapsed"), m_bCollapsed, FALSE);
  623. PX_Int(pPX, _T("ExpandedHeight"), m_nExpandedHeight, 0);
  625. if (!pPX->IsLoading())
  626. {
  627. int nTopContainer = m_pTopContainer ? m_pTopContainer->m_nIndex : 0;
  628. PX_Int(pPX, _T("TopContaner"), nTopContainer);
  629. }
  630. else
  631. {
  632. int nTopContainer = 0;
  633. PX_Int(pPX, _T("TopContaner"), nTopContainer);
  635. if (nTopContainer == 0)
  636. return FALSE;
  638. CXTPPaneIndexToPaneMap* pMap = (CXTPPaneIndexToPaneMap*)pPX->m_dwData;
  640. CXTPDockingPaneBase* pTop = (CXTPDockingPaneBase*)(*pMap)[nTopContainer];
  641. if (!pTop || pTop->GetType() != xtpPaneTypeSplitterContainer)
  642. return FALSE;
  644. m_pTopContainer = (CXTPDockingPaneSplitterContainer*)pTop;
  645. m_pTopContainer->m_pParentContainer = this;
  647. }
  649. return TRUE;
  650. }
  652. void CXTPDockingPaneLayout::Copy(const CXTPDockingPaneLayout* pLayout)
  653. {
  654. Free();
  656. CXTPPaneToPaneMap map;
  658. // Clone them
  659. POSITION pos = pLayout->m_lstStack.GetHeadPosition();
  660. while (pos)
  661. {
  662. CXTPDockingPaneBase* pPane = pLayout->m_lstStack.GetNext(pos);
  663. if (pPane->m_pParentContainer == NULL) // hidden pane, top pane, miniwnd.
  664. {
  665. pPane->Clone(this, &map);
  666. }
  667. }
  669. ASSERT(map.GetCount() == pLayout->m_lstStack.GetCount());
  670. ASSERT(map.Lookup(pLayout->m_pClient, m_pClient));
  671. ASSERT(map.Lookup(pLayout->m_pTopContainer, (CXTPDockingPaneBase*&)m_pTopContainer));
  673. m_pClient = map[pLayout->m_pClient];
  674. m_pTopContainer = (CXTPDockingPaneSplitterContainer*)map[pLayout->m_pTopContainer];
  676. for (int i = 0; i < 4; i++)
  677. if (pLayout->m_wndPanels[i]) m_wndPanels[i] = (CXTPDockingPaneAutoHidePanel*)map[pLayout->m_wndPanels[i]];
  679. // Map Holders
  680. pos = pLayout->m_lstPanes.GetHeadPosition();
  681. while (pos)
  682. {
  683. XTP_DOCKINGPANE_INFO& info = pLayout->GetPaneList().GetNext(pos);
  684. XTP_DOCKINGPANE_INFO infoCopy;
  685. ASSERT(map.Lookup((CXTPDockingPaneBase*)info.pPane, (CXTPDockingPaneBase*&)infoCopy.pPane));
  687. infoCopy.pPane = (CXTPDockingPane*)map[(CXTPDockingPaneBase*)info.pPane];
  689. if (info.pDockingHolder) infoCopy.pDockingHolder = (CXTPDockingPaneBase*)map[info.pDockingHolder];
  690. if (info.pLastHolder) infoCopy.pLastHolder = (CXTPDockingPaneBase*)map[info.pLastHolder];
  691. if (info.pFloatingHolder) infoCopy.pFloatingHolder = (CXTPDockingPaneBase*)map[info.pFloatingHolder];
  693. m_lstPanes.AddTail(infoCopy);
  694. }
  695. }
  697. void CXTPDockingPaneLayout::_FreeEmptyPanes()
  698. {
  699. WORD w;
  700. CMapPtrToWord map;
  702. POSITION pos = m_lstPanes.GetHeadPosition();
  703. while (pos)
  704. {
  705. XTP_DOCKINGPANE_INFO& info = m_lstPanes.GetNext(pos);
  706. map.SetAt(info.pDockingHolder, TRUE);
  707. map.SetAt(info.pFloatingHolder, TRUE);
  708. map.SetAt(info.pPane->m_pParentContainer, TRUE);
  709. }
  711. BOOL bFound = TRUE;
  713. while (bFound)
  714. {
  715. bFound = FALSE;
  717. POSITION posRemove = pos = m_lstStack.GetHeadPosition();
  718. while (pos)
  719. {
  720. CXTPDockingPaneBase* pPane = m_lstStack.GetNext(pos);
  721. CXTPDockingPaneBase* pParentContainer = pPane->m_pParentContainer;
  723. switch (pPane->GetType())
  724. {
  725. case xtpPaneTypeTabbedContainer:
  726. if (!map.Lookup(pPane, w))
  727. {
  729. SAFE_CALLPTR(pParentContainer, RemovePane(pPane));
  731. m_lstStack.RemoveAt(posRemove);
  732. pPane->DeletePane();
  733. bFound = TRUE;
  734. }
  735. break;
  737. case xtpPaneTypeSplitterContainer:
  738. if (((CXTPDockingPaneSplitterContainer*)pPane)->m_lstPanes.GetCount() == 0)
  739. {
  740. SAFE_CALLPTR(pParentContainer, RemovePane(pPane));
  742. m_lstStack.RemoveAt(posRemove);
  743. pPane->DeletePane();
  744. bFound = TRUE;
  745. }
  746. else if (pParentContainer && (pParentContainer->GetType() == xtpPaneTypeSplitterContainer)
  747. && (((CXTPDockingPaneSplitterContainer*)pPane)->m_lstPanes.GetCount() == 1)
  748. && (((CXTPDockingPaneSplitterContainer*)pParentContainer)->m_lstPanes.GetCount() == 1))
  749. {
  750. CXTPDockingPaneBase* pChildPane = ((CXTPDockingPaneSplitterContainer*)pPane)->m_lstPanes.RemoveHead();
  751. ((CXTPDockingPaneSplitterContainer*)pParentContainer)->m_lstPanes.RemoveHead();
  752. ((CXTPDockingPaneSplitterContainer*)pParentContainer)->m_lstPanes.AddHead(pChildPane);
  753. pChildPane->m_pParentContainer = pParentContainer;
  755. m_lstStack.RemoveAt(posRemove);
  756. pPane->DeletePane();
  757. bFound = TRUE;
  759. }
  760. break;
  762. case xtpPaneTypeMiniWnd:
  763. if (((CXTPDockingPaneMiniWnd*)pPane)->m_pTopContainer == NULL)
  764. {
  765. m_lstStack.RemoveAt(posRemove);
  766. pPane->DeletePane();
  767. bFound = TRUE;
  768. }
  769. break;
  771. case xtpPaneTypeSidePanel:
  772. if (((CXTPDockingPaneSidePanel*)pPane)->m_lstPanes.GetCount() == 0)
  773. {
  774. m_lstStack.RemoveAt(posRemove);
  775. pPane->DeletePane();
  776. bFound = TRUE;
  777. }
  778. break;
  779. }
  780. posRemove = pos;
  781. }
  782. }
  783. }
  786. XTP_DOCKINGPANE_INFO* CXTPDockingPaneLayout::FindPane(CXTPDockingPane* pPane)
  787. {
  788. POSITION pos = m_lstPanes.GetHeadPosition();
  789. while (pos)
  790. {
  791. XTP_DOCKINGPANE_INFO& info = m_lstPanes.GetNext(pos);
  793. if (info.pPane == pPane)
  794. return &info;
  795. }
  796. return 0;
  797. }
  799. XTPDockingPaneDirection CXTPDockingPaneLayout::_GetPaneDirection(const CXTPDockingPaneBase* pPane) const
  800. {
  801. if (pPane->GetType() == xtpPaneTypeMiniWnd)
  802. return (XTPDockingPaneDirection)4;
  804. if (!pPane->m_pParentContainer || pPane->GetType() == xtpPaneTypeClient)
  805. return (XTPDockingPaneDirection)-1;
  807. if (pPane->m_pParentContainer->GetType() == xtpPaneTypeAutoHidePanel)
  808. {
  809. return ((CXTPDockingPaneAutoHidePanel*)pPane->m_pParentContainer)->m_direction;
  810. }
  812. if (pPane->GetType() == xtpPaneTypeSidePanel)
  813. {
  814. return ((CXTPDockingPaneSidePanel*)pPane)->m_direction;
  815. }
  817. if (pPane->m_pParentContainer->GetType() == xtpPaneTypeSplitterContainer)
  818. {
  819. POSITION pos = pPane->m_pParentContainer->ContainPane(m_pClient);
  820. if (pos)
  821. {
  822. CXTPDockingPaneSplitterContainer* pSplitter = (CXTPDockingPaneSplitterContainer*)pPane->m_pParentContainer;
  824. if (pSplitter->_Before(pPane, pos))
  825. {
  826. return  pSplitter->IsHoriz() ? xtpPaneDockLeft : xtpPaneDockTop;
  828. }
  829. else
  830. {
  831. return  pSplitter->IsHoriz() ? xtpPaneDockRight : xtpPaneDockBottom;
  832. }
  833. }
  834. }
  835. return _GetPaneDirection(pPane->m_pParentContainer);
  836. }
  838. void CXTPDockingPaneLayout::_AddPanesTo(CXTPDockingPaneTabbedContainer* pContainer, CXTPDockingPaneBaseList& lst, DWORD dwIgnoredOptions)
  839. {
  840. POSITION pos = lst.GetHeadPosition();
  841. while (pos)
  842. {
  843. CXTPDockingPane* pPane = (CXTPDockingPane*)lst.GetNext(pos);
  845. if ((((CXTPDockingPane*)pPane)->GetOptions() & dwIgnoredOptions) == 0)
  846. {
  847. SAFE_CALLPTR(pPane->m_pParentContainer, RemovePane(pPane));
  848. pContainer->_InsertPane(pPane);
  849. }
  850. }
  851. }
  853. BOOL CXTPDockingPaneLayout::_FindTabbedPaneToHide(CXTPDockingPaneAutoHidePanel* pPanel, CXTPDockingPaneBase* pPane)
  854. {
  855. CXTPDockingPaneBaseList lst;
  856. pPane->FindPane(xtpPaneTypeDockingPane, &lst);
  858. if (lst.IsEmpty())
  859. return FALSE;
  861. CXTPDockingPane* pPanePrimary = (CXTPDockingPane*)lst.GetHead();
  862. XTP_DOCKINGPANE_INFO* pInfo = FindPane(pPanePrimary);
  863. if (!pInfo || pInfo->pDockingHolder == NULL)
  864. return FALSE;
  866. POSITION pos = pPanel->m_lstPanes.GetHeadPosition();
  867. while (pos)
  868. {
  869. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)pPanel->m_lstPanes.GetNext(pos);
  870. CXTPDockingPane* pContainerPane = (CXTPDockingPane*)pContainer->GetFirstPane();
  871. if (pContainerPane)
  872. {
  873. XTP_DOCKINGPANE_INFO* pContanerPaneInfo = FindPane(pContainerPane);
  875. if (pContanerPaneInfo && pContanerPaneInfo->pDockingHolder == pInfo->pDockingHolder)
  876. {
  877. _AddPanesTo(pContainer, lst, xtpPaneNoHideable);
  878. return TRUE;
  879. }
  880. }
  881. }
  885. return FALSE;
  886. }
  888. void CXTPDockingPaneLayout::HidePane(CXTPDockingPaneBase* pPane)
  889. {
  890. ASSERT(!m_bUserLayout);
  892. XTPDockingPaneDirection direction = _GetPaneDirection(pPane);
  893. if (direction < 0 || direction >= 4)
  894. direction = xtpPaneDockLeft;
  896. if (m_wndPanels[direction] == 0)
  897. {
  898. m_wndPanels[direction] = (CXTPDockingPaneAutoHidePanel*)m_pManager->
  899. OnCreatePane(xtpPaneTypeAutoHidePanel, this);
  900. m_wndPanels[direction]->m_direction = direction;
  901. }
  903. if (_FindTabbedPaneToHide(m_wndPanels[direction], pPane))
  904. return;
  906. if (pPane->GetType() == xtpPaneTypeDockingPane)
  907. {
  908. pPane->m_pParentContainer->RemovePane(pPane);
  910. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)m_pManager->
  911. OnCreatePane(xtpPaneTypeTabbedContainer, this);
  912. pContainer->Init((CXTPDockingPane*)pPane, m_pManager->GetSite());
  914. pPane = pContainer;
  916. }
  917. else if (pPane->GetType() == xtpPaneTypeTabbedContainer)
  918. {
  919. pPane = ((CXTPDockingPaneBase*)pPane)->Clone(this, 0, xtpPaneNoHideable);
  920. }
  922. m_wndPanels[direction]->_InsertPane(pPane);
  923. }
  925. void CXTPDockingPaneLayout::RepositionMargins(CRect& rect, const CRect& rcClientMargins)
  926. {
  927. int i;
  929. if (rcClientMargins.IsRectNull())
  930. {
  931. for (i = 0; i < 4; i++)
  932. {
  933. SAFE_DELETE(m_wndMargins[i]);
  934. }
  935. return;
  936. }
  938. for (i = 0; i < 4; i++)
  939. {
  940. if (m_wndMargins[i] == 0)
  941. {
  942. m_wndMargins[i] = new CXTPDockingPaneSplitterWnd();
  943. m_wndMargins[i]->Create(m_pManager, i == xtpPaneDockTop || i == xtpPaneDockBottom);
  944. }
  945. }
  947. CRect rcClient(rect);
  948. rcClient.DeflateRect(rcClientMargins);
  950. m_wndMargins[xtpPaneDockLeft]->MoveWindow(CRect(rect.left, rect.top, rcClient.left, rect.bottom));
  951. m_wndMargins[xtpPaneDockRight]->MoveWindow(CRect(rcClient.right , rect.top, rect.right, rect.bottom));
  952. m_wndMargins[xtpPaneDockTop]->MoveWindow(CRect(rcClient.left, rect.top, rcClient.right, rcClient.top));
  953. m_wndMargins[xtpPaneDockBottom]->MoveWindow(CRect(rcClient.left, rcClient.bottom, rcClient.right, rect.bottom));
  955. for (i = 0; i < 4; i++)
  956. {
  957. m_wndMargins[i]->Invalidate(FALSE);
  958. }
  960. rect = rcClient;
  961. }
  964. void CXTPDockingPaneLayout::OnSizeParent(CWnd* pParent, CRect rect, LPVOID lParam)
  965. {
  966. AFX_SIZEPARENTPARAMS* lpLayout = (AFX_SIZEPARENTPARAMS*)lParam;
  968. for (int i = 0; i < 4; i++)
  969. {
  970. SAFE_CALLPTR(m_wndPanels[i], OnSizeParentEx(pParent, rect, lParam));
  971. }
  973. int nMargin = m_pManager->GetClientMargin();
  974. CRect rcClientMargins(nMargin, nMargin, nMargin, nMargin);
  976. if (lpLayout->hDWP != NULL)
  977. {
  978. RepositionMargins(rect, rcClientMargins);
  979. }
  980. else
  981. {
  982. rect.DeflateRect(rcClientMargins);
  983. }
  985. m_pClient->OnSizeParent(pParent, rect, lParam);
  986. m_pTopContainer->OnSizeParent(pParent, rect, lParam);
  988. if (lpLayout->hDWP)
  989. {
  990. CXTPDockingPaneSidePanel::OnSizeParentEx(m_pManager, pParent, lpLayout->rect);
  991. }
  992. }
  995. void CXTPDockingPaneLayout::DestroyPane(CXTPDockingPane* pPane)
  996. {
  997. if (pPane == NULL) return;
  999. SAFE_CALLPTR(pPane->m_pParentContainer, RemovePane(pPane));
  1001. POSITION pos = m_lstPanes.GetHeadPosition();
  1002. while (pos)
  1003. {
  1004. if (m_lstPanes.GetAt(pos) == pPane)
  1005. {
  1006. m_lstPanes.RemoveAt(pos);
  1007. break;
  1008. }
  1009. m_lstPanes.GetNext(pos);
  1010. }
  1012. pos = m_lstStack.GetHeadPosition();
  1013. while (pos)
  1014. {
  1015. if (m_lstStack.GetAt(pos) == pPane)
  1016. {
  1017. m_lstStack.RemoveAt(pos);
  1018. break;
  1019. }
  1020. m_lstStack.GetNext(pos);
  1021. }
  1022. ((CXTPDockingPane*)pPane)->InternalRelease();
  1023. _FreeEmptyPanes();
  1025. }
  1027. void CXTPDockingPaneLayout::MoveToTail(CXTPDockingPaneBase* pPane)
  1028. {
  1029. POSITION pos = m_lstStack.GetHeadPosition();
  1030. while (pos)
  1031. {
  1032. if (m_lstStack.GetAt(pos) == pPane)
  1033. {
  1034. m_lstStack.RemoveAt(pos);
  1035. m_lstStack.AddTail(pPane);
  1036. return;
  1037. }
  1038. m_lstStack.GetNext(pos);
  1039. }
  1040. }