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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneMiniWnd.cpp：源码内容
  1. // XTPDockingPaneMiniWnd.cpp : implementation of the CXTPDockingPaneMiniWnd 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/XTPDrawHelpers.h"
  25. #include "Common/XTPToolTipContext.h"
  26. #include "Common/XTPResourceManager.h"
  27. #include "TabManager/XTPTabManager.h"
  30. #include "XTPDockingPaneMiniWnd.h"
  31. #include "XTPDockingPane.h"
  32. #include "XTPDockingPaneSplitterContainer.h"
  33. #include "XTPDockingPaneTabbedContainer.h"
  34. #include "XTPDockingPaneContext.h"
  35. #include "XTPDockingPaneManager.h"
  36. #include "XTPDockingPaneLayout.h"
  37. #include "XTPDockingPaneAutoHidePanel.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  46. BOOL CXTPDockingPaneMiniWnd::m_bShowPinButton = TRUE;
  48. #define TID_NCLEAVE 2345
  50. #define TID_CHECKACTIVE 1
  51. #define TID_SLIDEIN 2
  52. #define TID_SLIDEOUT 3
  54. #ifndef LWA_ALPHA
  55. #define LWA_ALPHA               0x00000002
  56. #endif
  57. #ifndef WS_EX_LAYERED
  58. #define WS_EX_LAYERED           0x00080000
  59. #endif
  62. IMPLEMENT_DYNAMIC(CXTPDockingPaneMiniWnd, CMiniFrameWnd)
  64. AFX_INLINE int ResetStepsCount()
  65. {
  66. if (CXTPDockingPaneAutoHideWnd::m_nAnimationInterval == 0)
  67. return 1;
  69. return max(1, CXTPDockingPaneAutoHideWnd::m_nAnimationDuration / CXTPDockingPaneAutoHideWnd::m_nAnimationInterval);
  70. }
  72. CXTPDockingPaneMiniWnd::CXTPDockingPaneMiniWnd(CXTPDockingPaneLayout* pLayout)
  73. : CXTPDockingPaneBase(xtpPaneTypeMiniWnd, pLayout)
  74. {
  75. m_pTopContainer = NULL;
  77. m_pCaptionButtons = new CXTPDockingPaneCaptionButtons();
  78. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_CLOSE, this));
  79. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_AUTOHIDE, this));
  80. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_MENU, this));
  82. m_bSlideOut = m_bExpanded = m_bCollapsed = FALSE;
  83. m_nExpandedHeight = 0;
  85. m_nSlideStep = 0;
  86. m_nStepsCount = ResetStepsCount();
  88. m_bDelayInvalidate = FALSE;
  89. m_nDeactivationCount = 0;
  91. }
  93. void CXTPDockingPaneMiniWnd::Init(CXTPDockingPaneBase* pPane, CRect rc)
  94. {
  95. m_rcWindow = rc;
  96. CreateContainer();
  98. if (pPane->GetType() == xtpPaneTypeDockingPane)
  99. {
  100. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)GetDockingPaneManager()->
  101. OnCreatePane(xtpPaneTypeTabbedContainer, m_pLayout);
  102. pContainer->Init((CXTPDockingPane*)pPane, this);
  104. pPane = pContainer;
  106. }
  108. m_pTopContainer = (CXTPDockingPaneSplitterContainer*)GetDockingPaneManager()->
  109. OnCreatePane(xtpPaneTypeSplitterContainer, m_pLayout);
  110. m_pTopContainer->Init(pPane, TRUE, this);
  112. m_pTopContainer->m_pParentContainer = this;
  114. m_bDelayInvalidate = TRUE;
  115. PostMessage(WM_IDLEUPDATECMDUI);
  116. DelayRecalcLayout();
  118. OnFocusChanged();
  119. }
  121. CXTPDockingPaneMiniWnd::~CXTPDockingPaneMiniWnd()
  122. {
  123. DestroyWindow();
  124. }
  126. void CXTPDockingPaneMiniWnd::Copy(CXTPDockingPaneBase* pCloneBase, CXTPPaneToPaneMap* pMap, DWORD /*dwIgnoredOptions*/)
  127. {
  128. CXTPDockingPaneMiniWnd* pClone = (CXTPDockingPaneMiniWnd*)pCloneBase;
  129. ASSERT(pMap);
  131. m_pTopContainer = (CXTPDockingPaneSplitterContainer*)pClone->m_pTopContainer->Clone(m_pLayout, pMap);
  132. m_pTopContainer->m_pParentContainer = this;
  133. m_pTopContainer->m_pDockingSite = this;
  135. m_rcWindow = pClone->m_rcWindow;
  136. if (pClone->m_hWnd) ::GetWindowRect(pClone->m_hWnd, &m_rcWindow);
  138. m_bCollapsed = ((CXTPDockingPaneMiniWnd*)pClone)->m_bCollapsed;
  139. m_nExpandedHeight = ((CXTPDockingPaneMiniWnd*)pClone)->m_nExpandedHeight;
  141. if (m_bCollapsed)
  142. {
  143. m_rcWindow.bottom = m_rcWindow.top + GetPaintManager()->GetCaptionHeight() + 8;
  144. }
  146. if (!m_pLayout->IsUserLayout())
  147. {
  148. CreateContainer();
  149. m_pTopContainer->OnParentContainerChanged(m_pTopContainer);
  150. OnChildContainerChanged(m_pTopContainer);
  151. }
  152. }
  154. void CXTPDockingPaneMiniWnd::RemovePane(CXTPDockingPaneBase* pPane)
  155. {
  156. ASSERT(pPane == m_pTopContainer);
  158. pPane->m_pParentContainer = NULL;
  159. m_pTopContainer = NULL;
  161. if (m_hWnd) ShowWindow(SW_HIDE);
  163. if (m_bCollapsed)
  164. OnPinButtonClick();
  166. }
  168. void CXTPDockingPaneMiniWnd::InvalidatePane(BOOL /*bSelectionChanged*/)
  169. {
  170. if (!m_pTopContainer)
  171. return;
  173. if (!m_hWnd)
  174. return;
  176. CXTPDockingPaneBaseList lstTabbed;
  178. FindPane(xtpPaneTypeTabbedContainer, &lstTabbed);
  179. int nCount = (int)lstTabbed.GetCount();
  181. POSITION pos = lstTabbed.GetHeadPosition();
  182. while (pos)
  183. {
  184. CXTPDockingPaneBase* pPane = lstTabbed.GetNext(pos);
  185. ASSERT(pPane->GetType() == xtpPaneTypeTabbedContainer);
  186. ((CXTPDockingPaneTabbedContainer*)pPane)->ShowTitle(nCount != 1);
  187. }
  188. CString strTitle = (nCount != 1) ? GetDockingPaneManager()->m_strFloatingFrameCaption : ((CXTPDockingPaneTabbedContainer*)lstTabbed.GetHead())->GetTitle();
  189. SetWindowText(strTitle);
  191. if (nCount > 0)
  192. {
  193. BOOL bEnabled = FALSE;
  195. CXTPDockingPaneBaseList lstChilds;
  197. FindPane(xtpPaneTypeDockingPane, &lstChilds);
  198. pos = lstChilds.GetHeadPosition();
  200. while (pos)
  201. {
  202. CXTPDockingPaneBase* pPane = lstChilds.GetNext(pos);
  204. if ((((CXTPDockingPane*)pPane)->GetOptions() & xtpPaneNoCloseable) == 0)
  205. bEnabled = TRUE;
  206. }
  208. if (!bEnabled || !m_bCloseEnabled)
  209. {
  210. CMenu* pSysMenu = GetSystemMenu(FALSE);
  211. pSysMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | (bEnabled ? MF_ENABLED : MF_DISABLED | MF_GRAYED));
  212. m_bCloseEnabled = bEnabled;
  213. }
  214. if ((GetStyle() & WS_CHILD) == 0)
  215. UpdatePosition();
  217. if ((GetStyle() & WS_VISIBLE) == 0)
  218. ShowWindow(SW_SHOWNOACTIVATE);
  219. }
  220. SendMessage(WM_NCPAINT);
  222. OnFocusChanged();
  223. }
  225. void CXTPDockingPaneMiniWnd::UpdatePosition()
  226. {
  227. CXTPWindowRect rc(this);
  228. CSize sz = rc.Size();
  230. if (IsThemed())
  231. {
  232. MINMAXINFO mmi;
  233. ZeroMemory(&mmi, sizeof(mmi));
  234. mmi.ptMaxTrackSize.x = 32000;
  235. mmi.ptMaxTrackSize.y = 32000;
  237. GetMinMaxInfo(&mmi);
  238. sz.cx = max(min(sz.cx, mmi.ptMaxTrackSize.x), mmi.ptMinTrackSize.x);
  239. sz.cy = max(min(sz.cy, mmi.ptMaxTrackSize.y), mmi.ptMinTrackSize.y);
  240. }
  242. MoveWindow(rc.left, rc.top, sz.cx, sz.cy);
  243. }
  245. void CXTPDockingPaneMiniWnd::CreateContainer()
  246. {
  247. if (!m_hWnd)
  248. {
  249. Create(m_rcWindow);
  250. }
  251. }
  253. void CXTPDockingPaneMiniWnd::OnChildContainerChanged(CXTPDockingPaneBase* /*pContainer*/)
  254. {
  255. if (!m_hWnd)
  256. return;
  258. if (m_pTopContainer == NULL || m_pTopContainer->IsEmpty())
  259. {
  260. DestroyWindow();
  261. }
  262. else
  263. {
  264. m_bDelayInvalidate = TRUE;
  265. PostMessage(WM_IDLEUPDATECMDUI);
  266. }
  267. }
  270. void CXTPDockingPaneMiniWnd::RecalcLayout(BOOL /*bNotify*/)
  271. {
  272. if (m_pTopContainer == NULL)
  273. return;
  275. if (m_bInRecalcLayout)
  276. return;
  278. m_bInRecalcLayout = TRUE;
  280. m_nIdleFlags &= ~(idleLayout | idleNotify);
  282. if (m_pTopContainer->IsEmpty())
  283. {
  284. ShowWindow(SW_HIDE);
  286. if (m_bCollapsed)
  287. OnPinButtonClick();
  288. }
  289. else
  290. {
  291. //ShowWindow(SW_SHOW);
  293. AFX_SIZEPARENTPARAMS layout;
  294. layout.bStretch = TRUE;
  295. GetClientRect(&layout.rect);
  296. layout.hDWP = ::BeginDeferWindowPos(8); // reasonable guess
  298. m_pTopContainer->OnSizeParent(this, layout.rect, &layout);
  300. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  301. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  303. CWnd::GetWindowRect(&m_pTopContainer->m_rcWindow);
  304. ScreenToClient(&m_pTopContainer->m_rcWindow);
  305. }
  307. GetDockingPaneManager()->SyncPanesState();
  309. m_bInRecalcLayout = FALSE;
  310. }
  313. BOOL CXTPDockingPaneMiniWnd::Create(CRect rc)
  314. {
  315. DWORD dwStyle = WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_BORDER |
  316. MFS_BLOCKSYSMENU | WS_THICKFRAME | (GetDockingPaneManager()->m_bSyncActiveFloatingFrames ? MFS_SYNCACTIVE : 0);
  318. DWORD dwExStyle = 0;
  320. if (GetDockingPaneManager()->IsLayoutRTL())
  321. {
  322. dwExStyle = WS_EX_LAYOUTRTL;
  323. }
  325. CXTPDockingPaneContext::EnsureVisible(rc);
  328. if (!CMiniFrameWnd::CreateEx(dwExStyle,
  329. _T("XTPDockingPaneMiniWnd"), _T(""), dwStyle, rc, GetDockingPaneManager()->GetSite()))
  330. {
  331. return FALSE;
  332. }
  333. CMenu* pSysMenu = GetSystemMenu(FALSE);
  334. pSysMenu->DeleteMenu(SC_MINIMIZE, MF_BYCOMMAND);
  335. pSysMenu->DeleteMenu(SC_MAXIMIZE, MF_BYCOMMAND);
  336. pSysMenu->DeleteMenu(SC_RESTORE, MF_BYCOMMAND);
  337. CString strHide;
  338. if (strHide.LoadString(AFX_IDS_HIDE))
  339. {
  340. pSysMenu->DeleteMenu(SC_CLOSE, MF_BYCOMMAND);
  341. pSysMenu->AppendMenu(MF_STRING | MF_ENABLED, SC_CLOSE, strHide);
  342. }
  343. m_bCloseEnabled = TRUE;
  345. if (IsThemed())
  346. {
  347. ModifyStyle(WS_BORDER | WS_THICKFRAME, 0, SWP_FRAMECHANGED);
  348. }
  350. SetWindowPos(0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
  352. UpdateWindowOpacity();
  354. return TRUE;
  357. }
  359. BEGIN_MESSAGE_MAP(CXTPDockingPaneMiniWnd, CMiniFrameWnd)
  360. ON_WM_CLOSE()
  361. ON_WM_NCLBUTTONDOWN()
  362. ON_WM_NCRBUTTONUP()
  363. ON_WM_NCLBUTTONDBLCLK()
  364. ON_WM_DESTROY()
  365. ON_WM_CONTEXTMENU()
  366. ON_WM_NCHITTEST_EX()
  367. ON_WM_NCPAINT()
  368. ON_WM_NCCALCSIZE()
  369. ON_WM_NCMOUSEMOVE()
  370. ON_WM_TIMER()
  371. ON_MESSAGE_VOID(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  372. ON_WM_GETMINMAXINFO()
  373. ON_WM_SETFOCUS()
  374. ON_WM_NCACTIVATE()
  375. ON_WM_SIZING()
  376. END_MESSAGE_MAP()
  378. void CXTPDockingPaneMiniWnd::OnSizing(UINT nSide, LPRECT lpRect)
  379. {
  380. CMiniFrameWnd::OnSizing(nSide, lpRect);
  382. GetDockingPaneManager()->GetDockingContext()->OnSizingFloatingFrame(this, nSide, lpRect);
  383. }
  385. void CXTPDockingPaneMiniWnd::UpdateWindowOpacity()
  386. {
  387. if (!GetSafeHwnd())
  388. return;
  390. CXTPDockingPaneManager::PFNSETLAYEREDWINDOWATTRIBUTES pfnSetLayeredWindowAttributes =
  391. GetDockingPaneManager()->m_pfnSetLayeredWindowAttributes;
  393. if (!pfnSetLayeredWindowAttributes)
  394. return;
  396. int nFloatingFramesOpacity = GetDockingPaneManager()->m_nFloatingFramesOpacity;
  397. if (nFloatingFramesOpacity == 255)
  398. {
  399. ModifyStyleEx(WS_EX_LAYERED, 0);
  400. return;
  401. }
  403. if (!m_bActive)
  404. {
  405. ModifyStyleEx(0, WS_EX_LAYERED);
  406. pfnSetLayeredWindowAttributes(m_hWnd, 0x00, (BYTE)nFloatingFramesOpacity, LWA_ALPHA);
  407. }
  408. else
  409. {
  410. pfnSetLayeredWindowAttributes(m_hWnd, 0x00, (BYTE)255, LWA_ALPHA);
  411. }
  412. }
  414. void CXTPDockingPaneMiniWnd::OnFocusChanged()
  415. {
  416. if (GetSafeHwnd())
  417. {
  418. CWnd* pFocus = GetFocus();
  419. BOOL bActive = (pFocus->GetSafeHwnd() && (pFocus == this || IsChild(pFocus) ||
  420. (pFocus->GetOwner()->GetSafeHwnd() && IsChild(pFocus->GetOwner()))));
  422. if (bActive != m_bActive)
  423. {
  424. m_bActive = bActive;
  426. if (IsThemed())
  427. {
  428. SendMessage(WM_NCPAINT);
  429. }
  430. UpdateWindowOpacity();
  431. }
  432. }
  433. }
  435. void CXTPDockingPaneMiniWnd::OnIdleUpdateCmdUI()
  436. {
  437. if (!GetSafeHwnd())
  438. return;
  440. if (m_bDelayInvalidate)
  441. {
  442. m_bDelayInvalidate = FALSE;
  443. InvalidatePane(FALSE);
  444. }
  446. CMiniFrameWnd::OnIdleUpdateCmdUI();
  447. }
  450. void CXTPDockingPaneMiniWnd::OnClose()
  451. {
  452. if (m_pTopContainer)
  453. {
  454. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  456. CXTPDockingPaneBaseList lst;
  457. FindPane(xtpPaneTypeDockingPane, &lst);
  459. POSITION pos = lst.GetHeadPosition();
  460. while (pos)
  461. {
  462. CXTPDockingPane* pPane = (CXTPDockingPane*)lst.GetNext(pos);
  464. if ((pPane->GetOptions() & xtpPaneNoCloseable) != 0)
  465. continue;
  467. pPane->InternalAddRef();
  469. if (!pManager->NotifyAction(xtpPaneActionClosing, pPane))
  470. {
  471. pPane->Close();
  472. pManager->NotifyAction(xtpPaneActionClosed, pPane);
  473. }
  475. pPane->InternalRelease();
  476. }
  477. }
  478. }
  480. void CXTPDockingPaneMiniWnd::OnSetFocus(CWnd* pOldWnd)
  481. {
  482. CMiniFrameWnd::OnSetFocus(pOldWnd);
  484. if (m_pTopContainer == 0)
  485. return;
  487. if (!m_pLayout || !m_pLayout->IsValid())
  488. return;
  490. CXTPDockingPaneBaseList lst;
  491. FindPane(xtpPaneTypeTabbedContainer, &lst);
  493. if (lst.GetCount() == 1)
  494. {
  495. CXTPDockingPane* pPane =
  496. ((CXTPDockingPaneTabbedContainer*)lst.GetHead())->GetSelected();
  497. if (pPane)
  498. {
  499. pPane->SetFocus();
  500. }
  501. }
  503. GetDockingPaneManager()->UpdatePanes();
  504. }
  506. void CXTPDockingPaneMiniWnd::PostNcDestroy()
  507. {
  508. // prevent auto deleting
  509. }
  511. void CXTPDockingPaneMiniWnd::FindPane(XTPDockingPaneType type, CXTPDockingPaneBaseList* pList) const
  512. {
  513. if (GetType() == type)
  514. {
  515. pList->AddTail((CXTPDockingPaneBase*)this);
  516. }
  517. else if (m_pTopContainer)
  518. {
  519. m_pTopContainer->FindPane(type, pList);
  520. }
  521. }
  523. void CXTPDockingPaneMiniWnd::OnContextMenu(CWnd* pWnd, CPoint point)
  524. {
  525. CXTPDockingPaneBaseList lst;
  526. FindPane(xtpPaneTypeTabbedContainer, &lst);
  528. CXTPDockingPane* pSelectedPane = 0;
  529. if (lst.GetCount() == 1)
  530. {
  531. pSelectedPane = ((CXTPDockingPaneTabbedContainer*)lst.GetHead())->GetSelected();
  532. }
  533. else
  534. {
  535. POSITION pos = lst.GetHeadPosition();
  536. while (pos)
  537. {
  538. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)lst.GetNext(pos);
  539. if (pContainer->IsActive())
  540. {
  541. pSelectedPane = pContainer->GetSelected();
  542. break;
  543. }
  544. }
  545. }
  547. if (pSelectedPane) pSelectedPane->SetFocus();
  548. XTP_DOCKINGPANE_CLICK menu;
  549. menu.pPane = pSelectedPane;
  550. menu.pt = point;
  551. menu.rcExclude.SetRectEmpty();
  552. menu.pContainer = this;
  554. if (GetDockingPaneManager()->NotifyOwner(XTP_DPN_CONTEXTMENU, (LPARAM)&menu))
  555. return;
  557. CMiniFrameWnd::OnContextMenu(pWnd, point);
  558. }
  560. void CXTPDockingPaneMiniWnd::OnNcRButtonUp(UINT nHitTest, CPoint point)
  561. {
  562. if (IsThemed() && (nHitTest == HTCAPTION))
  563. {
  564. OnContextMenu(this, point);
  565. return;
  566. }
  568. CMiniFrameWnd::OnNcRButtonUp(nHitTest, point);
  569. }
  571. void CXTPDockingPaneMiniWnd::OnNcLButtonDblClk(UINT nHitTest, CPoint /*point*/)
  572. {
  573. if (nHitTest == HTCAPTION)
  574. {
  575. if (m_bCollapsed)
  576. OnPinButtonClick();
  577. else
  578. GetDockingPaneManager()->ToggleDocking(m_pTopContainer);
  579. }
  580. }
  582. void CXTPDockingPaneMiniWnd::OnDestroy()
  583. {
  584. ::GetWindowRect(m_hWnd, &m_rcWindow);
  585. CWnd::OnDestroy();
  586. }
  589. BOOL CXTPDockingPaneMiniWnd::IsThemed() const
  590. {
  591. return GetDockingPaneManager()->IsThemedFloatingFrames();
  592. }
  594. //////////////////////////////////////////////////////////////////////////
  595. // Themed methods.
  597. LRESULT CXTPDockingPaneMiniWnd::OnNcHitTest(CPoint point)
  598. {
  599. LRESULT nHitTest = (LRESULT)CMiniFrameWnd::OnNcHitTest(point);
  601. if (!IsThemed())
  602. return nHitTest;
  604. CXTPWindowRect rcWindow(this);
  605. CRect rcBorders = rcWindow;
  606. rcBorders.DeflateRect(3, 3);
  608. if (rcWindow.PtInRect(point) && !rcBorders.PtInRect(point))
  609. {
  610. int ht = 0;
  612. if (point.y < rcBorders.top)
  613. ht = (HTTOP - HTSIZEFIRST + 1);
  614. else if (point.y >= rcBorders.bottom)
  615. ht = (HTBOTTOM - HTSIZEFIRST + 1);
  617. if (point.x < rcBorders.left)
  618. ht += (HTLEFT - HTSIZEFIRST + 1);
  619. else if (point.x >= rcBorders.right)
  620. ht += (HTRIGHT - HTSIZEFIRST + 1);
  622. return (LRESULT)(ht + HTSIZEFIRST - 1);
  623. }
  626. if (nHitTest == HTNOWHERE)
  627. {
  628. int nPoint = point.y - rcWindow.top;
  629. if (nPoint < GetPaintManager()->GetCaptionHeight() + 4)
  630. return HTCAPTION;
  631. }
  633. return nHitTest;
  634. }
  636. void CXTPDockingPaneMiniWnd::RedrawPane()
  637. {
  638. if (!IsThemed())
  639. return;
  641. if (GetSafeHwnd())
  642. ::InvalidateRect(GetSafeHwnd(), 0, FALSE);
  644. SendMessage(WM_NCPAINT);
  645. }
  647. void CXTPDockingPaneMiniWnd::OnNcPaint()
  648. {
  649. if (IsThemed())
  650. {
  651. CXTPWindowRect rc(this);
  652. rc.OffsetRect(-rc.TopLeft());
  653. CWindowDC dc(this);
  655. CXTPDockingPanePaintManager* pPaintManager = GetPaintManager();
  656. pPaintManager->DrawFloatingFrame(&dc, this, rc);
  657. }
  658. else
  659. {
  660. Default();
  661. }
  662. }
  664. BOOL CXTPDockingPaneMiniWnd::OnNcActivate(BOOL bActive)
  665. {
  666. if (IsThemed())
  667. {
  668. return TRUE;
  669. }
  671. return CMiniFrameWnd::OnNcActivate(bActive);
  672. }
  674. void CXTPDockingPaneMiniWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp)
  675. {
  676. if (IsThemed())
  677. {
  678. int nSize = 3;
  680. lpncsp->rgrc[0].left += nSize;
  681. lpncsp->rgrc[0].top += nSize;
  682. lpncsp->rgrc[0].right -= nSize;
  683. lpncsp->rgrc[0].bottom -= nSize;
  685. int nTitleFont = GetPaintManager()->GetCaptionHeight();
  686. lpncsp->rgrc[0].top += nTitleFont + 2;
  687. return;
  688. }
  690. CMiniFrameWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
  691. }
  693. void CXTPDockingPaneMiniWnd::OnNcMouseMove(UINT nHitTest, CPoint point)
  694. {
  695. CMiniFrameWnd::OnNcMouseMove(nHitTest, point);
  697. if (IsThemed())
  698. {
  699. CXTPDrawHelpers::ScreenToWindow(this, &point);
  701. if (m_pCaptionButtons->CheckForMouseOver(point))
  702. {
  703. SetTimer (TID_NCLEAVE, 100, NULL);
  704. }
  706. Expand();
  707. }
  708. }
  710. void CXTPDockingPaneMiniWnd::Collapse(BOOL bDelay)
  711. {
  712. m_nSlideStep = m_nStepsCount = ResetStepsCount();
  714. CWnd::GetWindowRect(&m_rcWindow);
  716. m_nExpandedHeight = m_rcWindow.Height();
  718. m_bCollapsed = TRUE;
  719. m_bExpanded = TRUE;
  721. if (!bDelay)
  722. {
  723. if (!OnAction(xtpPaneActionCollapsing))
  724. {
  725. m_nSlideStep = 0;
  726. DoSlideStep(FALSE);
  727. KillTimer(TID_SLIDEOUT);
  728. KillTimer(TID_CHECKACTIVE);
  729. OnAction(xtpPaneActionCollapsed);
  730. return;
  731. }
  732. }
  734. if (m_bSlideOut)
  735. {
  736. m_bSlideOut = FALSE;
  737. KillTimer(TID_SLIDEOUT);
  738. OnAction(xtpPaneActionCollapsed);
  739. }
  741. m_nDeactivationCount = 6;
  742. SetTimer(TID_CHECKACTIVE, 100, NULL);
  743. }
  745. void CXTPDockingPaneMiniWnd::OnCaptionButtonClick(CXTPDockingPaneCaptionButton* pButton)
  746. {
  747. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_CLOSE)
  748. {
  749. OnClose();
  750. return;
  751. }
  752. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_AUTOHIDE)
  753. {
  754. OnPinButtonClick();
  755. return;
  756. }
  757. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_MENU)
  758. {
  760. }
  761. }
  763. BOOL CXTPDockingPaneMiniWnd::OnCaptionButtonDown(CXTPDockingPaneCaptionButton* pButton)
  764. {
  765. switch (pButton->GetID())
  766. {
  767. case XTP_IDS_DOCKINGPANE_MENU:
  768. CXTPDockingPane* pSelectedPane = GetSelectedPane();
  769. if (pSelectedPane)
  770. {
  771. m_bActive = TRUE;
  773. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  774. XTP_DOCKINGPANE_CLICK menu;
  776. menu.pContainer = this;
  777. menu.rcExclude = pButton->GetRect();
  778. CXTPWindowRect rcWindow(this);
  780. if (GetExStyle() & WS_EX_LAYOUTRTL)
  781. {
  782. menu.rcExclude.OffsetRect(-menu.rcExclude.left + rcWindow.right - menu.rcExclude.right, rcWindow.top);
  783. menu.pt = CPoint(menu.rcExclude.right, menu.rcExclude.bottom);
  784. }
  785. else
  786. {
  787. menu.rcExclude.OffsetRect(rcWindow.left, rcWindow.top);
  788. menu.pt = CPoint(menu.rcExclude.left, menu.rcExclude.bottom);
  789. }
  791. menu.pPane = pSelectedPane;
  792. pButton->m_bPressed = TRUE;
  793. SendMessage(WM_NCPAINT);
  795. pManager->NotifyOwner(XTP_DPN_CONTEXTMENU, (LPARAM)&menu);
  797. pButton->m_bPressed = FALSE;
  798. if (m_hWnd) SendMessage(WM_NCPAINT);
  799. }
  800. return TRUE;
  802. }
  803. return FALSE;
  804. }
  806. BOOL CXTPDockingPaneMiniWnd::OnAction(XTPDockingPaneAction action)
  807. {
  808. if (m_pTopContainer)
  809. {
  810. return m_pTopContainer->OnAction(action);
  811. }
  813. return FALSE;
  814. }
  816. void CXTPDockingPaneMiniWnd::OnPinButtonClick()
  817. {
  818. if (!m_hWnd)
  819. return;
  821. BOOL bPinning = m_bCollapsed;
  823. if (OnAction(bPinning ? xtpPaneActionPinning : xtpPaneActionUnpinning))
  824. return;
  826. if (!m_bCollapsed)
  827. {
  828. Collapse(TRUE);
  829. }
  830. else
  831. {
  832. if (m_nStepsCount != m_nSlideStep)
  833. {
  834. CXTPWindowRect rcWindow(this);
  835. SetWindowPos(0, 0, 0, rcWindow.Width(), m_nExpandedHeight, SWP_NOZORDER | SWP_NOMOVE);
  836. }
  837. m_bCollapsed = FALSE;
  838. m_bExpanded = FALSE;
  840. KillTimer(TID_CHECKACTIVE);
  841. KillTimer(TID_SLIDEOUT);
  843. }
  844. SendMessage(WM_NCPAINT);
  846. OnAction(bPinning ? xtpPaneActionPinned : xtpPaneActionUnpinned);
  847. }
  849. void CXTPDockingPaneMiniWnd::DoSlideStep(BOOL bActivate)
  850. {
  851. int nMinHeight = GetPaintManager()->GetCaptionHeight() + 8;
  853. CXTPWindowRect rc(this);
  854. rc.bottom = rc.top + max(nMinHeight, m_nSlideStep * m_nExpandedHeight / m_nStepsCount);
  856. SetWindowPos(&CWnd::wndTop, rc.left, rc.top, rc.Width(), rc.Height(), (!bActivate ? SWP_NOZORDER | SWP_NOACTIVATE : SWP_NOACTIVATE));
  857. Invalidate(FALSE);
  858. }
  860. CXTPDockingPane* CXTPDockingPaneMiniWnd::GetSelectedPane() const
  861. {
  862. if (!m_pTopContainer)
  863. return 0;
  865. CXTPDockingPaneBaseList lst;
  866. FindPane(xtpPaneTypeTabbedContainer, &lst);
  867. int nCount = (int)lst.GetCount();
  868. if (nCount != 1)
  869. return 0;
  871. return ((CXTPDockingPaneTabbedContainer*)lst.GetHead())->GetSelected();
  872. }
  874. BOOL CXTPDockingPaneMiniWnd::IsCaptionButtonVisible(CXTPDockingPaneCaptionButton* pButton)
  875. {
  876. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_CLOSE)
  877. return m_bCloseEnabled;
  879. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_AUTOHIDE)
  880. {
  881. pButton->SetState(m_bCollapsed ? xtpPanePinPushed : 0);
  882. return m_bShowPinButton;
  883. }
  884. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_MENU)
  885. {
  886. CXTPDockingPane* pSelectedPane = GetSelectedPane();
  887. return pSelectedPane && (pSelectedPane->GetOptions() & xtpPaneHasMenuButton);
  888. }
  890. return TRUE;
  891. }
  894. void CXTPDockingPaneMiniWnd::OnNcLButtonDown(UINT nHitTest, CPoint point)
  895. {
  896. if (IsThemed())
  897. {
  898. CPoint ptClick(point);
  899. CXTPDrawHelpers::ScreenToWindow(this, &ptClick);
  901. for (int i = 0; i < m_pCaptionButtons->GetSize(); i++)
  902. {
  903. CXTPDockingPaneCaptionButton* pButton = m_pCaptionButtons->GetAt(i);
  904. if (pButton->PtInRect(ptClick))
  905. {
  906. if (!pButton->IsEnabled())
  907. return;
  909. if (OnCaptionButtonDown(pButton))
  910. return;
  912. if (pButton->Click(this, ptClick, FALSE))
  913. {
  914. OnCaptionButtonClick(pButton);
  915. }
  916. return;
  917. }
  918. }
  919. }
  921. if (nHitTest == HTCAPTION)
  922. {
  923. // special activation for floating toolbars
  924. ActivateTopParent();
  925. BringWindowToTop();
  927. CXTPDockingPaneContext* pContext = GetDockingPaneManager()->GetDockingContext();
  928. pContext->Drag(m_pTopContainer, point);
  930. return;
  931. }
  933. CMiniFrameWnd::OnNcLButtonDown(nHitTest, point);
  935. }
  937. void CXTPDockingPaneMiniWnd::OnTimer(UINT_PTR nIDEvent)
  938. {
  939. if (nIDEvent == TID_NCLEAVE)
  940. {
  941. CPoint pt;
  942. ::GetCursorPos (&pt);
  944. CXTPWindowRect rcCaption(this);
  945. rcCaption.bottom = rcCaption.top + GetPaintManager()->GetCaptionHeight() + 4;
  947. if (!rcCaption.PtInRect(pt))
  948. {
  949. m_pCaptionButtons->CheckForMouseOver(CPoint(-1, -1));
  951. KillTimer(TID_NCLEAVE);
  952. }
  953. }
  955. if (nIDEvent == TID_SLIDEOUT && m_bSlideOut)
  956. {
  957. m_nSlideStep--;
  959. if (m_nSlideStep > -1)
  960. DoSlideStep();
  961. else
  962. {
  963. m_bSlideOut = FALSE;
  964. m_bExpanded = FALSE;
  965. KillTimer(TID_SLIDEOUT);
  966. OnAction(xtpPaneActionCollapsed);
  967. }
  968. }
  970. if (nIDEvent == TID_CHECKACTIVE)
  971. {
  972. CPoint pt;
  973. GetCursorPos(&pt);
  975. CWnd* pFocus = GetFocus();
  976. BOOL bActive = (pFocus->GetSafeHwnd() && (pFocus == this || IsChild(pFocus)));
  978. if (!bActive && !m_bSlideOut && !CXTPWindowRect(this).PtInRect(pt) && ::GetCapture() == NULL)
  979. {
  980. if (--m_nDeactivationCount <= 0)
  981. {
  982. if (OnAction(xtpPaneActionCollapsing))
  983. {
  984. m_nDeactivationCount = 6;
  985. return;
  986. }
  988. if (m_nSlideStep == m_nStepsCount)
  989. {
  990. m_nExpandedHeight = CXTPWindowRect(this).Height();
  991. }
  993. m_bSlideOut = TRUE;
  994. SetTimer(TID_SLIDEOUT, CXTPDockingPaneAutoHideWnd::m_nAnimationInterval, NULL);
  996. KillTimer(TID_CHECKACTIVE);
  997. }
  998. }
  999. }
  1001. CMiniFrameWnd::OnTimer(nIDEvent);
  1002. }
  1006. void CXTPDockingPaneMiniWnd::OnThemedChanged()
  1007. {
  1008. if (!m_hWnd)
  1009. return;
  1011. ModifyStyle(IsThemed() ? WS_BORDER | WS_THICKFRAME: 0, IsThemed() ? 0 : WS_BORDER | WS_THICKFRAME, SWP_FRAMECHANGED);
  1013. if (!IsThemed() && m_bCollapsed)
  1014. {
  1015. OnPinButtonClick();
  1016. }
  1018. SetWindowPos(0, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
  1020. if (m_bCollapsed && IsThemed())
  1021. {
  1022. DoSlideStep();
  1023. }
  1024. }
  1028. void CXTPDockingPaneMiniWnd::Expand()
  1029. {
  1030. if (m_bCollapsed && m_nSlideStep <= 0)
  1031. {
  1032. if (m_bSlideOut)
  1033. {
  1034. m_bSlideOut = FALSE;
  1035. m_bExpanded = FALSE;
  1036. KillTimer(TID_SLIDEOUT);
  1037. OnAction(xtpPaneActionCollapsed);
  1038. }
  1040. if (OnAction(xtpPaneActionExpanding))
  1041. return;
  1043. m_bExpanded = TRUE;
  1044. m_nSlideStep = m_nStepsCount = ResetStepsCount();
  1045. DoSlideStep(TRUE);
  1047. m_nDeactivationCount = 8;
  1048. SetTimer(TID_CHECKACTIVE, 100, NULL);
  1050. OnAction(xtpPaneActionExpanded);
  1051. }
  1052. }
  1054. void CXTPDockingPaneMiniWnd::OnGetMinMaxInfo(MINMAXINFO* lpMMI)
  1055. {
  1056. CMiniFrameWnd::OnGetMinMaxInfo(lpMMI);
  1058. GetMinMaxInfo(lpMMI);
  1059. }
  1061. void CXTPDockingPaneMiniWnd::GetMinMaxInfo(LPMINMAXINFO lpMMI) const
  1062. {
  1063. if (m_pTopContainer && ((!m_bCollapsed || m_bExpanded) && !m_bSlideOut))
  1064. {
  1065. CXTPWindowRect rcWindow(this);
  1066. CXTPClientRect rcClient(this);
  1067. CSize szBorder = rcWindow.Size() - rcClient.Size();
  1069. MINMAXINFO mInfo;
  1070. m_pTopContainer->GetMinMaxInfo(&mInfo);
  1072. lpMMI->ptMinTrackSize.x = max(lpMMI->ptMinTrackSize.x, mInfo.ptMinTrackSize.x + szBorder.cx);
  1073. lpMMI->ptMinTrackSize.y = max(lpMMI->ptMinTrackSize.y, mInfo.ptMinTrackSize.y + szBorder.cy);
  1075. lpMMI->ptMaxTrackSize.x = min(lpMMI->ptMaxTrackSize.x, mInfo.ptMaxTrackSize.x + szBorder.cx);
  1076. lpMMI->ptMaxTrackSize.y = min(lpMMI->ptMaxTrackSize.y, mInfo.ptMaxTrackSize.y + szBorder.cy);
  1077. }
  1078. }
  1080. BOOL CXTPDockingPaneMiniWnd::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1081. {
  1082. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  1084. if (pManager)
  1085. {
  1086. pManager->GetToolTipContext()->FilterToolTipMessage(this, message, wParam, lParam);
  1087. }
  1089. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  1090. }
  1092. INT_PTR CXTPDockingPaneMiniWnd::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1093. {
  1095. ASSERT_VALID(this);
  1096. ASSERT(::IsWindow(m_hWnd));
  1098. if (!IsThemed())
  1099. return -1;
  1101. CXTPWindowRect rcWindow(this);
  1102. CPoint ptTopLeft(rcWindow.TopLeft());
  1103. ScreenToClient(&ptTopLeft);
  1105. if (GetExStyle() & WS_EX_LAYOUTRTL)
  1106. ptTopLeft.x -= rcWindow.Width();
  1108. for (int i = 0; i < m_pCaptionButtons->GetSize(); i++)
  1109. {
  1110. CXTPDockingPaneCaptionButton* pButton = m_pCaptionButtons->GetAt(i);
  1111. CRect rc = pButton->GetRect();
  1112. rc.OffsetRect(ptTopLeft);
  1114. if (rc.PtInRect(point))
  1115. {
  1116. INT_PTR nHit = (INT_PTR)pButton->GetID();
  1118. CString strTip;
  1119. XTPResourceManager()->LoadString(&strTip, (UINT)nHit);
  1121. if (strTip.GetLength() == 0)
  1122. return -1;
  1124. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, rc, nHit, strTip);
  1125. return nHit;
  1126. }
  1127. }
  1129. return -1;
  1130. }
  1132. void CXTPDockingPaneMiniWnd::DeletePane()
  1133. {
  1134. InternalRelease();
  1135. }
  1137. void CXTPDockingPaneMiniWnd::OnFinalRelease()
  1138. {
  1139. if (m_hWnd != NULL)
  1140. DestroyWindow();
  1142. CCmdTarget::OnFinalRelease();
  1143. }