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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneSidePanel.cpp：源码内容
  1. // XTPDockingPaneSidePanel.cpp : implementation of the CXTPDockingPaneSidePanel 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 "Resource.h"
  24. #include "Common/XTPVC80Helpers.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPColorManager.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPResourceManager.h"
  29. #include "Common/XTPToolTipContext.h"
  30. #include "TabManager/XTPTabManager.h"
  32. #include "XTPDockingPane.h"
  33. #include "XTPDockingPaneManager.h"
  34. #include "XTPDockingPaneTabbedContainer.h"
  35. #include "XTPDockingPaneSidePanel.h"
  36. #include "XTPDockingPaneLayout.h"
  37. #include "XTPDockingPaneContext.h"
  38. #include "XTPDockingPaneAutoHidePanel.h"
  40. #ifdef _DEBUG
  41. #define new DEBUG_NEW
  42. #undef THIS_FILE
  43. static char THIS_FILE[] = __FILE__;
  44. #endif
  46. #define TID_CHECKACTIVE 1
  47. #define TID_SLIDEIN 2
  48. #define TID_SLIDEOUT 3
  51. AFX_INLINE int ResetStepsCount()
  52. {
  53. if (CXTPDockingPaneAutoHideWnd::m_nAnimationInterval == 0)
  54. return 1;
  56. return max(1, CXTPDockingPaneAutoHideWnd::m_nAnimationDuration / CXTPDockingPaneAutoHideWnd::m_nAnimationInterval);
  57. }
  59. CXTPDockingPaneSidePanel::CXTPDockingPaneSidePanel(CXTPDockingPaneLayout* pLayout)
  60. : CXTPDockingPaneBaseContainer(xtpPaneTypeSidePanel, pLayout)
  61. {
  62. m_direction = xtpPaneDockLeft;
  63. m_bActive = FALSE;
  65. m_pCaptionButtons = new CXTPDockingPaneCaptionButtons();
  66. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_CLOSE, this));
  67. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_AUTOHIDE, this));
  69. m_bSlideOut = m_bExpanded = m_bCollapsed = FALSE;
  71. m_nSlideStep = 0;
  72. m_nStepsCount = ResetStepsCount();
  74. m_nDeactivationCount = 0;
  76. }
  78. CXTPDockingPaneSidePanel::~CXTPDockingPaneSidePanel()
  79. {
  81. }
  83. void CXTPDockingPaneSidePanel::DeletePane()
  84. {
  85. InternalRelease();
  86. }
  88. void CXTPDockingPaneSidePanel::OnFinalRelease()
  89. {
  90. if (m_hWnd != NULL)
  91. DestroyWindow();
  93. CCmdTarget::OnFinalRelease();
  94. }
  96. BOOL CXTPDockingPaneSidePanel::Init(CXTPDockingPaneBase* pBasePane, XTPDockingPaneDirection direction, CRect rc)
  97. {
  98. CXTPDockingPaneBaseList lstPanes;
  99. pBasePane->FindPane(xtpPaneTypeDockingPane, &lstPanes);
  100. if (lstPanes.GetCount() == 0)
  101. return FALSE;
  103. m_direction = direction;
  104. m_rcWindow = rc;
  105. CreateContainer();
  107. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)GetDockingPaneManager()->
  108. OnCreatePane(xtpPaneTypeTabbedContainer, m_pLayout);
  110. BOOL bInit = FALSE;
  112. POSITION pos = lstPanes.GetHeadPosition();
  113. while (pos)
  114. {
  115. CXTPDockingPane* pPane = (CXTPDockingPane*)lstPanes.GetNext(pos);
  117. if (pPane->GetContainer())
  118. {
  119. pPane->GetContainer()->RemovePane(pPane);
  120. }
  122. if (!bInit)
  123. {
  124. pContainer->Init((CXTPDockingPane*)pPane, this);
  125. }
  126. else
  127. {
  128. pContainer->_InsertPane(pPane, FALSE);
  129. }
  130. bInit = TRUE;
  131. }
  133. _InsertPane(pContainer);
  135. OnFocusChanged();
  137. m_nIdleFlags = 0;
  139. return TRUE;
  140. }
  142. void CXTPDockingPaneSidePanel::CreateContainer()
  143. {
  144. m_bInRecalcLayout = TRUE;
  146. if (!m_hWnd)
  147. {
  148. VERIFY(Create(m_rcWindow));
  149. }
  151. m_bInRecalcLayout = FALSE;
  152. }
  154. BOOL CXTPDockingPaneSidePanel::Create(CRect rc)
  155. {
  156. if (m_hWnd)
  157. return TRUE;
  159. if (!CreateEx(0, _T("XTPDockingPaneSidePanel"), _T(""), WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD, rc, GetDockingPaneManager()->GetSite(), 0))
  160. {
  161. return FALSE;
  162. }
  163. m_pCaptionButtons->CheckForMouseOver(CPoint(-1, -1));
  165. return TRUE;
  166. }
  168. void CXTPDockingPaneSidePanel::PostNcDestroy()
  169. {
  170. // prevent auto deleting
  171. }
  173. void CXTPDockingPaneSidePanel::RecalcLayout(BOOL /*bNotify*/)
  174. {
  175. if (m_bInRecalcLayout)
  176. return;
  178. m_bInRecalcLayout = TRUE;
  180. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  181. CWnd* pSite = GetDockingSite();
  182. CRect rcClient = pManager->GetClientPane()->GetPaneWindowRect();
  183. pSite->ScreenToClient(rcClient);
  185. OnSizeParentEx(pManager, pSite, rcClient);
  187. m_bInRecalcLayout = FALSE;
  190. }
  192. void CXTPDockingPaneSidePanel::OnFocusChanged()
  193. {
  194. CXTPDockingPaneTabbedContainer* pContainer = GetTopContainer();
  195. if (pContainer)
  196. {
  197. pContainer->OnFocusChanged();
  198. BOOL bActive = pContainer->IsActive();
  200. if (bActive != m_bActive)
  201. {
  202. m_bActive = bActive;
  203. InvalidatePane(FALSE);
  204. }
  205. }
  206. }
  208. void CXTPDockingPaneSidePanel::InvalidatePane(BOOL /*bSelectionChanged*/)
  209. {
  210. if (m_hWnd)
  211. {
  212. Invalidate(FALSE);
  213. }
  214. }
  216. CXTPDockingPaneTabbedContainer* CXTPDockingPaneSidePanel::GetTopContainer() const
  217. {
  218. return (CXTPDockingPaneTabbedContainer*)GetFirstPane();
  219. }
  221. void CXTPDockingPaneSidePanel::OnChildContainerChanged(CXTPDockingPaneBase* /*pContainer*/)
  222. {
  223. if (!m_hWnd)
  224. return;
  226. m_bExpanded = FALSE;
  227. m_nSlideStep = 0;
  229. if (IsEmpty())
  230. {
  231. DestroyWindow();
  232. }
  233. else
  234. {
  235. PostMessage(WM_IDLEUPDATECMDUI);
  236. }
  238. GetDockingPaneManager()->RecalcFrameLayout(NULL, TRUE);
  239. }
  241. void CXTPDockingPaneSidePanel::RemovePane(CXTPDockingPaneBase* pPane)
  242. {
  243. POSITION pos = m_lstPanes.Find(pPane);
  244. ASSERT(pos);
  246. m_lstPanes.RemoveAt(pos);
  248. if (IsEmpty())
  249. {
  250. DestroyWindow();
  251. }
  253. pPane->m_pParentContainer = NULL;
  254. }
  256. struct CXTPDockingPaneSidePanel::LENGTH
  257. {
  258. int nPos;
  259. int nSize;
  260. int nIndex;
  261. int nHeight;
  262. CXTPDockingPaneSidePanel* pPanel;
  264. int StartPos() {
  265. return nPos;
  266. }
  267. int EndPos() {
  268. return nPos + nSize;
  269. }
  270. };
  272. int _cdecl CXTPDockingPaneSidePanel::CompareLength(const void *arg1, const void *arg2)
  273. {
  274. int& dOffset1 = ((LENGTH*)arg1)->nPos;
  275. int& dOffset2 = ((LENGTH*)arg2)->nPos;
  276. return dOffset1 - dOffset2;
  277. }
  279. void CXTPDockingPaneSidePanel::SortLength(LENGTH* pLength, int nFirstIndex, int nLastIndex)
  280. {
  281. if (nLastIndex - nFirstIndex < 1)
  282. return;
  284. qsort(pLength + nFirstIndex, nLastIndex - nFirstIndex + 1, sizeof(LENGTH), CompareLength);
  286. for (int i = nFirstIndex; i <= nLastIndex; i++)
  287. {
  288. CXTPDockingPaneSidePanel* pPanel = pLength[i].pPanel;
  289. pPanel->m_nLengthIndex = i;
  290. }
  291. }
  293. void CXTPDockingPaneSidePanel::MovePanel(XTPDockingPaneDirection direction, CRect rect)
  294. {
  295. m_direction = direction;
  296. m_rcWindow = rect;
  298. m_pLayout->MoveToTail(this);
  299. RecalcLayout(FALSE);
  300. InvalidatePane(FALSE);
  301. }
  303. void CXTPDockingPaneSidePanel::MovePanel(LENGTH* pLength, CRect rect)
  304. {
  305. m_bInRecalcLayout = TRUE;
  307. if (m_bCollapsed && m_bSlideOut)
  308. {
  309. m_bSlideOut = FALSE;
  310. m_bExpanded = FALSE;
  311. m_nSlideStep = 0;
  312. KillTimer(TID_SLIDEOUT);
  313. OnAction(xtpPaneActionCollapsed);
  314. }
  316. BOOL bHorizontal = IsHorizontal();
  317. CSize sz = bHorizontal ? CSize(pLength->nSize, pLength->nHeight) : CSize(pLength->nHeight, pLength->nSize);
  319. int nMinHeight = GetMinHeight();
  321. if (m_bCollapsed && !m_bExpanded)
  322. {
  323. if (bHorizontal) sz.cy = nMinHeight; else sz.cx = nMinHeight;
  324. }
  325. else
  326. {
  327. if (bHorizontal) sz.cy = max(sz.cy, nMinHeight); else sz.cx = max(sz.cx, nMinHeight);
  328. }
  330. CPoint pt;
  332. switch (m_direction)
  333. {
  334. case xtpPaneDockLeft: pt = CPoint(rect.left, pLength->nPos + rect.top); break;
  335. case xtpPaneDockTop: pt = CPoint(rect.left + pLength->nPos, rect.top); break;
  336. case xtpPaneDockRight: pt = CPoint(rect.right - sz.cx, rect.top + pLength->nPos); break;
  337. case xtpPaneDockBottom: pt = CPoint(rect.left + pLength->nPos, rect.bottom - sz.cy); break;
  338. }
  340. SetWindowPos(&CWnd::wndTop, pt.x, pt.y, sz.cx, sz.cy, SWP_NOOWNERZORDER | SWP_SHOWWINDOW);
  342. CRect rcClient;
  343. GetClientRect(rcClient);
  345. GetPaintManager()->AdjustClientRect(this, rcClient);
  347. CXTPDockingPaneTabbedContainer* pContainer = GetTopContainer();
  348. if (pContainer)
  349. {
  350. pContainer->OnSizeParent(this, rcClient, NULL);
  351. }
  352. m_bInRecalcLayout = FALSE;
  353. }
  355. void CXTPDockingPaneSidePanel::OnSizeParentEx(CSidePanelArray& arrSide, CWnd* /*pParent*/, CRect rect)
  356. {
  357. XTPDockingPaneDirection direction = arrSide[0]->m_direction;
  358. BOOL bHorizontal = direction == xtpPaneDockTop || direction == xtpPaneDockBottom;
  360. int nCount = (int)arrSide.GetSize(), i, j;
  362. LENGTH* pLength = new LENGTH[nCount];
  364. for (i = 0; i < nCount; i++)
  365. {
  366. CXTPDockingPaneSidePanel* pPanel = arrSide[i];
  368. CRect rcPanel(pPanel->m_rcWindow);
  370. MINMAXINFO mmi;
  371. pPanel->GetMinMaxInfo(&mmi);
  373. if (rcPanel.Height() > mmi.ptMaxTrackSize.y) rcPanel.bottom = rcPanel.top + mmi.ptMaxTrackSize.y;
  374. if (rcPanel.Height() < mmi.ptMinTrackSize.y) rcPanel.bottom = rcPanel.top + mmi.ptMinTrackSize.y;
  375. if (rcPanel.Width() > mmi.ptMaxTrackSize.x) rcPanel.right = rcPanel.left + mmi.ptMaxTrackSize.x;
  376. if (rcPanel.Width() < mmi.ptMinTrackSize.x) rcPanel.right = rcPanel.left + mmi.ptMinTrackSize.x;
  378. pLength[i].nSize = bHorizontal ? rcPanel.Width() : rcPanel.Height();
  379. pLength[i].nPos = bHorizontal ? rcPanel.left : rcPanel.top;
  380. pLength[i].nIndex = i;
  381. pLength[i].pPanel = pPanel;
  383. pLength[i].nHeight = bHorizontal ? min(rect.Height(), rcPanel.Height()) : min(rect.Width(), rcPanel.Width());
  384. }
  386. SortLength(pLength, 0, nCount - 1);
  388. for (i = 1; i < nCount; i++)
  389. {
  390. int nLengthIndex = arrSide[i]->m_nLengthIndex;
  391. int nLeft = pLength[nLengthIndex].StartPos();
  392. int nRight = pLength[nLengthIndex].EndPos();
  394. for (j = nLengthIndex - 1; j >= 0; j--)
  395. {
  396. if (pLength[j].EndPos() > nLeft)
  397. {
  398. if (pLength[j].nIndex < i)
  399. {
  400. pLength[j].nPos = nLeft - pLength[j].nSize;
  401. nLeft = pLength[j].StartPos();
  402. }
  403. }
  404. else break;
  405. }
  406. SortLength(pLength, j + 1, nLengthIndex - 1);
  408. for (j = nLengthIndex + 1; j < nCount; j++)
  409. {
  410. if (pLength[j].StartPos() < nRight)
  411. {
  412. if (pLength[j].nIndex < i)
  413. {
  414. pLength[j].nPos = nRight;
  415. nRight = pLength[j].EndPos();
  416. }
  417. }
  418. else break;
  419. }
  420. SortLength(pLength, nLengthIndex + 1, j - 1);
  421. }
  424. int nBegin = 0;
  425. int nEnd = bHorizontal ? rect.Width() : rect.Height();
  426. int nRight = nEnd;
  427. int nLeft = nBegin;
  429. for (i = nCount - 1; i >= 0; i--)
  430. {
  431. if (pLength[i].EndPos() > nRight)
  432. {
  433. pLength[i].nPos = nRight - pLength[i].nSize;
  434. nRight = pLength[i].StartPos();
  435. }
  436. else break;
  437. }
  438. for (i = 0; i < nCount; i++)
  439. {
  440. if (pLength[i].StartPos() < nLeft)
  441. {
  442. pLength[i].nPos = nLeft;
  443. nLeft = pLength[i].EndPos();
  444. }
  445. else break;
  446. }
  448. int nTotal = pLength[nCount - 1].EndPos();
  449. int cxExtra = nTotal - nEnd;
  450. if (cxExtra > 0)
  451. {
  452. nLeft = 0;
  454. for (i = 0; i < nCount; i++)
  455. {
  456. pLength[i].nPos = nLeft;
  458. int cxAddExtra = nTotal == 0 ? cxExtra / nCount : cxExtra * pLength[i].nSize / nTotal;
  460. nTotal -= pLength[i].nSize;
  461. pLength[i].nSize -= cxAddExtra;
  463. cxExtra -= cxAddExtra;
  464. nLeft = pLength[i].EndPos();
  465. }
  466. }
  468. for (i = 0; i < nCount; i++)
  469. {
  470. int nIndex = pLength[i].nIndex;
  471. CXTPDockingPaneSidePanel* pPanel = arrSide[nIndex];
  473. pPanel->MovePanel(&pLength[i], rect);
  474. }
  476. delete[] pLength;
  477. }
  479. void CXTPDockingPaneSidePanel::OnSizeParentEx(CXTPDockingPaneManager* pManager, CWnd* pParent, CRect rect)
  480. {
  481. rect.DeflateRect(pManager->GetSideDockingMargin());
  483. CXTPDockingPaneBaseList& list = pManager->GetPaneStack();
  484. CSidePanelArray arrPanels[4];
  486. POSITION pos = list.GetHeadPosition();
  487. while (pos)
  488. {
  489. CXTPDockingPaneBase* pPane = list.GetNext(pos);
  490. if (pPane->GetType() == xtpPaneTypeSidePanel)
  491. {
  492. CXTPDockingPaneSidePanel* pPanel = (CXTPDockingPaneSidePanel*)pPane;
  494. if (!pPanel->IsEmpty())
  495. {
  496. arrPanels[pPanel->m_direction].Add(pPanel);
  497. }
  498. }
  499. }
  501. for (int i = 0; i < 4; i++)
  502. {
  503. if (arrPanels[i].GetSize() > 0)
  504. {
  505. OnSizeParentEx(arrPanels[i], pParent, rect);
  506. }
  507. }
  508. }
  510. void CXTPDockingPaneSidePanel::_InsertPane(CXTPDockingPaneBase* pPane)
  511. {
  512. ASSERT(m_lstPanes.IsEmpty());
  513. ASSERT(pPane->GetType() == xtpPaneTypeTabbedContainer);
  515. if (!m_hWnd && !m_pLayout->IsUserLayout() && pPane->GetPaneHwnd())
  516. {
  517. CreateContainer();
  518. }
  520. m_lstPanes.AddTail(pPane);
  522. pPane->SetParentContainer(this);
  523. pPane->SetDockingSite(this);
  525. pPane->OnParentContainerChanged(this);
  527. ((CXTPDockingPaneTabbedContainer*)pPane)->ShowTitle(FALSE);
  529. }
  531. void CXTPDockingPaneSidePanel::Copy(CXTPDockingPaneBase* pCloneBase, CXTPPaneToPaneMap* pMap, DWORD /*dwIgnoredOptions*/)
  532. {
  533. CXTPDockingPaneSidePanel* pClone = (CXTPDockingPaneSidePanel*)pCloneBase;
  535. ASSERT(pClone);
  536. if (!pClone)
  537. return;
  539. m_direction = pClone->m_direction;
  540. m_rcWindow = pClone->m_rcWindow;
  541. m_bCollapsed = pClone->m_bCollapsed;
  543. m_pDockingSite = GetDockingPaneManager()->GetSite();
  545. CXTPDockingPaneTabbedContainer* pContainer = pClone->GetTopContainer();
  546. if (pContainer)
  547. {
  548. _InsertPane(pContainer->Clone(m_pLayout, pMap));
  549. }
  550. }
  552. CString CXTPDockingPaneSidePanel::GetTitle() const
  553. {
  554. CXTPDockingPaneTabbedContainer* pContainer = GetTopContainer();
  555. if (!pContainer)
  556. return _T("");
  558. return pContainer->GetTitle();
  559. }
  561. BEGIN_MESSAGE_MAP(CXTPDockingPaneSidePanel, CMiniFrameWnd)
  562. ON_WM_PAINT()
  563. ON_WM_LBUTTONDOWN()
  564. ON_WM_TIMER()
  565. ON_WM_LBUTTONDBLCLK()
  566. ON_WM_RBUTTONUP()
  567. ON_WM_SIZE()
  568. ON_WM_MOUSEMOVE()
  569. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  570. ON_MESSAGE(WM_MOUSEHOVER, OnMouseHover)
  571. ON_WM_NCHITTEST_EX()
  572. ON_WM_NCLBUTTONDOWN()
  573. END_MESSAGE_MAP()
  575. void CXTPDockingPaneSidePanel::OnPaint()
  576. {
  577. CPaintDC dcPaint(this);
  578. CXTPClientRect rc(this);
  579. CXTPBufferDC dc(dcPaint);
  581. GetPaintManager()->DrawSidePanel(&dc, this, rc);
  582. }
  584. void CXTPDockingPaneSidePanel::OnSize(UINT nType, int cx, int cy)
  585. {
  586. CMiniFrameWnd::OnSize(nType, cx, cy);
  588. Invalidate(FALSE);
  589. }
  591. CXTPDockingPaneCaptionButton* CXTPDockingPaneSidePanel::HitTestCaptionButton(CPoint point) const
  592. {
  593. for (int i = 0; i < m_pCaptionButtons->GetSize(); i++)
  594. {
  595. CXTPDockingPaneCaptionButton* pButton = m_pCaptionButtons->GetAt(i);
  596. if (pButton->PtInRect(point))
  597. return pButton->IsEnabled() ? pButton : NULL;
  598. }
  599. return NULL;
  600. }
  602. void CXTPDockingPaneSidePanel::OnCaptionButtonClick(CXTPDockingPaneCaptionButton* pButton)
  603. {
  604. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  606. switch (pButton->GetID())
  607. {
  608. case XTP_IDS_DOCKINGPANE_CLOSE:
  609. {
  610. CXTPDockingPaneBaseList lstPanes;
  611. FindPane(xtpPaneTypeDockingPane, &lstPanes);
  613. POSITION pos = lstPanes.GetTailPosition();
  614. while (pos)
  615. {
  616. CXTPDockingPane* pPane = (CXTPDockingPane*)lstPanes.GetPrev(pos);
  618. if ((pPane->GetOptions() & xtpPaneNoCloseable) != 0)
  619. continue;
  621. pPane->InternalAddRef();
  623. if (!pManager->NotifyAction(xtpPaneActionClosing, pPane))
  624. {
  625. pPane->Close();
  626. pManager->NotifyAction(xtpPaneActionClosed, pPane);
  627. }
  629. pPane->InternalRelease();
  630. }
  631. }
  632. break;
  634. case XTP_IDS_DOCKINGPANE_AUTOHIDE:
  635. OnPinButtonClick();
  636. break;
  637. }
  638. }
  640. CXTPDockingPane* CXTPDockingPaneSidePanel::GetSelectedPane() const
  641. {
  642. if (GetTopContainer())
  643. return GetTopContainer()->GetSelected();
  644. return NULL;
  645. }
  647. BOOL CXTPDockingPaneSidePanel::IsCaptionButtonVisible(CXTPDockingPaneCaptionButton* pButton)
  648. {
  649. CXTPDockingPane* pSelectedPane = GetSelectedPane();
  651. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_CLOSE)
  652. return pSelectedPane && ((pSelectedPane->GetOptions() & xtpPaneNoCloseable) == 0);
  654. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_AUTOHIDE)
  655. {
  656. pButton->SetState(m_bCollapsed ? xtpPanePinPushed : 0);
  657. return pSelectedPane && ((pSelectedPane->GetOptions() & xtpPaneNoHideable) == 0);
  658. }
  660. return TRUE;
  661. }
  664. void CXTPDockingPaneSidePanel::_RestoreFocus()
  665. {
  666. CXTPDockingPaneTabbedContainer* pContainer = GetTopContainer();
  667. if (pContainer) pContainer->_RestoreFocus();
  668. }
  670. void CXTPDockingPaneSidePanel::OnCaptionLButtonDown(CPoint point)
  671. {
  672. if (GetKeyState(VK_LBUTTON) < 0)
  673. {
  674. if (OnAction(xtpPaneActionDragging))
  675. return;
  677. CXTPDockingPaneContext* pContext = GetDockingPaneManager()->GetDockingContext();
  679. CRect rcWindow;
  680. GetWindowRect(rcWindow);
  682. pContext->Drag(GetTopContainer(), point, rcWindow);
  683. }
  684. }
  686. void CXTPDockingPaneSidePanel::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  687. {
  688. if (m_bCollapsed && !m_bExpanded)
  689. {
  690. Expand();
  691. GetCursorPos(&point);
  692. ScreenToClient(&point);
  693. InvalidatePane(FALSE);
  694. UpdateWindow();
  695. }
  697. _RestoreFocus();
  699. CXTPDockingPaneCaptionButton* pButton = HitTestCaptionButton(point);
  701. if (pButton)
  702. {
  703. if (pButton->Click(this, point))
  704. {
  705. OnCaptionButtonClick(pButton);
  706. }
  708. return;
  709. }
  711. CRect rcCaption = GetPaintManager()->GetPaneCaptionRect(this);
  713. if (rcCaption.PtInRect(point))
  714. {
  715. ClientToScreen(&point);
  716. OnCaptionLButtonDown(point);
  717. }
  718. }
  720. void CXTPDockingPaneSidePanel::OnLButtonDblClk(UINT /*nFlags*/, CPoint point)
  721. {
  722. if (HitTestCaptionButton(point))
  723. return;
  725. CRect rcCaption = GetPaintManager()->GetPaneCaptionRect(this);
  727. if (rcCaption.PtInRect(point))
  728. {
  729. GetDockingPaneManager()->ToggleDocking(GetTopContainer());
  730. }
  731. }
  734. void CXTPDockingPaneSidePanel::OnMouseMove(UINT nFlags, CPoint point)
  735. {
  736. m_pCaptionButtons->CheckForMouseOver(point);
  738. if (m_bCollapsed && point != CPoint(-1, -1) && !m_bExpanded)
  739. {
  740. TRACKMOUSEEVENT tme =
  741. {
  742. sizeof(TRACKMOUSEEVENT), TME_HOVER, m_hWnd, CXTPDockingPaneAutoHideWnd::m_nMouseHoverDelay
  743. };
  744. _TrackMouseEvent(&tme);
  745. }
  747. CWnd::OnMouseMove(nFlags, point);
  748. }
  750. LRESULT CXTPDockingPaneSidePanel::OnMouseHover(WPARAM, LPARAM)
  751. {
  752. if (m_bCollapsed)
  753. {
  754. if (!CXTPDrawHelpers::IsTopParentActive(m_hWnd))
  755. return 1;
  757. Expand();
  758. }
  760. return 1;
  761. }
  763. void CXTPDockingPaneSidePanel::OnMouseLeave()
  764. {
  765. OnMouseMove(0, CPoint(-1, -1));
  766. }
  768. void CXTPDockingPaneSidePanel::OnPinButtonClick()
  769. {
  770. if (!m_hWnd)
  771. return;
  773. BOOL bPinning = m_bCollapsed;
  775. if (OnAction(bPinning ? xtpPaneActionPinning : xtpPaneActionUnpinning))
  776. return;
  778. if (!m_bCollapsed)
  779. {
  780. Collapse(TRUE);
  781. }
  782. else
  783. {
  784. if (m_nStepsCount != m_nSlideStep)
  785. {
  786. SetWindowPos(0, 0, 0, m_rcWindow.Width(), m_rcWindow.Height(), SWP_NOZORDER | SWP_NOMOVE);
  787. }
  788. m_bCollapsed = FALSE;
  789. m_bExpanded = FALSE;
  791. KillTimer(TID_CHECKACTIVE);
  792. KillTimer(TID_SLIDEOUT);
  794. }
  795. InvalidatePane(FALSE);
  797. OnAction(bPinning ? xtpPaneActionPinned : xtpPaneActionUnpinned);
  798. }
  800. int CXTPDockingPaneSidePanel::GetMinHeight()
  801. {
  802. CRect rc = GetPaintManager()->GetPaneCaptionRect(this);
  803. return 2 + (IsHorizontal() ? rc.Height() : rc.Width());
  804. }
  806. void CXTPDockingPaneSidePanel::DoSlideStep(BOOL bActivate)
  807. {
  808. m_bInRecalcLayout = TRUE;
  810. int nMinHeight = GetMinHeight();
  811. BOOL bHorizontal = IsHorizontal();
  813. CXTPWindowRect rc(this);
  814. int nSize = max(nMinHeight, m_nSlideStep * ( bHorizontal ? m_rcWindow.Height() : m_rcWindow.Width()) / m_nStepsCount);
  816. switch (m_direction)
  817. {
  818. case xtpPaneDockLeft: rc.right = rc.left + nSize; break;
  819. case xtpPaneDockTop: rc.bottom = rc.top + nSize; break;
  820. case xtpPaneDockRight: rc.left = rc.right - nSize; break;
  821. case xtpPaneDockBottom: rc.top = rc.bottom - nSize; break;
  822. }
  824. GetParent()->ScreenToClient(rc);
  826. SetWindowPos(&CWnd::wndTop, rc.left, rc.top, rc.Width(), rc.Height(), (!bActivate ? SWP_NOZORDER | SWP_NOACTIVATE : SWP_NOACTIVATE));
  827. Invalidate(FALSE);
  829. CRect rcClient;
  830. GetClientRect(rcClient);
  832. GetPaintManager()->AdjustClientRect(this, rcClient);
  834. CXTPDockingPaneTabbedContainer* pContainer = GetTopContainer();
  835. if (pContainer)
  836. {
  837. pContainer->OnSizeParent(this, rcClient, NULL);
  838. }
  841. m_bInRecalcLayout = FALSE;
  842. }
  845. void CXTPDockingPaneSidePanel::Expand()
  846. {
  847. if (m_bCollapsed)
  848. {
  849. if (m_bSlideOut)
  850. {
  851. m_bSlideOut = FALSE;
  852. m_bExpanded = FALSE;
  853. KillTimer(TID_SLIDEOUT);
  854. OnAction(xtpPaneActionCollapsed);
  855. }
  857. if (OnAction(xtpPaneActionExpanding))
  858. return;
  860. m_bExpanded = TRUE;
  861. m_nSlideStep = m_nStepsCount = ResetStepsCount();
  862. DoSlideStep(TRUE);
  864. m_nDeactivationCount = 8;
  865. SetTimer(TID_CHECKACTIVE, 100, NULL);
  867. OnAction(xtpPaneActionExpanded);
  868. }
  869. }
  871. void CXTPDockingPaneSidePanel::Collapse(BOOL bDelay)
  872. {
  873. m_nSlideStep = m_nStepsCount = ResetStepsCount();
  875. m_bCollapsed = TRUE;
  876. m_bExpanded = TRUE;
  878. if (!bDelay)
  879. {
  880. if (!OnAction(xtpPaneActionCollapsing))
  881. {
  882. m_bExpanded = FALSE;
  883. m_nSlideStep = 0;
  884. DoSlideStep(FALSE);
  885. KillTimer(TID_SLIDEOUT);
  886. KillTimer(TID_CHECKACTIVE);
  887. OnAction(xtpPaneActionCollapsed);
  888. return;
  889. }
  890. }
  892. if (m_bSlideOut)
  893. {
  894. m_bSlideOut = FALSE;
  895. KillTimer(TID_SLIDEOUT);
  896. OnAction(xtpPaneActionCollapsed);
  897. }
  899. m_nDeactivationCount = 6;
  900. SetTimer(TID_CHECKACTIVE, 100, NULL);
  901. }
  903. void CXTPDockingPaneSidePanel::OnTimer(UINT_PTR nIDEvent)
  904. {
  905. if (nIDEvent == TID_SLIDEOUT && m_bSlideOut)
  906. {
  907. m_nSlideStep--;
  909. if (m_nSlideStep > -1)
  910. DoSlideStep();
  911. else
  912. {
  913. m_bSlideOut = FALSE;
  914. m_bExpanded = FALSE;
  915. KillTimer(TID_SLIDEOUT);
  916. OnAction(xtpPaneActionCollapsed);
  917. }
  918. }
  920. if (nIDEvent == TID_CHECKACTIVE)
  921. {
  922. CPoint pt;
  923. GetCursorPos(&pt);
  925. CWnd* pFocus = GetFocus();
  926. BOOL bActive = (pFocus->GetSafeHwnd() && (pFocus == this || IsChild(pFocus)));
  928. if (!bActive && !m_bSlideOut && !CXTPWindowRect(this).PtInRect(pt) && ::GetCapture() == NULL)
  929. {
  930. if (--m_nDeactivationCount <= 0)
  931. {
  932. if (OnAction(xtpPaneActionCollapsing))
  933. {
  934. m_nDeactivationCount = 6;
  935. return;
  936. }
  938. m_bSlideOut = TRUE;
  939. SetTimer(TID_SLIDEOUT, CXTPDockingPaneAutoHideWnd::m_nAnimationInterval, NULL);
  941. KillTimer(TID_CHECKACTIVE);
  942. }
  943. }
  944. }
  946. CMiniFrameWnd::OnTimer(nIDEvent);
  947. }
  949. void CXTPDockingPaneSidePanel::GetMinMaxInfo(LPMINMAXINFO pMinMaxInfo) const
  950. {
  951. CXTPDockingPaneBase::GetMinMaxInfo(pMinMaxInfo);
  953. if (IsEmpty())
  954. return;
  956. GetTopContainer()->GetMinMaxInfo(pMinMaxInfo);
  958. CSize szBorder(6, 6);
  960. int nCaptionHeight = GetPaintManager()->GetCaptionHeight();
  961. if (IsHorizontal()) szBorder.cy += nCaptionHeight; else szBorder.cx += nCaptionHeight;
  963. pMinMaxInfo->ptMinTrackSize.x += szBorder.cx;
  964. pMinMaxInfo->ptMinTrackSize.y += szBorder.cy;
  966. pMinMaxInfo->ptMaxTrackSize.x += szBorder.cx;
  967. pMinMaxInfo->ptMaxTrackSize.y += szBorder.cy;
  969. pMinMaxInfo->ptMinTrackSize.x = max(pMinMaxInfo->ptMinTrackSize.x, nCaptionHeight * 2);
  970. pMinMaxInfo->ptMinTrackSize.y = max(pMinMaxInfo->ptMinTrackSize.y, nCaptionHeight * 2);
  972. }
  974. BOOL CXTPDockingPaneSidePanel::IsHorizontal() const
  975. {
  976. return m_direction == xtpPaneDockTop || m_direction == xtpPaneDockBottom;
  977. }
  979. BOOL CXTPDockingPaneSidePanel::IsResizable(int nHit)
  980. {
  981. if (IsHorizontal())
  982. {
  983. if (nHit == HTTOP) return m_direction == xtpPaneDockBottom;
  984. if (nHit == HTBOTTOM) return m_direction == xtpPaneDockTop;
  985. if (nHit == HTLEFT || nHit == HTRIGHT) return TRUE;
  986. }
  987. else
  988. {
  989. if (nHit == HTLEFT) return m_direction == xtpPaneDockRight;
  990. if (nHit == HTRIGHT) return m_direction == xtpPaneDockLeft;
  991. if (nHit == HTTOP || nHit == HTBOTTOM) return TRUE;
  992. }
  994. return FALSE;
  995. }
  997. void CXTPDockingPaneSidePanel::OnNcLButtonDown(UINT nHitTest, CPoint point)
  998. {
  999. if (nHitTest >= HTSIZEFIRST && nHitTest <= HTSIZELAST)
  1000. {
  1001. _RestoreFocus();
  1002. Expand();
  1003. SetCapture();
  1004. m_pLayout->MoveToTail(this);
  1006. CXTPWindowRect rcWindow(this);
  1008. CRect rcClient(GetDockingPaneManager()->GetClientPane()->GetPaneWindowRect());
  1009. rcClient.DeflateRect(GetDockingPaneManager()->GetSideDockingMargin());
  1011. rcWindow.OffsetRect(-rcClient.TopLeft());
  1014. MINMAXINFO mmi;
  1015. GetMinMaxInfo(&mmi);
  1017. BOOL bResizeTop = nHitTest == HTTOP || nHitTest == HTTOPLEFT || nHitTest == HTTOPRIGHT;
  1018. BOOL bResizeBottom = nHitTest == HTBOTTOM || nHitTest == HTBOTTOMLEFT || nHitTest == HTBOTTOMRIGHT;
  1019. BOOL bResizeRight = nHitTest == HTRIGHT || nHitTest == HTTOPRIGHT || nHitTest == HTBOTTOMRIGHT;
  1020. BOOL bResizeLeft = nHitTest == HTLEFT || nHitTest == HTTOPLEFT || nHitTest == HTBOTTOMLEFT;
  1022. while (::GetCapture() == m_hWnd)
  1023. {
  1024. MSG msg;
  1026. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  1027. {
  1028. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  1029. return;
  1030. DispatchMessage(&msg);
  1031. }
  1033. if (!GetMessage(&msg, NULL, 0, 0))
  1034. break;
  1036. if (msg.message == WM_MOUSEMOVE)
  1037. {
  1038. CPoint pt = CPoint(msg.lParam);
  1039. ClientToScreen(&pt);
  1041. CPoint ptOffset = pt - point;
  1042. point = pt;
  1044. if (bResizeTop) rcWindow.top += ptOffset.y;
  1045. if (bResizeBottom) rcWindow.bottom += ptOffset.y;
  1046. if (bResizeRight) rcWindow.right += ptOffset.x;
  1047. if (bResizeLeft) rcWindow.left += ptOffset.x;
  1049. m_rcWindow = rcWindow;
  1051. if (m_rcWindow.Height() > mmi.ptMaxTrackSize.y)
  1052. {
  1053. if (bResizeTop) m_rcWindow.top = m_rcWindow.bottom - mmi.ptMaxTrackSize.y; else m_rcWindow.bottom = m_rcWindow.top + mmi.ptMaxTrackSize.y;
  1054. }
  1055. if (m_rcWindow.Height() < mmi.ptMinTrackSize.y)
  1056. {
  1057. if (bResizeTop) m_rcWindow.top = m_rcWindow.bottom - mmi.ptMinTrackSize.y; else m_rcWindow.bottom = m_rcWindow.top + mmi.ptMinTrackSize.y;
  1058. }
  1060. if (m_rcWindow.Width() > mmi.ptMaxTrackSize.x)
  1061. {
  1062. if (bResizeLeft) m_rcWindow.left = m_rcWindow.right - mmi.ptMaxTrackSize.x; else m_rcWindow.right = m_rcWindow.left + mmi.ptMaxTrackSize.x;
  1063. }
  1064. if (m_rcWindow.Width() < mmi.ptMinTrackSize.x)
  1065. {
  1066. if (bResizeLeft) m_rcWindow.left = m_rcWindow.right - mmi.ptMinTrackSize.x; else m_rcWindow.right = m_rcWindow.left + mmi.ptMinTrackSize.x;
  1067. }
  1069. RecalcLayout(FALSE);
  1070. }
  1071. else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) break;
  1072. else if (msg.message == WM_LBUTTONUP) break;
  1073. else ::DispatchMessage(&msg);
  1074. }
  1076. if (CWnd::GetCapture() == this) ReleaseCapture();
  1077. }
  1078. }
  1080. LRESULT CXTPDockingPaneSidePanel::OnNcHitTest(CPoint point)
  1081. {
  1082. if (m_bCollapsed && !m_bExpanded)
  1083. return HTCLIENT;
  1085. CXTPWindowRect rcWindow(this);
  1086. CRect rcBorders = rcWindow;
  1087. rcBorders.DeflateRect(3, 3);
  1089. if (rcWindow.PtInRect(point) && !rcBorders.PtInRect(point))
  1090. {
  1091. rcBorders.DeflateRect(8, 8);
  1093. int ht = 0;
  1095. if (point.y < rcBorders.top && IsResizable(HTTOP))
  1096. ht = (HTTOP - HTSIZEFIRST + 1);
  1097. else if (point.y >= rcBorders.bottom  && IsResizable(HTBOTTOM))
  1098. ht = (HTBOTTOM - HTSIZEFIRST + 1);
  1100. if (point.x < rcBorders.left && IsResizable(HTLEFT))
  1101. ht += (HTLEFT - HTSIZEFIRST + 1);
  1102. else if (point.x >= rcBorders.right  && IsResizable(HTRIGHT))
  1103. ht += (HTRIGHT - HTSIZEFIRST + 1);
  1105. return (LRESULT)(ht + HTSIZEFIRST - 1);
  1106. }
  1108. return HTCLIENT;
  1109. }
  1111. INT_PTR CXTPDockingPaneSidePanel::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1112. {
  1114. ASSERT_VALID(this);
  1115. ASSERT(::IsWindow(m_hWnd));
  1117. // check child windows first by calling CControlBar
  1118. INT_PTR nHit = CWnd::OnToolHitTest(point, pTI);
  1119. if (nHit != -1)
  1120. return nHit;
  1122. CXTPDockingPaneCaptionButton* pButton = HitTestCaptionButton(point);
  1124. if (pButton)
  1125. {
  1126. nHit = (INT_PTR)pButton->GetID();
  1127. CString strTip;
  1128. XTPResourceManager()->LoadString(&strTip, (UINT)nHit);
  1130. if (strTip.GetLength() == 0)
  1131. return -1;
  1133. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, pButton->GetRect(), nHit, strTip);
  1135. return nHit;
  1136. }
  1138. return -1;
  1139. }
  1141. BOOL CXTPDockingPaneSidePanel::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1142. {
  1143. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  1145. if (pManager)
  1146. {
  1147. pManager->GetToolTipContext()->FilterToolTipMessage(this, message, wParam, lParam);
  1148. }
  1150. return CMiniFrameWnd::OnWndMsg(message, wParam, lParam, pResult);
  1151. }
  1153. void CXTPDockingPaneSidePanel::OnRButtonUp(UINT /*nFlags*/, CPoint point)
  1154. {
  1155. XTP_DOCKINGPANE_CLICK menu;
  1156. menu.pPane = GetSelectedPane();
  1157. menu.pContainer = this;
  1158. ClientToScreen(&point);
  1159. menu.pt = point;
  1160. menu.rcExclude.SetRectEmpty();
  1162. if (GetDockingPaneManager()->NotifyOwner(XTP_DPN_CONTEXTMENU, (LPARAM)&menu))
  1163. return;
  1164. }