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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneSplitterContainer.cpp：源码内容
  1. // XTPDockingPaneSplitterContainer.cpp : implementation of the CXTPDockingPaneSplitterContainer 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/Resource.h"
  24. #include "Common/XTPDrawHelpers.h"
  25. #include "Common/XTPColorManager.h"
  26. #include "Common/XTPResourceManager.h"
  28. #include "XTPDockingPaneBase.h"
  29. #include "XTPDockingPaneLayout.h"
  30. #include "XTPDockingPaneManager.h"
  31. #include "XTPDockingPaneSplitterContainer.h"
  32. #include "XTPDockingPanePaintManager.h"
  34. #ifdef _DEBUG
  35. #define new DEBUG_NEW
  36. #undef THIS_FILE
  37. static char THIS_FILE[] = __FILE__;
  38. #endif
  42. CXTPDockingPaneSplitterWnd::CXTPDockingPaneSplitterWnd()
  43. {
  44. m_hCursor = 0;
  45. m_pFirst = 0;
  46. m_pSecond = 0;
  47. m_pContainer = 0;
  48. m_pManager = 0;
  49. m_bHoriz = FALSE;
  50. }
  52. void CXTPDockingPaneSplitterWnd::Create(CXTPDockingPaneManager* pManager, BOOL bHoriz)
  53. {
  54. m_bHoriz = bHoriz;
  55. m_pManager = pManager;
  56. CWnd::Create(_T("XTPDockingPaneSplitter"), _T("Splitter"), WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, CRect(0, 0, 0, 0), pManager->GetSite(), 0);
  57. }
  59. void CXTPDockingPaneSplitterWnd::Create(CXTPDockingPaneSplitterContainer* pContainer, CXTPDockingPaneBase* pFirst, CXTPDockingPaneBase* pSecond)
  60. {
  61. m_pFirst = pFirst;
  62. m_pSecond = pSecond;
  63. m_pContainer = pContainer;
  64. m_bHoriz = !m_pContainer->IsHoriz();
  65. m_pManager = m_pContainer->GetDockingPaneManager();
  67. m_hCursor = XTPResourceManager()->LoadCursor(pContainer->m_bHoriz ? XTP_IDC_HSPLITBAR :  XTP_IDC_VSPLITBAR);
  69. CWnd::Create(_T("XTPDockingPaneSplitter"), _T("Splitter"), WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, CRect(0, 0, 0, 0), pContainer->GetDockingSite(), 0);
  70. }
  72. CXTPDockingPaneSplitterWnd::~CXTPDockingPaneSplitterWnd()
  73. {
  74. if (m_hWnd) DestroyWindow();
  75. }
  77. BEGIN_MESSAGE_MAP(CXTPDockingPaneSplitterWnd, CWnd)
  78. ON_WM_PAINT()
  79. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  80. ON_WM_LBUTTONDOWN()
  81. ON_WM_ERASEBKGND()
  82. ON_WM_SETCURSOR()
  83. END_MESSAGE_MAP()
  85. BOOL CXTPDockingPaneSplitterWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  86. {
  87. if (m_pContainer == 0)
  88. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  90. if (GetDockingPaneManager()->IsSplittersLocked())
  91. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  93. CRect rcAvail, rcUnion;
  94. if (!GetAvailableRect(rcAvail, rcUnion))
  95. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  97. ::SetCursor(m_hCursor);
  98. return TRUE;
  99. }
  101. void CXTPDockingPaneSplitterWnd::OnPaint()
  102. {
  103. CPaintDC dc(this);
  105. if (m_pManager)
  106. m_pManager->GetPaintManager()->DrawSplitter(&dc, this);
  107. }
  109. LRESULT CXTPDockingPaneSplitterWnd::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  110. {
  111. CDC* pDC = CDC::FromHandle((HDC)wParam);
  112. if (pDC && m_pManager)
  113. {
  114. m_pManager->GetPaintManager()->DrawSplitter(pDC, this);
  115. }
  117. return TRUE;
  118. }
  120. BOOL CXTPDockingPaneSplitterWnd::OnEraseBkgnd(CDC* /*pDC*/)
  121. {
  122. return TRUE;
  123. }
  125. BOOL CXTPDockingPaneSplitterWnd::IsHorizontal() const
  126. {
  127. return m_bHoriz;
  128. }
  130. void CXTPDockingPaneSplitterWnd::Reposition(CRect rc, CRect rcAvail)
  131. {
  132. int nSplitterSize = m_pContainer->GetDockingPaneManager()->GetPaintManager()->m_nSplitterSize;
  133. int nSplitterIndent = m_pContainer->GetDockingPaneManager()->GetPaintManager()->m_nSplitterIndent;
  135. if (m_pContainer->m_bHoriz)
  136. {
  137. double d = double(rc.left + nSplitterIndent - rcAvail.left) / rcAvail.Width();
  138. int nSum = m_pFirst->m_szDocking.cx + m_pSecond->m_szDocking.cx + nSplitterSize;
  139. m_pFirst->m_szDocking.cx = GetExStyle() & WS_EX_LAYOUTRTL ? nSum - int(d * nSum) - nSplitterSize : int(d * nSum);
  140. m_pSecond->m_szDocking.cx = nSum - m_pFirst->m_szDocking.cx - nSplitterSize;
  141. }
  142. else
  143. {
  144. double d = double(rc.top + nSplitterIndent - rcAvail.top) / rcAvail.Height();
  145. int nSum = m_pFirst->m_szDocking.cy + m_pSecond->m_szDocking.cy + nSplitterSize;
  146. m_pFirst->m_szDocking.cy = int(d * nSum);
  147. m_pSecond->m_szDocking.cy = nSum - m_pFirst->m_szDocking.cy - nSplitterSize;
  148. }
  150. }
  152. void CXTPDockingPaneSplitterContainer::NormalizeDockingSize()
  153. {
  154. if (m_bHoriz) m_szDocking.cx = m_rcWindow.Width();
  155. else m_szDocking.cy = m_rcWindow.Height();
  157. POSITION pos = GetHeadPosition();
  158. while (pos)
  159. {
  160. CXTPDockingPaneBase* pPane = GetNext(pos);
  161. if (!pPane->IsEmpty())
  162. {
  163. if (m_bHoriz) pPane->m_szDocking.cx = pPane->m_rcWindow.Width();
  164. else pPane->m_szDocking.cy = pPane->m_rcWindow.Height();
  165. }
  166. }
  167. }
  169. BOOL CXTPDockingPaneSplitterWnd::GetAvailableRect(CRect& rcAvail, CRect& rcUnion)
  170. {
  171. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  172. if (!pManager)
  173. return FALSE;
  175. int nSplitterSize = pManager->GetPaintManager()->m_nSplitterSize;
  177. BOOL bHoriz = m_pContainer->m_bHoriz;
  178. ASSERT(m_pFirst && m_pSecond);
  179. if (!m_pFirst || !m_pSecond)
  180. return FALSE;
  182. CRect rcFirst = m_pFirst->GetPaneWindowRect();
  183. CRect rcSecond = m_pSecond->GetPaneWindowRect();
  185. MINMAXINFO mmiFirst, mmiSecond;
  186. m_pFirst->GetMinMaxInfo(&mmiFirst);
  187. m_pSecond->GetMinMaxInfo(&mmiSecond);
  189. rcAvail.UnionRect(rcFirst, rcSecond);
  190. rcUnion = rcAvail;
  192. int nGap = pManager->m_nSplitterGap;
  193. if (bHoriz)
  194. {
  195. rcAvail.DeflateRect(max(mmiFirst.ptMinTrackSize.x, nGap), 0,
  196. max(mmiSecond.ptMinTrackSize.x + nSplitterSize, nGap), 0);
  198. if (rcUnion.Width() > mmiFirst.ptMaxTrackSize.x)
  199. rcAvail.right = min(rcAvail.right, rcUnion.left + mmiFirst.ptMaxTrackSize.x);
  201. if (rcUnion.Width() > mmiSecond.ptMaxTrackSize.x)
  202. rcAvail.left = max(rcAvail.left, rcUnion.right - mmiSecond.ptMaxTrackSize.x - nSplitterSize);
  204. if (rcAvail.left >= rcAvail.right)
  205. return FALSE;
  206. }
  207. else
  208. {
  209. rcAvail.DeflateRect(0, max(mmiFirst.ptMinTrackSize.y, nGap),
  210. 0, max(mmiSecond.ptMinTrackSize.y + nSplitterSize, nGap));
  212. if (rcUnion.Height() > mmiFirst.ptMaxTrackSize.y)
  213. rcAvail.bottom = min(rcAvail.bottom, rcUnion.top + mmiFirst.ptMaxTrackSize.y);
  215. if (rcUnion.Height() > mmiSecond.ptMaxTrackSize.y)
  216. rcAvail.top = max(rcAvail.top, rcUnion.bottom - mmiSecond.ptMaxTrackSize.y - nSplitterSize);
  218. if (rcAvail.top >= rcAvail.bottom)
  219. return FALSE;
  220. }
  221. return TRUE;
  222. }
  224. void CXTPDockingPaneSplitterWnd::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  225. {
  226. if (m_pContainer == 0)
  227. return;
  229. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  231. if (pManager->IsSplittersLocked())
  232. return;
  234. CXTPWindowRect rc(this);
  236. CRect rcAvail, rcUnion;
  237. if (!GetAvailableRect(rcAvail, rcUnion))
  238. return;
  240. if (m_pContainer->OnAction(xtpPaneActionSplitterResizing))
  241. return;
  243. m_pContainer->NormalizeDockingSize();
  245. BOOL bHoriz = m_pContainer->m_bHoriz;
  248. //point = rc.TopLeft();
  249. ClientToScreen(&point);
  251. if (pManager->IsSplitterTrackerUsed())
  252. {
  254. CXTPSplitterTracker tracker;
  255. BOOL bAccept = tracker.Track(this, rcAvail, rc, point, bHoriz);
  257. if (bAccept)
  258. {
  259. Reposition(rc, rcUnion);
  262. pManager->RecalcFrameLayout(m_pContainer, TRUE);
  263. }
  264. }
  265. else
  266. {
  267. CPoint ptOffset = bHoriz ? CPoint(rc.left - point.x, 0) :
  268. CPoint(0, rc.top - point.y);
  270. SetCapture();
  272. while (CWnd::GetCapture() == this)
  273. {
  274. MSG msg;
  276. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  277. {
  278. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  279. return;
  280. DispatchMessage(&msg);
  281. }
  283. if (!GetMessage(&msg, NULL, 0, 0))
  284. break;
  286. if (msg.message == WM_MOUSEMOVE)
  287. {
  289. point = CPoint(msg.lParam);
  290. ClientToScreen(&point);
  291. point += ptOffset;
  293. point.x = max(min(point.x, rcAvail.right), rcAvail.left);
  294. point.y = max(min(point.y, rcAvail.bottom), rcAvail.top);
  296. if (bHoriz)
  297. {
  298. if (rc.left == point.x)
  299. continue;
  300. rc.OffsetRect(point.x - rc.left, 0);
  301. }
  302. else
  303. {
  304. if (rc.top == point.y)
  305. continue;
  306. rc.OffsetRect(0, point.y - rc.top);
  307. }
  309. Reposition(rc, rcUnion);
  311. pManager->RecalcFrameLayout(m_pContainer);
  312. }
  313. else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) break;
  314. else if (msg.message == WM_LBUTTONUP) break;
  315. else ::DispatchMessage(&msg);
  316. }
  318. if (CWnd::GetCapture() == this) ReleaseCapture();
  319. }
  321. m_pContainer->OnAction(xtpPaneActionSplitterResized);
  322. }
  324. CXTPDockingPaneManager* CXTPDockingPaneSplitterWnd::GetDockingPaneManager() const
  325. {
  326. return m_pManager;
  327. }
  330. CXTPDockingPaneSplitterContainer::CXTPDockingPaneSplitterContainer(CXTPDockingPaneLayout* pLayout)
  331. : CXTPDockingPaneBaseContainer(xtpPaneTypeSplitterContainer, pLayout)
  332. {
  333. m_bRecalcLayout = FALSE;
  334. m_bHoriz = FALSE;
  336. }
  338. void CXTPDockingPaneSplitterContainer::Init(CXTPDockingPaneBase* pPane, BOOL bHoriz, CWnd* pFrame)
  339. {
  340. ASSERT(pPane);
  341. if (!pPane)
  342. return;
  344. m_bHoriz = bHoriz;
  345. m_pDockingSite = pFrame;
  346. _InsertPane(pPane);
  348. m_szDocking = pPane->m_szDocking;
  349. }
  351. void CXTPDockingPaneSplitterContainer::_UpdateSplitters()
  352. {
  353. if (m_bRecalcLayout)
  354. return;
  356. if (m_pLayout->IsUserLayout())
  357. return;
  359. while (!m_lstSpliters.IsEmpty())
  360. {
  361. delete m_lstSpliters.RemoveTail();
  362. }
  364. if (m_lstPanes.GetCount() > 1)
  365. {
  366. POSITION posPane = GetHeadPosition();
  367. CXTPDockingPaneBase* pFirstPane = NULL;
  369. // Finding first nonempty pane
  370. while (posPane)
  371. {
  372. pFirstPane = GetNext(posPane);
  373. if (!pFirstPane->IsEmpty())
  374. break;
  375. }
  377. // Splitting
  378. while (posPane)
  379. {
  380. CXTPDockingPaneBase* pSecondPane = GetNext(posPane);
  381. if (pSecondPane->IsEmpty())
  382. continue;
  384. CXTPDockingPaneSplitterWnd* pSplitter = OnCreateSplitter();
  385. pSplitter->Create(this, pFirstPane, pSecondPane);
  387. m_lstSpliters.AddTail(pSplitter);
  389. pFirstPane = pSecondPane;
  390. }
  391. }
  392. }
  394. CXTPDockingPaneSplitterWnd* CXTPDockingPaneSplitterContainer::OnCreateSplitter()
  395. {
  396. return new CXTPDockingPaneSplitterWnd();
  397. }
  399. void CXTPDockingPaneSplitterContainer::_Replace(CXTPDockingPaneBase* pPane, CXTPDockingPaneBase* pReplace)
  400. {
  401. ASSERT(pPane && pReplace);
  403. POSITION pos = m_lstPanes.Find(pPane);
  404. ASSERT(pos);
  406. m_lstPanes.InsertAfter(pos, pReplace);
  407. m_lstPanes.RemoveAt(pos);
  409. pReplace->m_pParentContainer = this;
  411. _UpdateSplitters();
  413. if (m_pParentContainer)
  414. {
  415. m_pParentContainer->OnChildContainerChanged(this);
  416. }
  417. }
  419. void CXTPDockingPaneSplitterContainer::_InsertPane(CXTPDockingPaneBase* pPane, CXTPDockingPaneBase* pNeighbour, BOOL bAfter)
  420. {
  421. POSITION pos = pNeighbour ? m_lstPanes.Find(pNeighbour) : NULL;
  423. if (bAfter)
  424. {
  425. if (pos == NULL) pos = m_lstPanes.GetTailPosition();
  426. m_lstPanes.InsertAfter(pos, pPane);
  427. }
  428. else
  429. {
  430. if (pos == NULL) pos = GetHeadPosition();
  431. m_lstPanes.InsertBefore(pos, pPane);
  432. }
  433. pPane->m_pParentContainer = this;
  434. pPane->SetDockingSite(GetDockingSite());
  436. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  438. _UpdateSplitters();
  440. if (m_pParentContainer)
  441. {
  442. m_pParentContainer->OnChildContainerChanged(this);
  443. }
  445. pPane->OnParentContainerChanged(this);
  447. }
  449. void CXTPDockingPaneSplitterContainer::RemovePane(CXTPDockingPaneBase* pPane)
  450. {
  451. POSITION pos = m_lstPanes.Find(pPane);
  452. ASSERT(pos);
  454. m_lstPanes.RemoveAt(pos);
  455. _UpdateSplitters();
  457. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  459. if (m_pParentContainer)
  460. {
  461. m_pParentContainer->OnChildContainerChanged(this);
  462. }
  464. if (m_lstPanes.IsEmpty())
  465. {
  466. m_pParentContainer->RemovePane(this);
  467. }
  469. pPane->m_pParentContainer = NULL;
  470. }
  472. void CXTPDockingPaneSplitterContainer::OnChildContainerChanged(CXTPDockingPaneBase* pContainer)
  473. {
  474. if (m_pParentContainer)
  475. {
  476. m_pParentContainer->OnChildContainerChanged(pContainer);
  477. }
  479. _UpdateSplitters();
  480. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  481. }
  483. void CXTPDockingPaneSplitterContainer::OnParentContainerChanged(CXTPDockingPaneBase* pContainer)
  484. {
  485. m_pDockingSite = pContainer->m_pDockingSite;
  486. _UpdateSplitters();
  488. POSITION pos = GetHeadPosition();
  489. while (pos)
  490. {
  491. GetNext(pos)->OnParentContainerChanged(pContainer);
  492. }
  493. }
  496. CXTPDockingPaneSplitterContainer::~CXTPDockingPaneSplitterContainer()
  497. {
  498. while (!m_lstSpliters.IsEmpty())
  499. {
  500. delete m_lstSpliters.RemoveTail();
  501. }
  502. }
  504. void CXTPDockingPaneSplitterContainer::OnSizeParent(CWnd* pParent, CRect rect, LPVOID lParam)
  505. {
  506. int nSplitterSize = GetDockingPaneManager()->GetPaintManager()->m_nSplitterSize;
  507. int nSplitterIndent = GetDockingPaneManager()->GetPaintManager()->m_nSplitterIndent;
  508. CXTPDockingPaneBase* pClient = GetDockingPaneManager()->GetClientPane();
  511. AFX_SIZEPARENTPARAMS* lpLayout = (AFX_SIZEPARENTPARAMS*)lParam;
  513. m_pDockingSite = pParent;
  514. m_rcWindow = rect;
  516. BOOL bClientPane = !GetDockingPaneManager()->m_bHideClient;
  518. // getting list of nonempty panes
  519. CXTPDockingPaneBaseList lst;
  520. POSITION pos = GetHeadPosition();
  521. while (pos)
  522. {
  523. CXTPDockingPaneBase* pPane = GetNext(pos);
  524. if (!pPane->IsEmpty())
  525. lst.AddTail(pPane);
  527. if (!bClientPane && pPane->ContainPane(pClient))
  528. bClientPane = TRUE;
  530. }
  532. if (!lst.IsEmpty() && bClientPane && GetDockingPaneManager()->m_bHideClient)
  533. {
  534. pClient->OnSizeParent(pParent, CXTPEmptyRect(), lParam);
  535. }
  538. if (lst.GetCount() == 0)
  539. return;
  541. if (lst.GetCount() == 1)
  542. {
  543. lst.GetHead()->OnSizeParent(pParent, rect, lParam);
  544. return;
  545. }
  547. if (m_bRecalcLayout)
  548. return;
  550. m_bRecalcLayout = TRUE;
  552. //ASSERT(m_lstSpliters.GetCount() == lst.GetCount() - 1);
  554. int nTotalLength = 0;
  555. int nLengthAvail = 0;
  557. _AdjustPanesLength(GetDockingPaneManager(), lst, rect, m_bHoriz, TRUE, nTotalLength, nLengthAvail);
  559. pos = lst.GetHeadPosition();
  560. POSITION posSplitter = m_lstSpliters.GetHeadPosition();
  562. CRect rcPane(rect);
  563. while (pos)
  564. {
  565. CXTPDockingPaneBase* pPane = lst.GetNext(pos);
  567. int nLength = -pPane->m_nLength;
  568. if (pPane->m_nLength > 0)
  569. {
  570. nLength = nTotalLength == 0 ? 0 : int((nLengthAvail * pPane->m_nLength) / nTotalLength);
  572. nTotalLength -= pPane->m_nLength;
  573. nLengthAvail = max(nLengthAvail - nLength, 0);
  574. }
  576. CRect rcSplitter;
  578. if (m_bHoriz)
  579. {
  580. rcPane.right = pos == NULL ? rect.right : rcPane.left + nLength;
  581. rcSplitter.SetRect(rcPane.right - nSplitterIndent, rect.top, rcPane.right + nSplitterSize + nSplitterIndent, rect.bottom);
  582. }
  583. else
  584. {
  585. rcPane.bottom = pos == NULL ? rect.bottom : rcPane.top + nLength;
  586. rcSplitter.SetRect(rect.left, rcPane.bottom - nSplitterIndent, rect.right, rcPane.bottom + nSplitterSize + nSplitterIndent);
  587. }
  589. if (lpLayout->hDWP != NULL && posSplitter)
  590. {
  591. CXTPDockingPaneSplitterWnd* pSplitter = m_lstSpliters.GetNext(posSplitter);
  592. if (pSplitter)
  593. {
  594. rcSplitter.IntersectRect(rcSplitter, rect);
  595. pSplitter->SetWindowPos(&CWnd::wndBottom, rcSplitter.left, rcSplitter.top, rcSplitter.Width(), rcSplitter.Height(), 0);
  596. pSplitter->Invalidate(FALSE);
  597. }
  598. }
  600. pPane->OnSizeParent(pParent, rcPane, lParam);
  602. if (m_bHoriz)
  603. {
  604. rcPane.left = rcPane.right + nSplitterSize;
  605. }
  606. else
  607. {
  608. rcPane.top = rcPane.bottom + nSplitterSize;
  609. }
  610. }
  612. m_bRecalcLayout = FALSE;
  613. }
  615. void CXTPDockingPaneSplitterContainer::FindChildPane(XTPDockingPaneType type, CXTPDockingPaneBaseList* pList) const
  616. {
  617. POSITION pos = GetHeadPosition();
  618. while (pos)
  619. {
  620. CXTPDockingPaneBase* pPane = GetNext(pos);
  622. if (pPane->GetType() == type && !pPane->IsEmpty())
  623. {
  624. pList->AddTail(pPane);
  625. }
  626. }
  627. }
  629. void CXTPDockingPaneSplitterContainer::Copy(CXTPDockingPaneBase* pCloneBase, CXTPPaneToPaneMap* pMap, DWORD /*dwIgnoredOptions*/)
  630. {
  631. CXTPDockingPaneSplitterContainer* pClone = (CXTPDockingPaneSplitterContainer*)pCloneBase;
  632. ASSERT(pClone);
  633. if (!pClone)
  634. return;
  636. m_bHoriz = pClone->m_bHoriz;
  637. m_pDockingSite = GetDockingPaneManager()->GetSite();
  639. POSITION pos = pClone->GetHeadPosition();
  640. while (pos)
  641. {
  642. CXTPDockingPaneBase* pPane = (CXTPDockingPaneBase*)pClone->GetNext(pos);
  643. if (!pPane->IsEmpty() || pMap)
  644. {
  645. _InsertPane(pPane->Clone(m_pLayout, pMap));
  646. }
  647. }
  648. m_szDocking = pClone->m_szDocking;
  649. m_rcWindow = pClone->m_rcWindow;
  650. }
  653. BOOL CXTPDockingPaneSplitterContainer::_Before(const CXTPDockingPaneBase* pPane, POSITION pos) const
  654. {
  655. POSITION p = GetHeadPosition();
  656. while (p)
  657. {
  658. if (p == pos) return FALSE;
  659. CXTPDockingPaneBase* pBase = GetNext(p);
  660. if (pBase == pPane) return TRUE;
  661. }
  663. ASSERT(FALSE);
  664. return FALSE;
  665. }
  667. void CXTPDockingPaneSplitterContainer::_AdjustPanesLength(CXTPDockingPaneManager* pManager, CXTPDockingPaneBaseList& lst, CRect rect, BOOL bHoriz, BOOL bApply, int& nTotalLength, int& nLengthAvail)
  668. {
  669. nTotalLength = 0;
  670. nLengthAvail = 0;
  672. CXTPDockingPaneBase* pClientPane = NULL;
  673. CXTPDockingPaneBase* pClient = pManager->GetClientPane();
  674. int nSplitterSize = pManager->GetPaintManager()->m_nSplitterSize;
  676. POSITION pos = lst.GetHeadPosition();
  677. while (pos)
  678. {
  679. CXTPDockingPaneBase* pPane = lst.GetNext(pos);
  680. pPane->m_nLength = bHoriz ? pPane->m_szDocking.cx : pPane->m_szDocking.cy;
  682. MINMAXINFO mmi;
  683. pPane->GetMinMaxInfo(&mmi);
  684. pPane->m_nLength = max(GetMinSize(&mmi, bHoriz), min(GetMaxSize(&mmi, bHoriz), pPane->m_nLength));
  686. if (pClientPane == NULL && pPane->ContainPane(pClient))
  687. {
  688. if (!pManager->m_bHideClient || pPane->m_szDocking == CSize(0, 0))
  689. {
  690. pClientPane = pPane;
  691. if (bApply) pClientPane->m_szDocking = CSize(0, 0);
  692. pClientPane->m_nLength = 0;
  693. }
  694. }
  695. nTotalLength += pPane->m_nLength;
  696. }
  697. nLengthAvail = (bHoriz ? rect.Width() : rect.Height()) - (nSplitterSize * ((int)lst.GetCount() - 1));
  700. if (pClientPane && nTotalLength < nLengthAvail)
  701. {
  702. pClientPane->m_nLength = nLengthAvail - nTotalLength;
  703. if (bApply)
  704. {
  705. if (bHoriz) pClientPane->m_szDocking.cx = pClientPane->m_nLength;
  706. else pClientPane->m_szDocking.cy = pClientPane->m_nLength;
  707. }
  708. nTotalLength = nLengthAvail;
  709. }
  711. if (nLengthAvail > 0)
  712. {
  713. pos = lst.GetHeadPosition();
  714. while (pos)
  715. {
  716. CXTPDockingPaneBase* pPane = lst.GetNext(pos);
  718. if ((pPane->m_nLength < 0) || (nTotalLength == 0))
  719. continue;
  721. MINMAXINFO mmi;
  722. pPane->GetMinMaxInfo(&mmi);
  724. int nLength = pPane->m_nLength;
  726. if (nLengthAvail * nLength / nTotalLength < GetMinSize(&mmi, bHoriz))
  727. pPane->m_nLength = -GetMinSize(&mmi, bHoriz);
  728. else if (nLengthAvail * nLength / nTotalLength > GetMaxSize(&mmi, bHoriz))
  729. pPane->m_nLength = -GetMaxSize(&mmi, bHoriz);
  731. if (pPane->m_nLength < 0)
  732. {
  733. nLengthAvail += pPane->m_nLength;
  734. nTotalLength -= nLength;
  736. if (nLengthAvail < 0)
  737. {
  738. pPane->m_nLength -= nLengthAvail;
  739. nLengthAvail = 0;
  740. break;
  741. }
  743. pos = lst.GetHeadPosition();
  744. }
  745. }
  746. }
  747. }
  750. CRect CXTPDockingPaneSplitterContainer::_CalculateResultDockingRect(BOOL bHoriz, CXTPDockingPaneBaseList& lst, CRect rect, CXTPDockingPaneBase* pPaneI)
  751. {
  752. CXTPDockingPaneManager* pManager = pPaneI->GetDockingPaneManager();
  753. int nSplitterSize = pManager->GetPaintManager()->m_nSplitterSize;
  755. int nTotalLength = 0;
  756. int nLengthAvail = 0;
  758. _AdjustPanesLength(pManager, lst, rect, bHoriz, FALSE, nTotalLength, nLengthAvail);
  761. POSITION pos = lst.GetHeadPosition();
  763. CRect rcPane(rect);
  764. while (pos)
  765. {
  766. CXTPDockingPaneBase* pPane = lst.GetNext(pos);
  768. int nLength = -pPane->m_nLength;
  769. if (pPane->m_nLength > 0)
  770. {
  771. nLength = nTotalLength == 0 ? 0 : int((nLengthAvail * pPane->m_nLength) / nTotalLength);
  773. nTotalLength -= pPane->m_nLength;
  774. nLengthAvail = max(nLengthAvail - nLength, 0);
  775. }
  777. if (bHoriz)
  778. {
  779. rcPane.right = pos == NULL ? rect.right : rcPane.left + nLength;
  781. if (pPaneI == pPane)
  782. break;
  784. rcPane.left = rcPane.right + nSplitterSize;
  785. }
  786. else
  787. {
  788. rcPane.bottom = pos == NULL ? rect.bottom : rcPane.top + nLength;
  790. if (pPaneI == pPane)
  791. break;
  793. rcPane.top = rcPane.bottom + nSplitterSize;
  794. }
  795. }
  797. return rcPane;
  798. }
  801. CRect CXTPDockingPaneSplitterContainer::_CalculateResultDockingRectSelf(CXTPDockingPaneBase* pPaneI, XTPDockingPaneDirection direction, CXTPDockingPaneBase* pNeighbour)
  802. {
  803. direction = GetDockingPaneManager()->GetRTLDirection(direction);
  805. ASSERT(pNeighbour);
  807. BOOL bAfter = (direction == xtpPaneDockRight || direction == xtpPaneDockBottom);
  809. // getting list of nonempty panes
  810. CXTPDockingPaneBaseList lst;
  811. POSITION posPanes = GetHeadPosition();
  812. while (posPanes)
  813. {
  814. CXTPDockingPaneBase* pPane = GetNext(posPanes);
  815. if (pPane->IsEmpty() || (pPane == pPaneI))
  816. continue;
  818. POSITION pos = lst.AddTail(pPane);
  820. if (pPane == pNeighbour)
  821. {
  822. if (bAfter)
  823. lst.InsertAfter(pos, pPaneI);
  824. else
  825. lst.InsertBefore(pos, pPaneI);
  826. }
  827. }
  829. CRect rcResult = _CalculateResultDockingRect(m_bHoriz, lst, m_rcWindow, pPaneI);
  831. m_pDockingSite->ClientToScreen(rcResult);
  833. return rcResult;
  835. }
  838. CRect CXTPDockingPaneSplitterContainer::_CalculateResultDockingRectChild(CXTPDockingPaneBase* pSplitter, CXTPDockingPaneBase* pPane, XTPDockingPaneDirection direction)
  839. {
  840. BOOL bAfter = (direction == xtpPaneDockRight || direction == xtpPaneDockBottom);
  841. BOOL bHoriz = (direction == xtpPaneDockLeft || direction == xtpPaneDockRight);
  843. CXTPDockingPaneBaseList lst;
  844. lst.AddTail(pSplitter);
  846. if (bAfter)
  847. lst.AddTail(pPane);
  848. else
  849. lst.AddHead(pPane);
  851. CRect rect = pSplitter->GetPaneWindowRect();
  853. return _CalculateResultDockingRect(bHoriz, lst, rect, pPane);
  855. }
  857. void CXTPDockingPaneSplitterContainer::DeletePane()
  858. {
  859. InternalRelease();
  860. }
  862. void CXTPDockingPaneSplitterContainer::GetMinMaxInfo(LPMINMAXINFO pMinMaxInfo) const
  863. {
  864. CXTPDockingPaneBase::GetMinMaxInfo(pMinMaxInfo);
  866. int nCount = 0;
  868. POSITION pos = GetHeadPosition();
  869. while (pos)
  870. {
  871. CXTPDockingPaneBase* pPane = GetNext(pos);
  872. if (pPane->IsEmpty())
  873. continue;
  875. nCount++;
  877. MINMAXINFO info;
  878. pPane->GetMinMaxInfo(&info);
  880. if (nCount == 1)
  881. {
  882. *pMinMaxInfo = info;
  884. }
  885. else
  886. {
  887. GetMinSize(pMinMaxInfo, m_bHoriz) += GetMinSize(&info, m_bHoriz);
  888. GetMaxSize(pMinMaxInfo, m_bHoriz) += GetMaxSize(&info, m_bHoriz);
  890. GetMinSize(pMinMaxInfo, !m_bHoriz) = max(GetMinSize(pMinMaxInfo, !m_bHoriz), GetMinSize(&info, !m_bHoriz));
  891. GetMaxSize(pMinMaxInfo, !m_bHoriz) = min(GetMaxSize(pMinMaxInfo, !m_bHoriz), GetMaxSize(&info, !m_bHoriz));
  892. }
  893. }
  895. if (nCount > 0)
  896. {
  897. GetMinSize(pMinMaxInfo, m_bHoriz) += GetPaintManager()->m_nSplitterSize * (nCount - 1);
  898. GetMaxSize(pMinMaxInfo, m_bHoriz) += GetPaintManager()->m_nSplitterSize * (nCount - 1);
  899. }
  900. }