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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneAutoHidePanel.cpp：源码内容
  1. // XTPDockingPaneAutoHidePanel.cpp : implementation of the CXTPDockingPaneAutoHidePanel 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/XTPVC80Helpers.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPColorManager.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPResourceManager.h"
  29. #include "TabManager/XTPTabManager.h"
  31. #include "XTPDockingPane.h"
  32. #include "XTPDockingPaneManager.h"
  33. #include "XTPDockingPaneTabbedContainer.h"
  34. #include "XTPDockingPaneAutoHidePanel.h"
  35. #include "XTPDockingPaneLayout.h"
  36. #include "XTPDockingPaneSplitterContainer.h"
  38. #ifdef _DEBUG
  39. #define new DEBUG_NEW
  40. #undef THIS_FILE
  41. static char THIS_FILE[] = __FILE__;
  42. #endif
  44. #define TID_CHECKACTIVE 1
  45. #define TID_CLOSE 4
  46. #define TID_SLIDEIN 2
  47. #define TID_SLIDEOUT 3
  49. double CXTPDockingPaneAutoHideWnd::m_dAnimationDelay = -1;
  50. int CXTPDockingPaneAutoHideWnd::m_nAnimationInterval = 16;                 // smother animation
  51. int CXTPDockingPaneAutoHideWnd::m_nAnimationDuration = 128;                // fast slide completion
  52. BOOL CXTPDockingPaneAutoHidePanel::m_bCloseActiveWindow = TRUE;
  53. DWORD CXTPDockingPaneAutoHideWnd::m_nMouseHoverDelay = HOVER_DEFAULT;
  54. UINT CXTPDockingPaneAutoHideWnd::m_nInactiveCollapseDelay = 100;
  56. void CXTPDockingPaneAutoHideWnd::GetMinMaxInfo (LPMINMAXINFO pMinMaxInfo, BOOL bIncludeSplitter /*= TRUE*/) const
  57. {
  58. ZeroMemory(pMinMaxInfo, sizeof(MINMAXINFO));
  59. pMinMaxInfo->ptMaxTrackSize = CPoint(32000, 32000);
  61. if (!m_pPane || !m_pPane->m_pSelectedPane)
  62. return;
  64. m_pPane->m_pSelectedPane->GetMinMaxInfo(pMinMaxInfo);
  65. m_pPane->AdjustMinMaxInfoClientRect(pMinMaxInfo, TRUE);
  67. if (!bIncludeSplitter)
  68. return;
  70. if (m_direction == xtpPaneDockLeft || m_direction == xtpPaneDockRight)
  71. {
  72. pMinMaxInfo->ptMinTrackSize.x += 4;
  73. pMinMaxInfo->ptMaxTrackSize.x += 4;
  74. }
  75. else
  76. {
  77. pMinMaxInfo->ptMinTrackSize.y += 4;
  78. pMinMaxInfo->ptMaxTrackSize.y += 4;
  79. }
  80. }
  82. CXTPDockingPaneAutoHideWnd::CXTPDockingPaneAutoHideWnd(CXTPDockingPaneAutoHidePanel* pPanel, CXTPDockingPaneTabbedContainer* pPane)
  83. : m_pPanel(pPanel), m_pPane(pPane)
  84. {
  85. ASSERT(pPane);
  86. if (!pPane)
  87. return;
  89. ASSERT(pPane->m_pSelectedPane);
  90. if (!pPane->m_pSelectedPane)
  91. return;
  93. m_bTracking = FALSE;
  95. m_direction = m_pPanel->GetDirection();
  96. m_bHoriz = (m_direction == xtpPaneDockTop || m_direction == xtpPaneDockBottom);
  97. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  99. CWnd* pSite = pManager->GetSite();
  100. CXTPDockingPaneBase* pTopPane = pManager->GetTopPane();
  102. CRect rcClient = pTopPane->GetPaneWindowRect();
  104. MINMAXINFO mmInfo;
  105. GetMinMaxInfo(&mmInfo);
  107. CSize szDocking = CSize(
  108. max(mmInfo.ptMinTrackSize.x, min(mmInfo.ptMaxTrackSize.x, pPane->m_pSelectedPane->m_szDocking.cx + 4)),
  109. max(mmInfo.ptMinTrackSize.y, min(mmInfo.ptMaxTrackSize.y, pPane->m_pSelectedPane->m_szDocking.cy + 4)));
  112. switch (pManager->GetRTLDirection(m_direction))
  113. {
  114. case xtpPaneDockLeft:
  115. rcClient.right = rcClient.left + szDocking.cx;
  116. break;
  118. case xtpPaneDockRight:
  119. rcClient.left = rcClient.right - szDocking.cx;
  120. break;
  122. case xtpPaneDockTop:
  123. rcClient.bottom = rcClient.top + szDocking.cy;
  124. break;
  126. case xtpPaneDockBottom:
  127. rcClient.top = rcClient.bottom - szDocking.cy;
  128. break;
  129. }
  131. pSite->ScreenToClient(&rcClient);
  133. CRect rcAvail, rc;
  134. BOOL bResizable = GetAvailableRect(rcAvail, rc);
  136. HCURSOR hCursor = !bResizable || pManager->IsSplittersLocked() ? AfxGetApp()->LoadStandardCursor(IDC_ARROW) :
  137. XTPResourceManager()->LoadCursor(!m_bHoriz ? XTP_IDC_HSPLITBAR :  XTP_IDC_VSPLITBAR);
  138. m_rcWindow = rcClient;
  140. CreateEx(pSite->GetExStyle() & WS_EX_LAYOUTRTL, AfxRegisterWndClass(0, hCursor), _T(""),
  141. WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, rcClient, pSite, 0);
  144. m_nSlideStep = 0;
  145. m_nStepsCount = 1;
  147. if (m_dAnimationDelay != .0 && m_nAnimationInterval != 0)
  148. {
  149. if (m_dAnimationDelay > 0)
  150. {
  151. // keep the animation delay behaviour relative to 50 ms frame interval as per original
  152. // implementation
  153. m_nStepsCount = int((m_bHoriz ? m_rcWindow.Width() : m_rcWindow.Height()) * m_dAnimationDelay * 50 / m_nAnimationInterval);
  154. }
  155. else
  156. {
  157. m_nStepsCount = m_nAnimationDuration/m_nAnimationInterval;
  158. }
  159. }
  160. if (m_nStepsCount < 1) m_nStepsCount = 1;
  163. m_bSlideOut = FALSE;
  164. if (m_nStepsCount > 1)
  165. SetTimer(TID_SLIDEIN, m_nAnimationInterval, NULL);
  166. DoSlideStep();
  167. m_pPane->ShowWindow(SW_SHOW);
  169. SetTimer(TID_CHECKACTIVE, m_nInactiveCollapseDelay, NULL);
  171. m_nDeactivationCount = 6;
  173. }
  175. CXTPDockingPaneManager* CXTPDockingPaneAutoHideWnd::GetDockingPaneManager() const
  176. {
  177. ASSERT(m_pPanel);
  178. return m_pPanel ? m_pPanel->GetDockingPaneManager() : NULL;
  179. }
  182. void CXTPDockingPaneAutoHideWnd::DoSlideStep()
  183. {
  184. CRect rc(m_rcWindow);
  186. switch (m_direction)
  187. {
  188. case xtpPaneDockLeft:
  189. rc.right = rc.left + (m_nSlideStep + 1) * m_rcWindow.Width() / m_nStepsCount;
  190. break;
  192. case xtpPaneDockRight:
  193. rc.left = rc.right - (m_nSlideStep + 1) * m_rcWindow.Width() / m_nStepsCount;
  194. break;
  196. case xtpPaneDockTop:
  197. rc.bottom = rc.top + (m_nSlideStep + 1) * m_rcWindow.Height() / m_nStepsCount;
  198. break;
  200. case xtpPaneDockBottom:
  201. rc.top = rc.bottom - (m_nSlideStep + 1) * m_rcWindow.Height() / m_nStepsCount;
  202. break;
  203. }
  204. SetWindowPos(&CWnd::wndTop, rc.left, rc.top, rc.Width(), rc.Height(), SWP_SHOWWINDOW | SWP_NOOWNERZORDER | SWP_NOACTIVATE);
  205. Invalidate(FALSE);
  206. }
  208. void CXTPDockingPaneAutoHideWnd::RecalcLayout(BOOL /*bNotify*/)
  209. {
  210. if (!m_pPane || !m_pPane->GetSafeHwnd())
  211. return;
  213. AFX_SIZEPARENTPARAMS layout;
  214. layout.bStretch = TRUE;
  215. GetClientRect(&layout.rect);
  216. CRect rcClient(layout.rect);
  217. layout.hDWP = ::BeginDeferWindowPos(8); // reasonable guess
  219. CRect rcPane(CPoint(0, 0), m_rcWindow.Size());
  221. switch (m_direction)
  222. {
  223. case xtpPaneDockLeft:
  224. rcPane.OffsetRect(- m_rcWindow.Width() + rcClient.Width(), 0);
  225. rcPane.right -= 4;
  226. break;
  228. case xtpPaneDockTop:
  229. rcPane.OffsetRect(0, - m_rcWindow.Height() + rcClient.Height());
  230. rcPane.bottom -= 4;
  231. break;
  233. case xtpPaneDockRight:
  234. rcPane.left += 4;
  235. break;
  237. case xtpPaneDockBottom:
  238. rcPane.top += 4;
  239. break;
  240. }
  242. m_pPane->OnSizeParent(this, rcPane, &layout);
  244. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  245. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  246. }
  248. IMPLEMENT_DYNAMIC(CXTPDockingPaneAutoHideWnd, CMiniFrameWnd)
  250. BEGIN_MESSAGE_MAP(CXTPDockingPaneAutoHideWnd, CMiniFrameWnd)
  251. ON_WM_PAINT()
  252. ON_WM_TIMER()
  253. ON_WM_CLOSE()
  254. ON_WM_LBUTTONDOWN()
  255. ON_WM_MOUSEMOVE()
  256. ON_WM_ERASEBKGND()
  257. END_MESSAGE_MAP()
  260. void CXTPDockingPaneAutoHideWnd::CloseWindow()
  261. {
  262. if (!IsWindow(m_hWnd))
  263. return;
  265. ShowWindow(SW_HIDE);
  267. if (m_pPane && m_pPane->GetSafeHwnd() && m_pPane->GetParent() == this)
  268. {
  269. m_pPane->ShowWindow(SW_HIDE);
  270. m_pPane->SetDockingSite(GetDockingPaneManager()->GetSite());
  271. }
  272. m_pPane = 0;
  274. if (m_pPanel && m_pPanel->m_pActiveWnd == this)
  275. m_pPanel->m_pActiveWnd = 0;
  277. PostMessage(WM_CLOSE);
  278. }
  280. void CXTPDockingPaneAutoHideWnd::PostNcDestroy()
  281. {
  282. if (m_pPanel && m_pPanel->m_pActiveWnd == this)
  283. m_pPanel->m_pActiveWnd = 0;
  285. if (m_dwRef <= 1)
  286. {
  287. delete this;
  288. }
  289. else
  290. {
  291. InternalRelease();
  292. }
  293. }
  295. void CXTPDockingPaneAutoHideWnd::OnTimer(UINT_PTR nIDEvent)
  296. {
  297. if (nIDEvent == TID_CLOSE)
  298. {
  299. CloseWindow();
  300. return;
  301. }
  303. if (!m_pPane)
  304. return;
  306. if (m_pPanel && m_pPanel->m_pActiveWnd != this)
  307. return;
  309. if (nIDEvent == TID_CHECKACTIVE)
  310. {
  311. if (m_bTracking)
  312. return;
  314. CPoint pt;
  315. GetCursorPos(&pt);
  316. if (!m_pPane->IsActive() && !CXTPWindowRect(this).PtInRect(pt) && !CXTPWindowRect(m_pPanel).PtInRect(pt))
  317. {
  318. if (!m_bSlideOut)
  319. {
  320. if (--m_nDeactivationCount <= 0)
  321. {
  322. m_nDeactivationCount = 0;
  324. InternalAddRef();
  326. if (!CXTPDockingPaneAutoHidePanel::m_bCloseActiveWindow || GetDockingPaneManager()->NotifyAction(xtpPaneActionCollapsing, m_pPane->GetSelected()))
  327. {
  328. m_nDeactivationCount = 6;
  329. }
  330. else
  331. {
  332. m_bSlideOut = TRUE;
  333. if (m_hWnd) SetTimer(TID_SLIDEOUT, m_nAnimationInterval, NULL);
  334. }
  336. InternalRelease();
  337. }
  338. }
  339. }
  340. else
  341. {
  342. m_nDeactivationCount = 6;
  343. if (m_bSlideOut)
  344. {
  345. m_bSlideOut = FALSE;
  346. KillTimer(TID_SLIDEOUT);
  347. SetTimer(TID_SLIDEIN, m_nAnimationInterval, NULL);
  348. }
  349. }
  350. return;
  351. }
  353. if (nIDEvent == TID_SLIDEOUT && m_bSlideOut)
  354. {
  355. m_nSlideStep--;
  356. if (m_nSlideStep > -1) DoSlideStep();
  357. else
  358. {
  359. m_bSlideOut = FALSE;
  360. KillTimer(TID_SLIDEOUT);
  362. InternalAddRef();
  364. GetDockingPaneManager()->NotifyAction(xtpPaneActionCollapsed, m_pPane->GetSelected());
  365. CloseWindow();
  367. InternalRelease();
  368. }
  369. return;
  370. }
  372. if (nIDEvent == TID_SLIDEIN && !m_bSlideOut)
  373. {
  374. m_nSlideStep++;
  375. if (m_nSlideStep < m_nStepsCount) DoSlideStep();
  376. else
  377. {
  378. m_nSlideStep = m_nStepsCount - 1;
  379. KillTimer(TID_SLIDEIN);
  381. GetDockingPaneManager()->NotifyAction(xtpPaneActionExpanded, m_pPane->GetSelected());
  382. }
  383. return;
  384. }
  385. }
  388. void CXTPDockingPaneAutoHideWnd::OnMouseMove(UINT nFlags, CPoint point)
  389. {
  390. if (m_bSlideOut)
  391. {
  392. OnTimer(TID_CHECKACTIVE);
  393. return;
  394. }
  396. CMiniFrameWnd::OnMouseMove(nFlags, point);
  397. }
  400. void CXTPDockingPaneAutoHideWnd::OnClose()
  401. {
  402. CMiniFrameWnd::OnClose();
  403. }
  405. BOOL CXTPDockingPaneAutoHideWnd::OnEraseBkgnd(CDC* /*pDC*/)
  406. {
  407. return TRUE;
  408. }
  410. void CXTPDockingPaneAutoHideWnd::OnPaint()
  411. {
  412. CPaintDC dc(this);
  414. if (!m_pPane)
  415. return;
  417. CXTPDockingPanePaintManager* pPaintManager = m_pPane->CXTPDockingPaneBase::GetPaintManager();
  419. CXTPClientRect rc(this);
  420. dc.FillSolidRect(rc, pPaintManager->GetXtremeColor(XPCOLOR_3DFACE));
  423. switch (m_direction)
  424. {
  425. case xtpPaneDockLeft:
  426. dc.Draw3dRect(rc.right - 1, rc.top, 1, rc.Height(), pPaintManager->GetXtremeColor(COLOR_BTNTEXT), pPaintManager->GetXtremeColor(COLOR_BTNTEXT));
  427. dc.Draw3dRect(rc.right - 2, rc.top, 1, rc.Height(), pPaintManager->GetXtremeColor(COLOR_3DSHADOW), pPaintManager->GetXtremeColor(COLOR_3DSHADOW));
  428. break;
  430. case xtpPaneDockTop:
  431. dc.Draw3dRect(rc.left, rc.bottom - 1, rc.Width(), 1, pPaintManager->GetXtremeColor(COLOR_BTNTEXT), pPaintManager->GetXtremeColor(COLOR_BTNTEXT));
  432. dc.Draw3dRect(rc.left, rc.bottom - 2, rc.Width(), 1, pPaintManager->GetXtremeColor(COLOR_3DSHADOW), pPaintManager->GetXtremeColor(COLOR_3DSHADOW));
  433. break;
  435. case xtpPaneDockRight:
  436. dc.Draw3dRect(rc.left + 1, rc.top, 1, rc.Height(), pPaintManager->GetXtremeColor(COLOR_3DHIGHLIGHT), pPaintManager->GetXtremeColor(COLOR_3DHIGHLIGHT));
  437. break;
  439. case xtpPaneDockBottom:
  440. dc.Draw3dRect(rc.left, rc.top + 1, rc.Width(), 1, pPaintManager->GetXtremeColor(COLOR_3DHIGHLIGHT), pPaintManager->GetXtremeColor(COLOR_3DHIGHLIGHT));
  441. break;
  442. }
  443. }
  445. void CXTPDockingPaneAutoHideWnd::Reposition(CRect rc, CRect rcClient)
  446. {
  447. CWnd* pSite = GetDockingPaneManager()->GetSite();
  449. switch (GetDockingPaneManager()->GetRTLDirection(m_direction))
  450. {
  451. case xtpPaneDockLeft:  rc.left = rcClient.left; break;
  452. case xtpPaneDockRight: rc.right = rcClient.right; break;
  453. case xtpPaneDockTop: rc.top = rcClient.top; break;
  454. case xtpPaneDockBottom: rc.bottom = rcClient.bottom; break;
  455. }
  456. if (!m_bHoriz) m_pPane->m_pSelectedPane->m_szDocking.cx = rc.Width();
  457. else m_pPane->m_pSelectedPane->m_szDocking.cy = rc.Height();
  459. pSite->ScreenToClient(&rc);
  460. m_rcWindow = rc;
  461. MoveWindow(m_rcWindow);
  462. Invalidate(FALSE);
  463. }
  465. BOOL CXTPDockingPaneAutoHideWnd::GetAvailableRect(CRect& rcAvail, CRect& rc) const
  466. {
  467. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  468. if (!pManager)
  469. return FALSE;
  471. CRect rcClient = pManager->GetTopPane()->GetPaneWindowRect();
  473. int nGap = pManager->m_nSplitterGap + 4;
  475. rcAvail = rcClient;
  477. MINMAXINFO mmInfo;
  478. GetMinMaxInfo(&mmInfo, m_direction == xtpPaneDockRight || m_direction == xtpPaneDockBottom);
  480. switch (m_direction)
  481. {
  482. case xtpPaneDockLeft:
  483. rcAvail.DeflateRect(max(mmInfo.ptMinTrackSize.x, nGap), 0, nGap, 0);
  485. if (rcAvail.right - rcClient.left > mmInfo.ptMaxTrackSize.x)
  486. rcAvail.right = mmInfo.ptMaxTrackSize.x + rcClient.left;
  488. if (rcAvail.left >= rcAvail.right)
  489. return FALSE;
  491. rc.left = rc.right - 4;
  492. break;
  494. case xtpPaneDockRight:
  495. rcAvail.DeflateRect(nGap, 0, max(mmInfo.ptMinTrackSize.x, nGap), 0);
  497. if (rcClient.right - rcAvail.left > mmInfo.ptMaxTrackSize.x)
  498. rcAvail.left = rcClient.right - mmInfo.ptMaxTrackSize.x;
  500. if (rcAvail.left >= rcAvail.right)
  501. return FALSE;
  503. rc.right = rc.left + 4;
  504. break;
  506. case xtpPaneDockTop:
  507. rcAvail.DeflateRect(0, max(mmInfo.ptMinTrackSize.y, nGap), 0, nGap);
  509. if (rcAvail.bottom - rcClient.top > mmInfo.ptMaxTrackSize.y)
  510. rcAvail.bottom = mmInfo.ptMaxTrackSize.y + rcClient.top;
  512. if (rcAvail.top >= rcAvail.bottom)
  513. return FALSE;
  515. rc.top = rc.bottom - 4;
  516. break;
  518. case xtpPaneDockBottom:
  519. rcAvail.DeflateRect(0, nGap, 0, max(mmInfo.ptMinTrackSize.y, nGap));
  521. if (rcClient.bottom - rcAvail.top > mmInfo.ptMaxTrackSize.y)
  522. rcAvail.top = rcClient.bottom - mmInfo.ptMaxTrackSize.y;
  524. if (rcAvail.top >= rcAvail.bottom)
  525. return FALSE;
  527. rc.bottom = rc.top + 4;
  528. break;
  529. }
  530. return TRUE;
  531. }
  533. void CXTPDockingPaneAutoHideWnd::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  534. {
  535. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  537. if (!pManager || pManager->IsSplittersLocked())
  538. return;
  540. if (!m_pPane)
  541. return;
  543. CXTPWindowRect rc(this);
  544. CRect rcClient = pManager->GetTopPane()->GetPaneWindowRect();
  546. CRect rcAvail;
  547. if (!GetAvailableRect(rcAvail, rc))
  548. return;
  550. if (m_pPane->OnAction(xtpPaneActionSplitterResizing))
  551. return;
  553. m_bTracking = TRUE;
  555. if (pManager->IsSplitterTrackerUsed())
  556. {
  557. if (GetExStyle() & WS_EX_LAYOUTRTL)
  558. point = rc.TopLeft();
  559. else ClientToScreen(&point);
  562. CXTPSplitterTracker tracker;
  564. if (tracker.Track(this, rcAvail, rc, point, !m_bHoriz))
  565. {
  566. Reposition(rc, rcClient);
  567. }
  568. }
  569. else
  570. {
  571. SetCapture();
  573. while (CWnd::GetCapture() == this)
  574. {
  575. MSG msg;
  577. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  578. {
  579. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  580. return;
  581. DispatchMessage(&msg);
  582. }
  584. if (!GetMessage(&msg, NULL, 0, 0))
  585. break;
  587. if (msg.message == WM_MOUSEMOVE)
  588. {
  589. point = CPoint(msg.lParam);
  590. ClientToScreen(&point);
  592. point.x = max(min(point.x, rcAvail.right), rcAvail.left);
  593. point.y = max(min(point.y, rcAvail.bottom), rcAvail.top);
  595. if (!m_bHoriz)
  596. {
  597. if (rc.left == point.x)
  598. continue;
  599. rc.OffsetRect(point.x - rc.left, 0);
  600. }
  601. else
  602. {
  603. if (rc.top == point.y)
  604. continue;
  605. rc.OffsetRect(0, point.y - rc.top);
  606. }
  608. Reposition(rc, rcClient);
  609. }
  610. else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) break;
  611. else if (msg.message == WM_LBUTTONUP) break;
  612. else ::DispatchMessage(&msg);
  613. }
  615. if (CWnd::GetCapture() == this) ReleaseCapture();
  616. }
  618. m_bTracking = FALSE;
  620. m_pPane->OnAction(xtpPaneActionSplitterResized);
  621. }
  624. //////////////////////////////////////////////////////////////////////////
  625. // CPanelDropTarget
  627. class CXTPDockingPaneAutoHidePanel::CPanelDropTarget : public COleDropTarget
  628. {
  629. virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* /*pDataObject*/, DWORD /*dwKeyState*/, CPoint point)
  630. {
  631. CXTPDockingPaneAutoHidePanel* pPanel = (CXTPDockingPaneAutoHidePanel*)pWnd;
  632. ASSERT_VALID(pPanel);
  634. if (!pPanel->GetPaintManager()->GetPanelPaintManager()->m_bSelectOnDragOver)
  635. return DROPEFFECT_NONE;
  637. CXTPDockingPane* pPane = pPanel->HitTest(point);
  638. if (pPane)
  639. {
  640. if (!(pPanel->m_pActiveWnd && pPanel->m_pActiveWnd->GetPane()->GetSelected() == pPane))
  641. {
  642. pPanel->ShowPane(pPane, FALSE);
  643. }
  644. }
  646. return DROPEFFECT_NONE;
  647. }
  648. };
  650. //////////////////////////////////////////////////////////////////////////
  651. // CAutoHidePanelTabManager
  653. class CXTPDockingPaneAutoHidePanel::CAutoHidePanelTabManager : public CXTPTabManager
  654. {
  655. public:
  656. CAutoHidePanelTabManager()
  657. {
  658. FindNavigateButton(xtpTabNavigateButtonLeft)->SetFlags(xtpTabNavigateButtonNone);
  659. FindNavigateButton(xtpTabNavigateButtonRight)->SetFlags(xtpTabNavigateButtonNone);
  660. }
  662. virtual void Reposition()
  663. {
  665. }
  666. virtual BOOL DrawIcon(CDC* pDC, CPoint pt, CXTPTabManagerItem* pItem, BOOL bDraw, CSize& szIcon) const
  667. {
  668. if (!pItem)
  669. return TRUE;
  671. if (GetPanel()->GetPaintManager()->GetPanelPaintManager()->m_bShowIcons == FALSE)
  672. return FALSE;
  675. CXTPImageManagerIcon* pImage = ((CXTPDockingPane*)pItem->GetData())->GetIcon(szIcon.cx);
  677. if (!pImage)
  678. return FALSE;
  680. if (!bDraw)
  681. {
  682. return TRUE;
  683. }
  685. pItem->DrawImage(pDC, CRect(pt, szIcon), pImage);
  687. return TRUE;
  689. }
  691. virtual void RedrawControl(LPCRECT lpRect, BOOL /*bAnimate*/)
  692. {
  693. if (GetPanel()->m_hWnd) GetPanel()->InvalidateRect(lpRect, FALSE);
  694. }
  696. virtual CXTPTabPaintManager* GetPaintManager() const
  697. {
  698. return GetPanel()->GetPaintManager()->GetPanelPaintManager();
  700. }
  702. CXTPTabManagerItem* Add()
  703. {
  704. return AddItem(GetItemCount());
  705. }
  707. XTPTabPosition GetPosition() const
  708. {
  709. switch (GetPanel()->GetDirection())
  710. {
  711. case xtpPaneDockLeft: return xtpTabPositionRight;
  712. case xtpPaneDockRight: return xtpTabPositionLeft;
  713. case xtpPaneDockTop: return xtpTabPositionBottom;
  714. case xtpPaneDockBottom: return xtpTabPositionTop;
  715. }
  716. return xtpTabPositionTop;
  717. }
  719. void PerformMouseMove(HWND hwnd, CPoint pt)
  720. {
  721. CXTPTabManager::PerformMouseMove(hwnd, pt);
  722. }
  724. CXTPDockingPaneAutoHidePanel* GetPanel() const;
  726. public:
  727. CAutoHidePanelTabManagersArray* m_pArray;
  728. CRect m_rcManager;
  729. };
  731. class CXTPDockingPaneAutoHidePanel::CAutoHidePanelTabManagersArray : public CArray<CAutoHidePanelTabManager*, CAutoHidePanelTabManager*>
  732. {
  733. public:
  735. ~CAutoHidePanelTabManagersArray()
  736. {
  737. FreeAll();
  738. }
  740. void FreeAll()
  741. {
  742. for (int i = 0; i < GetSize(); i++)
  743. {
  744. delete GetAt(i);
  745. }
  746. RemoveAll();
  747. }
  748. CAutoHidePanelTabManager* AddManager()
  749. {
  750. CAutoHidePanelTabManager* pManager = new CAutoHidePanelTabManager();
  751. Add(pManager);
  752. pManager->m_pArray = this;
  753. return pManager;
  754. }
  756. void Draw(CDC* pDC)
  757. {
  758. CRect rcClipBox;
  759. pDC->GetClipBox(rcClipBox);
  761. CXTPTabPaintManager* pPaintManager = m_pAutoHidePanel->GetPaintManager()->GetPanelPaintManager();
  762. for (int i = 0; i < GetSize(); i++)
  763. {
  764. CAutoHidePanelTabManager* pManager = GetAt(i);
  766. if (CRect().IntersectRect(rcClipBox, pManager->m_rcManager))
  767. pPaintManager->DrawTabControl(pManager, pDC, pManager->m_rcManager);
  768. }
  769. }
  773. public:
  774. CXTPDockingPaneAutoHidePanel* m_pAutoHidePanel;
  775. };
  779. CXTPDockingPaneAutoHidePanel* CXTPDockingPaneAutoHidePanel::CAutoHidePanelTabManager::GetPanel() const
  780. {
  781. return m_pArray->m_pAutoHidePanel;
  782. }
  789. //////////////////////////////////////////////////////////////////////////
  790. // CXTPDockingPaneAutoHidePanel
  792. int CXTPDockingPaneAutoHidePanel::GetPanelHeight() const
  793. {
  794. CXTPTabPaintManager::CAppearanceSet* pAppearanceSet = GetPaintManager()->GetPanelPaintManager()->GetAppearanceSet();
  796. return pAppearanceSet->GetButtonHeight(NULL) +
  797. pAppearanceSet->m_rcHeaderMargin.bottom + pAppearanceSet->m_rcHeaderMargin.top;
  798. }
  800. void CXTPDockingPaneAutoHidePanel::RefreshManagersArray(CDC* pDC, CRect rcClient)
  801. {
  802. BOOL bIndent = (m_direction == xtpPaneDockLeft || m_direction == xtpPaneDockRight)
  803. && (m_pLayout->m_wndPanels[xtpPaneDockTop] != NULL && !m_pLayout->m_wndPanels[xtpPaneDockTop]->IsEmpty());
  805. if (bIndent)
  806. {
  807. rcClient.top += GetPanelHeight();
  808. }
  810. m_pTabManagers->FreeAll();
  812. CRect rcMargins = GetPaintManager()->GetPanelPaintManager()->GetAppearanceSet()->GetHeaderMargin();
  814. POSITION pos = GetHeadPosition();
  815. while (pos)
  816. {
  817. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)GetNext(pos);
  818. if (pContainer->IsEmpty())
  819. continue;
  821. CAutoHidePanelTabManager* pManager = m_pTabManagers->AddManager();
  823. POSITION posPane = pContainer->GetHeadPosition();
  824. while (posPane)
  825. {
  826. CXTPDockingPane* pPane = (CXTPDockingPane*)pContainer->GetNext(posPane);
  828. CXTPTabManagerItem* pItem = pManager->Add();
  830. pItem->SetData((DWORD_PTR)pPane);
  831. if (pContainer->GetSelected() == pPane) pManager->SetSelectedItem(pItem);
  833. pItem->SetCaption(pPane->GetShortTitle());
  834. pItem->SetColor(pPane->GetItemColor());
  835. pItem->SetEnabled(pPane->GetEnabled() & xtpPaneEnableClient);
  836. }
  837. pManager->GetPaintManager()->RepositionTabControl(pManager, pDC, rcClient);
  838. pManager->m_rcManager = rcClient;
  840. if (m_direction == xtpPaneDockLeft || m_direction == xtpPaneDockRight)
  841. {
  842. rcClient.top += pManager->GetItemsLength() + rcMargins.left + rcMargins.right + 8;
  843. }
  844. else
  845. {
  846. rcClient.left += pManager->GetItemsLength() + rcMargins.left + rcMargins.right + 8;
  848. }
  849. }
  850. }
  852. CXTPDockingPaneAutoHidePanel::CXTPDockingPaneAutoHidePanel(CXTPDockingPaneLayout* pLayout)
  853. : CXTPDockingPaneBaseContainer(xtpPaneTypeAutoHidePanel, pLayout)
  854. {
  855. m_direction = xtpPaneDockLeft;
  856. m_pActiveWnd = 0;
  857. m_pTabManagers = new CAutoHidePanelTabManagersArray();
  858. m_pTabManagers->m_pAutoHidePanel = this;
  860. m_pDropTarget = new CPanelDropTarget();
  861. m_rcFrameRect.SetRectEmpty();
  863. }
  865. CXTPDockingPaneAutoHidePanel::~CXTPDockingPaneAutoHidePanel()
  866. {
  867. if (m_pActiveWnd)
  868. {
  869. m_pActiveWnd->m_pPane = 0;
  870. m_pActiveWnd->m_pPanel = 0;
  871. CloseActiveWindow();
  872. }
  874. if (m_hWnd)
  875. DestroyWindow();
  877. delete m_pTabManagers;
  878. delete m_pDropTarget;
  879. }
  881. void CXTPDockingPaneAutoHidePanel::_InsertPane(CXTPDockingPaneBase* pPane)
  882. {
  883. m_lstPanes.AddTail(pPane);
  885. pPane->SetParentContainer(this);
  886. pPane->SetDockingSite(m_pDockingSite);
  888. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  890. pPane->OnParentContainerChanged(this);
  892. if (pPane->GetType() == xtpPaneTypeTabbedContainer)
  893. {
  894. CWnd* pFocus = GetFocus();
  895. if (((CXTPDockingPaneTabbedContainer*)pPane)->GetSafeHwnd() && pFocus->GetSafeHwnd() && (pFocus == ((CXTPDockingPaneTabbedContainer*)pPane) || ((CXTPDockingPaneTabbedContainer*)pPane)->IsChild(pFocus)))
  896. GetDockingPaneManager()->GetSite()->SetFocus();
  897. }
  899. if (m_hWnd) Invalidate(FALSE);
  900. }
  902. void CXTPDockingPaneAutoHidePanel::RemovePane(CXTPDockingPaneBase* pPane)
  903. {
  904. POSITION pos = m_lstPanes.Find(pPane);
  905. ASSERT(pos);
  907. m_lstPanes.RemoveAt(pos);
  908. if (m_hWnd) Invalidate(FALSE);
  909. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  911. if (m_lstPanes.IsEmpty())
  912. {
  913. if (m_hWnd) DestroyWindow();
  914. }
  916. pPane->m_pParentContainer = NULL;
  917. }
  919. void CXTPDockingPaneAutoHidePanel::Create(CWnd* pParent)
  920. {
  921. CWnd::Create(_T("XTPDockingPaneAutoHidePanel"), NULL, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, CXTPEmptyRect(), pParent, 0);
  922. m_pDropTarget->Register(this);
  923. }
  925. void CXTPDockingPaneAutoHidePanel::OnSizeParentEx(CWnd* pParent, CRect& rect, LPVOID lParam)
  926. {
  927. AFX_SIZEPARENTPARAMS* lpLayout = (AFX_SIZEPARENTPARAMS*)lParam;
  929. if (IsEmpty())
  930. {
  931. if (m_hWnd) DestroyWindow();
  932. return;
  933. }
  935. if (!m_hWnd)
  936. Create(pParent);
  938. if (m_rcFrameRect != rect)
  939. {
  940. CloseActiveWindow();
  941. m_rcFrameRect = rect;
  942. }
  944. int nHeight = GetPanelHeight();
  946. CRect rcClient(rect);
  947. switch (m_direction)
  948. {
  949. case xtpPaneDockLeft:
  950. rcClient.right = rect.left = rect.left + nHeight;
  951. break;
  953. case xtpPaneDockRight:
  954. rcClient.left = rect.right = rect.right - nHeight;
  955. break;
  957. case xtpPaneDockTop:
  958. rcClient.bottom = rect.top = rect.top + nHeight;
  959. break;
  961. case xtpPaneDockBottom:
  962. rcClient.top = rect.bottom = rect.bottom - nHeight;
  963. break;
  964. }
  966. CClientDC dc(this);
  967. CRect rcPanel(rcClient);
  968. rcPanel.OffsetRect(-rcPanel.TopLeft());
  969. RefreshManagersArray(&dc, rcPanel);
  971. if (lpLayout->hDWP != NULL)
  972. {
  973. MoveWindow(rcClient);
  974. Invalidate(FALSE);
  975. }
  976. }
  979. BEGIN_MESSAGE_MAP(CXTPDockingPaneAutoHidePanel, CWnd)
  980. ON_WM_PAINT()
  981. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  982. ON_WM_LBUTTONDOWN()
  983. ON_WM_RBUTTONDOWN()
  984. ON_WM_RBUTTONUP()
  985. ON_WM_MOUSEMOVE()
  986. ON_MESSAGE(WM_MOUSEHOVER, OnMouseHover)
  987. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  988. END_MESSAGE_MAP()
  990. LRESULT CXTPDockingPaneAutoHidePanel::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  991. {
  992. CDC* pDC = CDC::FromHandle((HDC)wParam);
  993. if (pDC)
  994. {
  995. OnDraw(pDC);
  996. }
  998. return TRUE;
  999. }
  1001. void CXTPDockingPaneAutoHidePanel::OnPaint()
  1002. {
  1003. CPaintDC dcPaint(this);
  1004. CXTPBufferDC dc(dcPaint);
  1005. OnDraw(&dc);
  1006. }
  1008. void CXTPDockingPaneAutoHidePanel::OnDraw(CDC* pDC)
  1009. {
  1010. CXTPClientRect rc(this);
  1012. CXTPPaintManagerColorGradient& clr = GetPaintManager()->GetPanelPaintManager()->GetColorSet()->m_clrAutoHideFace;
  1014. if (clr.clrDark == clr.clrLight)
  1015. {
  1016. pDC->FillSolidRect(rc, clr.clrDark);
  1017. }
  1018. else
  1019. {
  1020. CRect rcFill(rc);
  1022. if (m_direction == xtpPaneDockRight)
  1023. {
  1024. rcFill.left -= CXTPClientRect(GetParent()).Width() - rcFill.Width();
  1025. }
  1027. rcFill.right = rcFill.left + max(rcFill.Width(), GetSystemMetrics(SM_CXFULLSCREEN) / 2);
  1028. XTPDrawHelpers()->GradientFill(pDC, rcFill, clr.clrLight, clr.clrDark, TRUE, rc);
  1029. }
  1031. m_pTabManagers->Draw(pDC);
  1032. }
  1034. CXTPTabManagerItem* CXTPDockingPaneAutoHidePanel::GetPaneTab(CXTPDockingPane* pPane) const
  1035. {
  1036. for (int i = 0; i < m_pTabManagers->GetSize(); i++)
  1037. {
  1038. CAutoHidePanelTabManager* pTabManager = m_pTabManagers->GetAt(i);
  1040. for (int j = 0; j < pTabManager->GetItemCount(); j++)
  1041. {
  1042. CXTPTabManagerItem* pItem = pTabManager->GetItem(j);
  1044. if ((CXTPDockingPane*)pItem->GetData() == pPane)
  1045. {
  1046. return pItem;
  1047. }
  1048. }
  1049. }
  1050. return NULL;
  1051. }
  1053. CXTPDockingPane* CXTPDockingPaneAutoHidePanel::HitTest(CPoint point) const
  1054. {
  1055. for (int i = 0; i < m_pTabManagers->GetSize(); i++)
  1056. {
  1057. CXTPTabManagerItem* pItem = m_pTabManagers->GetAt(i)->HitTest(point);
  1058. if (pItem)
  1059. {
  1060. return (CXTPDockingPane*)pItem->GetData();
  1061. }
  1063. }
  1064. return NULL;
  1065. }
  1067. void CXTPDockingPaneAutoHidePanel::CloseActiveWindows()
  1068. {
  1069. for (int i = 0; i < 4; i++)
  1070. {
  1071. SAFE_CALLPTR(m_pLayout->m_wndPanels[i], CloseActiveWindow());
  1072. }
  1073. }
  1075. void CXTPDockingPaneAutoHidePanel::CloseActiveWindow(BOOL bDelayed)
  1076. {
  1077. if (!m_bCloseActiveWindow)
  1078. return;
  1080. if (m_pActiveWnd)
  1081. {
  1082. if (m_pActiveWnd->m_pPane)
  1083. {
  1084. if (GetDockingPaneManager()->NotifyAction(xtpPaneActionCollapsing, m_pActiveWnd->m_pPane->GetSelected()))
  1085. return;
  1087. GetDockingPaneManager()->NotifyAction(xtpPaneActionCollapsed,
  1088. m_pActiveWnd->m_pPane->GetSelected());
  1089. }
  1091. if (bDelayed)
  1092. {
  1093. // let the window close itself
  1094. if (m_pActiveWnd->m_pPane)
  1095. {
  1096. m_pActiveWnd->m_pPane->ShowWindow(SW_HIDE);
  1097. m_pActiveWnd->m_pPane->SetDockingSite(GetDockingPaneManager()->GetSite());
  1098. m_pActiveWnd->m_pPane = 0;
  1099. }
  1100. m_pActiveWnd->SetTimer(TID_CLOSE, 50, NULL);
  1101. }
  1102. else
  1103. {
  1104. m_pActiveWnd->CloseWindow();
  1105. }
  1107. m_pActiveWnd = 0;
  1108. }
  1109. }
  1111. void CXTPDockingPaneAutoHidePanel::ShowPane(CXTPDockingPane* pPane, BOOL bSetFocus)
  1112. {
  1113. if (m_pActiveWnd && m_pActiveWnd->m_pPane && m_pActiveWnd->m_pPane->GetSelected() == pPane)
  1114. {
  1115. if (bSetFocus) m_pActiveWnd->m_pPane->SelectPane(pPane, TRUE, FALSE);
  1117. if (m_pActiveWnd->m_bSlideOut)
  1118. {
  1119. m_pActiveWnd->OnTimer(TID_CHECKACTIVE);
  1120. }
  1121. return;
  1122. }
  1124. CloseActiveWindows();
  1126. if (GetDockingPaneManager()->NotifyAction(xtpPaneActionExpanding, pPane))
  1127. return;
  1129. CXTPDockingPaneTabbedContainer* pContainer = ((CXTPDockingPaneTabbedContainer*)pPane->m_pParentContainer);
  1131. ASSERT(pContainer);
  1132. if (!pContainer)
  1133. return;
  1134. ASSERT(pContainer->GetType() == xtpPaneTypeTabbedContainer);
  1136. pContainer->SelectPane(pPane, FALSE, TRUE);
  1137. CXTPDockingPaneAutoHideWnd* pActiveWnd = new CXTPDockingPaneAutoHideWnd(this, pContainer);
  1139. if (bSetFocus) pContainer->SelectPane(pPane, TRUE, FALSE);
  1141. if (m_hWnd) Invalidate(FALSE);
  1142. GetDockingPaneManager()->RecalcFrameLayout(this);
  1144. m_pActiveWnd = pActiveWnd;
  1145. }
  1147. void CXTPDockingPaneAutoHidePanel::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  1148. {
  1149. CXTPDockingPane* pPane = HitTest(point);
  1150. if (pPane)
  1151. {
  1152. if (m_pActiveWnd && m_pActiveWnd->m_pPane->GetSelected() == pPane)
  1153. {
  1154. pPane->SetFocus();
  1156. }
  1157. else
  1158. {
  1159. ShowPane(pPane);
  1160. }
  1161. }
  1162. }
  1164. void CXTPDockingPaneAutoHidePanel::OnRButtonDown(UINT /*nFlags*/, CPoint point)
  1165. {
  1166. CXTPDockingPane* pPane = HitTest(point);
  1167. if (pPane)
  1168. {
  1169. GetDockingPaneManager()->NotifyOwner(XTP_DPN_RCLICK, (LPARAM)(CXTPDockingPaneBase*)pPane);
  1170. }
  1171. }
  1173. void CXTPDockingPaneAutoHidePanel::OnRButtonUp(UINT /*nFlags*/, CPoint point)
  1174. {
  1175. XTP_DOCKINGPANE_CLICK menu;
  1176. menu.pPane = HitTest(point);
  1177. menu.pContainer = this;
  1178. ClientToScreen(&point);
  1179. menu.pt = point;
  1180. menu.rcExclude.SetRectEmpty();
  1182. if (GetDockingPaneManager()->NotifyOwner(XTP_DPN_CONTEXTMENU, (LPARAM)&menu))
  1183. return;
  1184. }
  1186. void CXTPDockingPaneAutoHidePanel::OnMouseMove(UINT nFlags, CPoint point)
  1187. {
  1188. for (int i = 0; i < m_pTabManagers->GetSize(); i++)
  1189. {
  1190. m_pTabManagers->GetAt(i)->PerformMouseMove(m_hWnd, point);
  1191. }
  1195. CXTPDockingPane* pPane = HitTest(point);
  1196. if (pPane)
  1197. {
  1198. TRACKMOUSEEVENT tme =
  1199. {
  1200. sizeof(TRACKMOUSEEVENT), TME_HOVER | TME_LEAVE, m_hWnd, CXTPDockingPaneAutoHideWnd::m_nMouseHoverDelay
  1201. };
  1202. _TrackMouseEvent(&tme);
  1204. }
  1205. CWnd::OnMouseMove(nFlags, point);
  1206. }
  1208. void CXTPDockingPaneAutoHidePanel::OnMouseLeave()
  1209. {
  1210. OnMouseMove(0, CPoint(-1, -1));
  1211. }
  1213. LRESULT CXTPDockingPaneAutoHidePanel::OnMouseHover(WPARAM, LPARAM lParam)
  1214. {
  1215. CPoint point(lParam);
  1216. CXTPDockingPane* pPane = HitTest(point);
  1217. if (pPane)
  1218. {
  1219. if (!CXTPDrawHelpers::IsTopParentActive(m_hWnd) || (m_pActiveWnd && m_pActiveWnd->m_pPane->GetSelected() == pPane))
  1220. return 1;
  1222. ShowPane(pPane, FALSE);
  1223. }
  1225. return 1;
  1226. }
  1229. void CXTPDockingPaneAutoHidePanel::Copy(CXTPDockingPaneBase* pCloneBase, CXTPPaneToPaneMap* pMap, DWORD /*dwIgnoredOptions*/)
  1230. {
  1231. CXTPDockingPaneAutoHidePanel* pClone = (CXTPDockingPaneAutoHidePanel*)pCloneBase;
  1233. ASSERT(pClone);
  1234. if (!pClone)
  1235. return;
  1237. m_direction = pClone->m_direction;
  1238. m_pDockingSite = GetDockingPaneManager()->GetSite();
  1240. POSITION pos = pClone->GetHeadPosition();
  1241. while (pos)
  1242. {
  1243. CXTPDockingPaneBase* pPane = (CXTPDockingPaneBase*)pClone->GetNext(pos);
  1244. if (!pPane->IsEmpty() || pMap)
  1245. {
  1246. _InsertPane(pPane->Clone(m_pLayout, pMap));
  1247. }
  1248. }
  1249. }
  1251. void CXTPDockingPaneAutoHidePanel::InvalidatePane(BOOL /*bSelectionChanged*/)
  1252. {
  1253. if (!m_hWnd)
  1254. return;
  1256. CClientDC dc(this);
  1257. CXTPClientRect rcPanel(this);
  1259. RefreshManagersArray(&dc, rcPanel);
  1260. Invalidate(FALSE);
  1261. }
  1264. void CXTPDockingPaneAutoHidePanel::OnChildContainerChanged(CXTPDockingPaneBase* /*pContainer*/)
  1265. {
  1266. if (m_pActiveWnd)
  1267. {
  1268. if (!m_bCloseActiveWindow)
  1269. {
  1270. GetDockingPaneManager()->RecalcFrameLayout(this);
  1272. m_pActiveWnd->RecalcLayout(TRUE);
  1273. }
  1274. else
  1275. {
  1276. CloseActiveWindow(GetDockingPaneManager()->m_bAttachingPane);
  1277. }
  1278. }
  1279. }
  1281. void CXTPDockingPaneAutoHidePanel::DeletePane()
  1282. {
  1283. InternalRelease();
  1284. }
  1286. void CXTPDockingPaneAutoHidePanel::OnFinalRelease()
  1287. {
  1288. if (m_hWnd != NULL)
  1289. DestroyWindow();
  1291. CCmdTarget::OnFinalRelease();
  1292. }