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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPaneTabbedContainer.cpp：源码内容
  1. // XTPDockingPaneTabbedContainer.cpp : implementation of the CXTPDockingPaneTabbedContainer 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/XTPResourceManager.h"
  25. #include "Common/XTPVC80Helpers.h"
  26. #include "Common/XTPDrawHelpers.h"
  27. #include "Common/XTPToolTipContext.h"
  28. #include "TabManager/XTPTabManager.h"
  30. #include "XTPDockingPaneTabbedContainer.h"
  31. #include "XTPDockingPane.h"
  32. #include "XTPDockingPaneContext.h"
  33. #include "XTPDockingPaneManager.h"
  34. #include "XTPDockingPanePaintManager.h"
  35. #include "XTPDockingPaneLayout.h"
  36. #include "XTPDockingPaneAutoHidePanel.h"
  37. #include "XTPDockingPaneMiniWnd.h"
  38. #include "XTPDockingPaneSplitterContainer.h"
  39. #include "XTPDockingPaneSidePanel.h"
  41. #ifdef _DEBUG
  42. #define new DEBUG_NEW
  43. #undef THIS_FILE
  44. static char THIS_FILE[] = __FILE__;
  45. #endif
  48. //////////////////////////////////////////////////////////////////////////
  49. // CTabManagerDropTarget
  51. class CXTPDockingPaneTabbedContainer::CContainerDropTarget : public COleDropTarget
  52. {
  53. virtual DROPEFFECT OnDragOver(CWnd* pWnd, COleDataObject* /*pDataObject*/, DWORD /*dwKeyState*/, CPoint point)
  54. {
  55. CXTPDockingPaneTabbedContainer* pControl = (CXTPDockingPaneTabbedContainer*)pWnd;
  56. ASSERT_VALID(pControl);
  58. if (!pControl->GetPaintManager()->m_bSelectOnDragOver)
  59. return DROPEFFECT_NONE;
  61. CXTPTabManagerItem* pItem = pControl->CXTPTabManager::HitTest(point);
  63. if (pItem)
  64. {
  65. CXTPDockingPane* pPane = pControl->GetItemPane(pItem->GetIndex());
  66. if (pControl->GetSelected() != pPane)
  67. {
  68. pControl->SelectPane(pPane, FALSE, FALSE);
  69. }
  70. }
  72. return DROPEFFECT_NONE;
  73. }
  74. };
  76. // CXTPDockingPaneTabbedContainer
  78. void CXTPDockingPaneTabbedContainer::RedrawControl(LPCRECT lpRect, BOOL /*bAnimate*/)
  79. {
  80. if (!m_bLockReposition)
  81. {
  82. if (GetSafeHwnd()) InvalidateRect(lpRect, FALSE);
  83. }
  84. }
  85. void CXTPDockingPaneTabbedContainer::Reposition()
  86. {
  87. if (!m_bLockReposition)
  88. {
  89. GetDockingPaneManager()->RedrawPanes();
  90. }
  92. }
  93. CXTPTabPaintManager* CXTPDockingPaneTabbedContainer::GetPaintManager() const
  94. {
  95. return CXTPDockingPaneBase::GetPaintManager()->GetTabPaintManager();
  96. }
  98. void CXTPDockingPaneTabbedContainer::SetPaintManager(CXTPTabPaintManager* /*pPaintManager*/)
  99. {
  101. }
  103. BOOL CXTPDockingPaneTabbedContainer::DrawIcon(CDC* pDC, CPoint pt, CXTPTabManagerItem* pItem, BOOL bDraw, CSize& szIcon) const
  104. {
  105. if (!pItem)
  106. return TRUE;
  108. if (!CXTPDockingPaneBase::GetPaintManager()->GetTabPaintManager()->m_bShowIcons)
  109. return FALSE;
  111. CXTPImageManagerIcon* pImage = ((CXTPDockingPane*)pItem->GetData())->GetIcon(szIcon.cx);
  113. if (!pImage)
  114. return FALSE;
  116. if (!bDraw)
  117. {
  118. return TRUE;
  119. }
  121. pItem->DrawImage(pDC, CRect(pt, szIcon), pImage);
  123. return TRUE;
  124. }
  128. IMPLEMENT_DYNAMIC(CXTPDockingPaneTabbedContainer, CWnd)
  130. CXTPDockingPaneTabbedContainer::CXTPDockingPaneTabbedContainer(CXTPDockingPaneLayout* pLayout)
  131. : CXTPDockingPaneBaseContainer(xtpPaneTypeTabbedContainer, pLayout)
  132. {
  134. m_pSelectedPane = 0;
  135. m_pTrackingPane = 0;
  137. m_bLockReposition = FALSE;
  139. m_bActive = FALSE;
  140. m_bTitleVisible = TRUE;
  141. m_bDelayRedraw = FALSE;
  143. m_pCaptionButtons = new CXTPDockingPaneCaptionButtons();
  144. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_CLOSE, this));
  145. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_MAXIMIZE, this));
  146. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_RESTORE, this));
  147. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_AUTOHIDE, this));
  148. m_pCaptionButtons->Add(new CXTPDockingPaneCaptionButton(XTP_IDS_DOCKINGPANE_MENU, this));
  150. m_pDropTarget = new CContainerDropTarget();
  151. m_bMaximized = FALSE;
  153. EnableAutomation();
  155. }
  157. CXTPDockingPaneCaptionButton* CXTPDockingPaneTabbedContainer::GetCloseButton() const
  158. {
  159. return FindCaptionButton(XTP_IDS_DOCKINGPANE_CLOSE);
  160. }
  161. CXTPDockingPaneCaptionButton* CXTPDockingPaneTabbedContainer::GetPinButton() const
  162. {
  163. return FindCaptionButton(XTP_IDS_DOCKINGPANE_AUTOHIDE);
  164. }
  167. void CXTPDockingPaneTabbedContainer::Init(CXTPDockingPane* pPane, CWnd* pFrame)
  168. {
  169. ASSERT(pPane);
  170. if (!pPane)
  171. return;
  173. m_pDockingSite = pFrame;
  174. m_szDocking = pPane->m_szDocking;
  175. m_rcWindow = pPane->m_rcWindow;
  177. _InsertPane(pPane);
  178. SelectPane(pPane);
  179. }
  181. CXTPDockingPaneTabbedContainer::~CXTPDockingPaneTabbedContainer()
  182. {
  183. if (m_hWnd) DestroyWindow();
  185. delete m_pDropTarget;
  186. }
  188. void CXTPDockingPaneTabbedContainer::SetDockingSite(CWnd* pFrame)
  189. {
  190. m_pDockingSite = pFrame;
  192. if (m_hWnd && !pFrame->GetSafeHwnd())
  193. {
  194. pFrame = GetDockingPaneManager()->GetSite();
  195. }
  197. if (m_hWnd)
  198. {
  199. if (GetParent() != pFrame) CWnd::SetParent(pFrame);
  200. }
  202. POSITION pos = GetHeadPosition();
  203. while (pos)
  204. {
  205. CXTPDockingPane* pPane = (CXTPDockingPane*)GetNext(pos);
  206. pPane->SetDockingSite(m_pDockingSite);
  207. }
  209. }
  211. BOOL CXTPDockingPaneTabbedContainer::IsTabsVisible() const
  212. {
  213. return m_hWnd && !DYNAMIC_DOWNCAST(CXTPDockingPaneAutoHideWnd, GetParent())
  214. && (GetItemCount() > 1 || CXTPDockingPaneBase::GetPaintManager()->m_bDrawSingleTab);
  215. }
  217. void CXTPDockingPaneTabbedContainer::InvalidatePane(BOOL bSelectionChanged)
  218. {
  219. if (!GetSafeHwnd())
  220. return;
  222. if (m_pParentContainer == 0)
  223. return;
  225. if (m_bLockReposition)
  226. return;
  228. m_bLockReposition += 1;
  229. OnTabsChanged();
  230. m_bLockReposition -= 1;
  232. CRect rect = m_rcWindow;
  233. CXTPDockingPaneBase::GetPaintManager()->AdjustClientRect(this, rect, TRUE);
  235. if (bSelectionChanged)
  236. {
  237. POSITION pos = GetHeadPosition();
  238. while (pos)
  239. {
  240. CXTPDockingPane* pPane = (CXTPDockingPane*)GetNext(pos);
  241. pPane->ShowWindow(m_pSelectedPane == pPane);
  242. pPane->OnSizeParent(m_pDockingSite, rect, 0);
  243. }
  244. }
  245. Invalidate(FALSE);
  247. m_pParentContainer->InvalidatePane(bSelectionChanged);
  248. }
  250. void CXTPDockingPaneTabbedContainer::OnSizeParent(CWnd* pParent, CRect rect, LPVOID lParam)
  251. {
  252. AFX_SIZEPARENTPARAMS* lpLayout = (AFX_SIZEPARENTPARAMS*)lParam;
  254. ASSERT(!IsEmpty());
  256. SetDockingSite(pParent);
  257. m_rcWindow = rect;
  259. if (lpLayout == 0 || lpLayout->hDWP != NULL)
  260. {
  261. CRect rectOld;
  262. ::GetWindowRect(m_hWnd, rectOld);
  263. HWND hWndParent = ::GetParent(m_hWnd);
  264. ::ScreenToClient(hWndParent, &rectOld.TopLeft());
  265. ::ScreenToClient(hWndParent, &rectOld.BottomRight());
  266. if (rectOld != rect || m_bDelayRedraw)
  267. {
  268. SetWindowPos(&CWnd::wndBottom, rect.left, rect.top, rect.Width(), rect.Height(), 0);
  269. Invalidate(FALSE);
  270. m_bDelayRedraw = FALSE;
  271. }
  272. else
  273. {
  274. SetWindowPos(&CWnd::wndBottom, rect.left, rect.top, rect.Width(), rect.Height(), SWP_NOMOVE | SWP_NOSIZE);
  275. }
  277. m_bLockReposition += 1;
  278. OnTabsChanged();
  279. m_bLockReposition -= 1;
  281. GetPinButton()->SetState(IsHidden() ? xtpPanePinVisible | xtpPanePinPushed: DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, pParent) == 0 ? xtpPanePinVisible : 0);
  283. CXTPDockingPaneBase::GetPaintManager()->AdjustClientRect(this, rect, TRUE);
  285. POSITION pos = GetHeadPosition();
  286. while (pos)
  287. {
  288. CXTPDockingPane* pPane = (CXTPDockingPane*)GetNext(pos);
  289. pPane->ShowWindow(m_pSelectedPane == pPane);
  290. pPane->OnSizeParent(pParent, rect, lParam);
  291. }
  293. }
  294. }
  298. void CXTPDockingPaneTabbedContainer::OnTabsChanged()
  299. {
  300. if (!m_hWnd)
  301. return;
  303. m_bLockReposition += 1;
  305. DeleteAllItems();
  307. POSITION pos = GetHeadPosition();
  308. while (pos)
  309. {
  310. CXTPDockingPane* pPane = (CXTPDockingPane*)GetNext(pos);
  312. CXTPTabManagerItem* pItem = AddItem(GetItemCount());
  313. if (m_pSelectedPane == pPane) SetSelectedItem(pItem);
  315. pItem->SetCaption(pPane->GetShortTitle());
  316. pItem->SetColor(pPane->GetItemColor());
  317. pItem->SetTooltip(pPane->GetTitle());
  318. pItem->SetEnabled(pPane->GetEnabled() & xtpPaneEnableClient);
  320. pItem->SetData((DWORD_PTR)pPane);
  321. }
  322. //////////////////////////////////////////////////////////////////////////
  324. m_pCaptionButtons->CheckForMouseOver(CPoint(-1, -1));
  326. m_bLockReposition -= 1;
  327. }
  329. void CXTPDockingPaneTabbedContainer::CreateContainer()
  330. {
  331. SAFE_CALLPTR(m_pParentContainer, CreateContainer());
  333. if (!m_hWnd)
  334. {
  335. Create(_T("XTPDockingPaneTabbedContainer"), _T(""), WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD | WS_VISIBLE, CRect(0, 0, 0, 0), GetDockingSite(), 0);
  336. m_pDropTarget->Register(this);
  337. }
  338. }
  340. void CXTPDockingPaneTabbedContainer::_InsertPane(CXTPDockingPane* pPane, BOOL bSetFocus)
  341. {
  342. ASSERT(m_pLayout);
  343. if (!m_pLayout)
  344. return;
  346. if (!m_hWnd && !m_pLayout->IsUserLayout())
  347. {
  348. CreateContainer();
  349. }
  351. m_lstPanes.AddTail(pPane);
  353. pPane->SetParentContainer(this);
  354. pPane->SetDockingSite(GetDockingSite());
  356. m_bDelayRedraw = TRUE;
  357. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  359. SelectPane(pPane, bSetFocus);
  361. SAFE_CALLPTR(m_pParentContainer, OnChildContainerChanged(this));
  363. }
  365. void CXTPDockingPaneTabbedContainer::RemovePane(CXTPDockingPaneBase* pPane)
  366. {
  367. ASSERT(pPane->GetContainer() == this);
  369. POSITION pos = m_lstPanes.Find((CXTPDockingPane*)pPane);
  370. ASSERT(pos);
  372. m_lstPanes.RemoveAt(pos);
  373. OnTabsChanged();
  375. pPane->SetParentContainer(NULL);
  377. m_pParentContainer->OnChildContainerChanged(this);
  379. if (m_lstPanes.IsEmpty())
  380. {
  381. if (m_bActive)
  382. {
  383. GetDockingPaneManager()->GetSite()->SetFocus();
  384. m_bActive = FALSE;
  385. GetDockingPaneManager()->OnActivatePane(FALSE, m_pSelectedPane);
  386. }
  387. DestroyWindow();
  388. }
  390. m_bDelayRedraw = TRUE;
  391. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  393. if (pPane == m_pSelectedPane)
  394. {
  395. SelectPane((CXTPDockingPane*)GetLastPane());
  396. }
  397. }
  400. BEGIN_MESSAGE_MAP(CXTPDockingPaneTabbedContainer, CWnd)
  401. ON_WM_PAINT()
  402. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  403. ON_WM_LBUTTONDOWN()
  404. ON_WM_RBUTTONDOWN()
  405. ON_WM_RBUTTONUP()
  406. ON_WM_MOUSEMOVE()
  407. ON_WM_LBUTTONUP()
  408. ON_WM_CAPTURECHANGED()
  409. ON_WM_LBUTTONDBLCLK()
  410. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  411. ON_MESSAGE(WM_HELPHITTEST, OnHelpHitTest)
  412. ON_WM_DESTROY()
  413. ON_WM_SETCURSOR()
  414. ON_MESSAGE(WM_GETOBJECT, OnGetObject)
  415. END_MESSAGE_MAP()
  419. // CXTPDockingPaneTabbedContainer message handlers
  421. void CXTPDockingPaneTabbedContainer::OnDestroy()
  422. {
  423. CWnd::OnDestroy();
  424. }
  426. void CXTPDockingPaneTabbedContainer::DeletePane()
  427. {
  428. InternalRelease();
  429. }
  431. void CXTPDockingPaneTabbedContainer::OnFinalRelease()
  432. {
  433. if (m_hWnd != NULL)
  434. DestroyWindow();
  436. CCmdTarget::OnFinalRelease();
  437. }
  439. BOOL CXTPDockingPaneTabbedContainer::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  440. {
  441. if (GetDockingPaneManager()->m_bShowSizeCursorWhileDragging)
  442. {
  443. POINT pt;
  444. GetCursorPos(&pt);
  445. ScreenToClient(&pt);
  447. if (CXTPDockingPaneBase::GetPaintManager()->GetCaptionGripperRect(this).PtInRect(pt))
  448. {
  449. SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
  450. return TRUE;
  451. }
  453. }
  455. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  456. }
  459. LRESULT CXTPDockingPaneTabbedContainer::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  460. {
  461. CDC* pDC = CDC::FromHandle((HDC)wParam);
  462. if (pDC)
  463. {
  464. CXTPClientRect rc(this);
  465. CXTPDockingPaneBase::GetPaintManager()->DrawPane(pDC, this, rc);
  466. }
  468. return TRUE;
  469. }
  471. void CXTPDockingPaneTabbedContainer::OnPaint()
  472. {
  473. CPaintDC dcPaint(this);
  474. CXTPClientRect rc(this);
  475. CXTPBufferDC dc(dcPaint);
  477. CXTPDockingPaneBase::GetPaintManager()->DrawPane(&dc, this, rc);
  478. }
  481. void CXTPDockingPaneTabbedContainer::ShowTitle(BOOL bShow)
  482. {
  483. if (m_bTitleVisible != bShow)
  484. {
  485. m_bTitleVisible = bShow;
  487. m_bDelayRedraw = TRUE;
  488. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  489. }
  490. }
  492. BOOL CXTPDockingPaneTabbedContainer::IsTitleVisible() const
  493. {
  494. return m_bTitleVisible &&
  495. (m_pSelectedPane && ((m_pSelectedPane->GetOptions() & xtpPaneNoCaption) == 0)) &&
  496. CXTPDockingPaneBase::GetPaintManager()->m_bShowCaption;
  497. }
  500. CString CXTPDockingPaneTabbedContainer::GetTitle() const
  501. {
  502. return m_pSelectedPane ? m_pSelectedPane->GetTitle() : _T("");
  503. }
  505. void CXTPDockingPaneTabbedContainer::OnFocusChanged()
  506. {
  507. if (!GetSafeHwnd() || IsEmpty())
  508. return;
  510. CWnd* pFocus = GetFocus();
  511. BOOL bActive = (pFocus->GetSafeHwnd() && (pFocus == this || IsChild(pFocus) ||
  512. (pFocus->GetOwner()->GetSafeHwnd() && IsChild(pFocus->GetOwner()))));
  514. if (bActive != m_bActive)
  515. {
  516. m_bActive = bActive;
  518. GetDockingPaneManager()->OnActivatePane(bActive, m_pSelectedPane);
  520. Invalidate(FALSE);
  521. }
  522. else if (m_bActive && GetDockingPaneManager()->GetActivePane() != m_pSelectedPane)
  523. {
  524. GetDockingPaneManager()->OnActivatePane(bActive, m_pSelectedPane);
  525. }
  526. }
  528. #define DOCKINGPANE_HITCAPTION -2
  530. int CXTPDockingPaneTabbedContainer::HitTest(CPoint point) const
  531. {
  532. CXTPClientRect rc(this);
  534. if (IsTitleVisible())
  535. {
  536. if (rc.PtInRect(point))
  537. {
  538. CXTPDockingPaneBase::GetPaintManager()->AdjustCaptionRect(this, rc);
  539. if (!rc.PtInRect(point))
  540. {
  541. return DOCKINGPANE_HITCAPTION;
  542. }
  543. }
  544. }
  546. if (IsTabsVisible())
  547. {
  548. CXTPTabManagerItem* pItem = CXTPTabManager::HitTest(point);
  549. return pItem ? pItem->GetIndex() : -1;
  550. }
  551. return -1;
  552. }
  554. CXTPTabManagerItem* CXTPDockingPaneTabbedContainer::GetPaneTab(CXTPDockingPane* pPane) const
  555. {
  556. for (int i = 0; i < GetItemCount(); i++)
  557. {
  558. if (GetItemPane(i) == pPane)
  559. return GetItem(i);
  560. }
  561. return NULL;
  562. }
  564. void CXTPDockingPaneTabbedContainer::SelectPane(CXTPDockingPane* pPane, BOOL bSetFocus, BOOL bDelayRedraw)
  565. {
  566. if (m_pSelectedPane != pPane)
  567. {
  568. m_pSelectedPane = pPane;
  570. if (bDelayRedraw)
  571. {
  572. m_bDelayRedraw = TRUE;
  573. GetDockingPaneManager()->RecalcFrameLayout(this, TRUE);
  574. SAFE_CALLPTR(m_pParentContainer, OnChildContainerChanged(this));
  575. }
  576. else
  577. {
  578. InvalidatePane(TRUE);
  579. }
  581. CXTPTabManager::EnsureVisible(GetPaneTab(m_pSelectedPane));
  582. }
  584. if (bSetFocus)
  585. {
  586. if (m_bActive) GetDockingPaneManager()->OnActivatePane(TRUE, m_pSelectedPane);
  587. SAFE_CALLPTR(pPane, SetFocus());
  588. }
  590. }
  592. void CXTPDockingPaneTabbedContainer::OnRButtonUp(UINT /*nFlags*/, CPoint point)
  593. {
  594. XTP_DOCKINGPANE_CLICK menu;
  595. menu.pContainer = this;
  596. menu.pPane = GetItemPane(HitTest(point));
  597. if (!menu.pPane) menu.pPane = m_pSelectedPane;
  598. ClientToScreen(&point);
  599. menu.pt = point;
  600. menu.rcExclude.SetRectEmpty();
  602. if (GetDockingPaneManager()->NotifyOwner(XTP_DPN_CONTEXTMENU, (LPARAM)&menu))
  603. return;
  605. }
  607. void CXTPDockingPaneTabbedContainer::OnRButtonDown(UINT /*nFlags*/, CPoint point)
  608. {
  609. int nHit = HitTest(point);
  610. if (nHit >= 0)
  611. {
  612. SelectPane(GetItemPane(nHit));
  613. GetDockingPaneManager()->RecalcFrameLayout(this);
  614. }
  616. if (m_pSelectedPane)
  617. m_pSelectedPane->SetFocus();
  618. else
  619. SetFocus();
  621. GetDockingPaneManager()->UpdatePanes();
  623. GetDockingPaneManager()->NotifyOwner(XTP_DPN_RCLICK, (LPARAM)(CXTPDockingPaneBase*)this);
  624. }
  626. void CXTPDockingPaneTabbedContainer::OnCaptionLButtonDown(CPoint point)
  627. {
  628. _RestoreFocus();
  630. if (GetKeyState(VK_LBUTTON) < 0)
  631. {
  632. if (GetDockingPaneManager()->NotifyAction(xtpPaneActionDragging, m_pSelectedPane))
  633. return;
  635. CXTPDockingPaneContext* pContext = GetDockingPaneManager()->GetDockingContext();
  636. pContext->Drag(this, point);
  637. }
  638. }
  641. void CXTPDockingPaneTabbedContainer::NormalizeDockingSize()
  642. {
  643. XTPDockingPaneDirection direction = GetDockingPaneManager()->GetPaneDirection(this);
  644. BOOL bHoriz = (direction == xtpPaneDockLeft) || (direction == xtpPaneDockRight);
  646. if (bHoriz) m_szDocking.cx = m_rcWindow.Width();
  647. else m_szDocking.cy = m_rcWindow.Height();
  649. POSITION pos = GetHeadPosition();
  650. while (pos)
  651. {
  652. CXTPDockingPaneBase* pPane = GetNext(pos);
  653. if (!pPane->IsEmpty())
  654. {
  655. if (bHoriz) pPane->m_szDocking.cx = m_szDocking.cx;
  656. else pPane->m_szDocking.cy = m_szDocking.cy;
  657. }
  658. }
  659. }
  661. void CXTPDockingPaneTabbedContainer::OnCaptionButtonClick(CXTPDockingPaneCaptionButton* pButton)
  662. {
  663. CXTPDockingPane* pSelectedPane = m_pSelectedPane;
  665. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  667. switch (pButton->GetID())
  668. {
  669. case XTP_IDS_DOCKINGPANE_CLOSE:
  671. if (pManager->m_bCloseGroupOnButtonClick)
  672. {
  673. POSITION pos = m_lstPanes.GetTailPosition();
  674. while (pos)
  675. {
  676. CXTPDockingPane* pPane = (CXTPDockingPane*)m_lstPanes.GetPrev(pos);
  678. if ((pPane->GetOptions() & xtpPaneNoCloseable) != 0)
  679. continue;
  681. pPane->InternalAddRef();
  683. if (!pManager->NotifyAction(xtpPaneActionClosing, pPane))
  684. {
  685. pPane->Close();
  686. pManager->NotifyAction(xtpPaneActionClosed, pPane);
  687. }
  689. pPane->InternalRelease();
  690. }
  692. }
  693. else if (pSelectedPane)
  694. {
  695. pSelectedPane->InternalAddRef();
  696. if (!pManager->NotifyAction(xtpPaneActionClosing, pSelectedPane))
  697. {
  698. pSelectedPane->Close();
  699. pManager->NotifyAction(xtpPaneActionClosed, pSelectedPane);
  700. }
  701. pSelectedPane->InternalRelease();
  702. }
  703. break;
  706. case XTP_IDS_DOCKINGPANE_AUTOHIDE:
  708. if (!IsHidden())
  709. {
  710. if (!pManager->NotifyAction(xtpPaneActionUnpinning, pSelectedPane))
  711. {
  712. GetDockingSite()->SetFocus();
  713. NormalizeDockingSize();
  714. pSelectedPane->Hide();
  715. pManager->NotifyAction(xtpPaneActionUnpinned, pSelectedPane);
  716. }
  718. }
  719. else
  720. {
  721. GetDockingPaneManager()->ToggleDocking(pManager->m_bHideGroupOnButtonClick ?
  722. (CXTPDockingPaneBase*)this : (CXTPDockingPaneBase*)pSelectedPane);
  723. }
  725. break;
  727. case XTP_IDS_DOCKINGPANE_MAXIMIZE:
  728. Maximize();
  729. break;
  731. case XTP_IDS_DOCKINGPANE_RESTORE:
  732. Restore();
  733. break;
  735. }
  736. }
  738. BOOL CXTPDockingPaneTabbedContainer::OnCaptionButtonDown(CXTPDockingPaneCaptionButton* pButton)
  739. {
  740. switch (pButton->GetID())
  741. {
  742. case XTP_IDS_DOCKINGPANE_MENU:
  743. if (m_pSelectedPane)
  744. {
  745. InternalAddRef();
  747. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  748. XTP_DOCKINGPANE_CLICK menu;
  750. menu.pContainer = this;
  751. menu.rcExclude = pButton->GetRect();
  752. ClientToScreen(&menu.rcExclude);
  754. menu.pt = GetExStyle() & WS_EX_LAYOUTRTL ? CPoint(menu.rcExclude.right, menu.rcExclude.bottom) : CPoint(menu.rcExclude.left, menu.rcExclude.bottom);
  755. menu.pPane = m_pSelectedPane;
  756. pButton->m_bPressed = TRUE;
  757. Invalidate(FALSE);
  759. pManager->NotifyOwner(XTP_DPN_CONTEXTMENU, (LPARAM)&menu);
  761. pButton->m_bPressed = FALSE;
  762. if (m_hWnd) Invalidate(FALSE);
  764. InternalRelease();
  765. }
  766. return TRUE;
  768. }
  769. return FALSE;
  770. }
  773. void CXTPDockingPaneTabbedContainer::_RestoreFocus()
  774. {
  775. if (m_pSelectedPane)
  776. m_pSelectedPane->SetFocus();
  777. else
  778. SetFocus();
  780. GetDockingPaneManager()->UpdatePanes();
  781. }
  784. void CXTPDockingPaneTabbedContainer::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  785. {
  787. CXTPDockingPaneCaptionButton* pButton = HitTestCaptionButton(point);
  789. if (pButton)
  790. {
  791. _RestoreFocus();
  793. if (m_pSelectedPane && OnCaptionButtonDown(pButton))
  794. return;
  796. if (pButton->Click(this, point) && m_pSelectedPane)
  797. {
  798. OnCaptionButtonClick(pButton);
  799. }
  801. return;
  802. }
  804. if (IsTabsVisible() && PerformClick(m_hWnd, point, TRUE))
  805. return;
  807. int nHit = HitTest(point);
  808. if (nHit == DOCKINGPANE_HITCAPTION && !IsHidden())
  809. {
  810. ClientToScreen(&point);
  811. OnCaptionLButtonDown(point);
  812. }
  813. else if (nHit >= 0)
  814. {
  815. CXTPDockingPane* pPane = GetItemPane(nHit);
  816. if (GetDockingPaneManager()->NotifyAction(xtpPaneActionDragging, pPane))
  817. {
  818. SelectPane(pPane, TRUE, FALSE);
  819. PerformMouseMove(m_hWnd, point);
  820. Invalidate(FALSE);
  821. return;
  822. }
  824. m_lstRects.RemoveAll();
  825. for (int j = 0; j < GetItemCount(); j++)
  826. {
  827. CRect rc(GetItem(j)->GetRect());
  828. m_lstRects.Add(rc);
  829. }
  831. m_pTrackingPane = pPane;
  832. SelectPane(m_pTrackingPane, TRUE, FALSE);
  834. PerformMouseMove(m_hWnd, point);
  836. SetCapture();
  838. Invalidate(FALSE);
  839. }
  840. else
  841. {
  842. _RestoreFocus();
  843. }
  844. }
  846. CXTPDockingPane* CXTPDockingPaneTabbedContainer::GetItemPane(int nIndex) const
  847. {
  848. return nIndex >= 0 ? (CXTPDockingPane*)GetItem(nIndex)->GetData() : NULL;
  849. }
  851. void CXTPDockingPaneTabbedContainer::OnLButtonDblClk(UINT /*nFlags*/, CPoint point)
  852. {
  853. if (PerformClick(m_hWnd, point, TRUE))
  854. return;
  856. if (HitTestCaptionButton(point))
  857. return;
  859. int nHit = HitTest(point);
  860. if (nHit == DOCKINGPANE_HITCAPTION)
  861. {
  862. CXTPDockingPane* pSelected = GetSelected();
  864. if (IsHidden() && pSelected && ((pSelected->GetOptions() & xtpPaneNoHideable) != 0))
  865. return;
  867. if (!IsHidden() && pSelected && ((pSelected->GetOptions() & xtpPaneNoFloatableByCaptionDoubleClick) != 0))
  868. return;
  870. GetDockingPaneManager()->ToggleDocking(this);
  871. }
  872. else if (nHit >= 0)
  873. {
  874. CXTPDockingPane* pPane = GetItemPane(nHit);
  876. if ((pPane->GetOptions() & xtpPaneNoFloatableByTabDoubleClick) == 0)
  877. {
  878. GetDockingPaneManager()->ToggleDocking(pPane);
  879. }
  880. }
  882. }
  885. void CXTPDockingPaneTabbedContainer::_Swap(CXTPDockingPane* p1, CXTPDockingPane* p2)
  886. {
  887. POSITION pos1 = m_lstPanes.Find(p1);
  888. POSITION pos2 = m_lstPanes.Find(p2);
  889. ASSERT(pos1 && pos2);
  891. m_lstPanes.SetAt(pos1, p2);
  892. m_lstPanes.SetAt(pos2, p1);
  893. }
  895. void CXTPDockingPaneTabbedContainer::OnMouseMove(UINT nFlags, CPoint point)
  896. {
  897. PerformMouseMove(m_hWnd, point);
  899. if (m_pTrackingPane)
  900. {
  901. for (int i = 0; i < m_lstRects.GetSize(); i++)
  902. {
  903. if (GetItemPane(i) != m_pTrackingPane && m_lstRects[i].PtInRect(point))
  904. {
  905. _Swap(GetItemPane(i), m_pTrackingPane);
  907. InvalidatePane(TRUE);
  908. return;
  909. }
  910. }
  913. if (CXTPTabManager::HitTest(point) == NULL)
  914. {
  915. if (GetDockingPaneManager()->NotifyAction(xtpPaneActionDetaching, m_pTrackingPane))
  916. return;
  918. ASSERT(m_pSelectedPane == m_pTrackingPane);
  919. m_pTrackingPane = NULL;
  920. ReleaseCapture();
  922. ClientToScreen(&point);
  924. CXTPDockingPaneContext* pContext = GetDockingPaneManager()->GetDockingContext();
  925. pContext->Drag(m_pSelectedPane, point);
  926. }
  927. }
  928. else
  929. {
  930. m_pCaptionButtons->CheckForMouseOver(point);
  931. }
  933. CWnd::OnMouseMove(nFlags, point);
  934. }
  936. void CXTPDockingPaneTabbedContainer::OnMouseLeave()
  937. {
  938. OnMouseMove(0, CPoint(-1, -1));
  939. }
  941. void CXTPDockingPaneTabbedContainer::OnLButtonUp(UINT nFlags, CPoint point)
  942. {
  943. if (m_pTrackingPane)
  944. {
  945. m_pTrackingPane = NULL;
  946. if (GetCapture() == this) ReleaseCapture();
  947. }
  949. CWnd::OnLButtonUp(nFlags, point);
  950. }
  952. void CXTPDockingPaneTabbedContainer::OnCaptureChanged(CWnd* pWnd)
  953. {
  954. m_pTrackingPane = NULL;
  955. CWnd::OnCaptureChanged(pWnd);
  956. }
  958. void CXTPDockingPaneTabbedContainer::OnParentContainerChanged(CXTPDockingPaneBase* pContainer)
  959. {
  960. m_pDockingSite = pContainer->m_pDockingSite;
  961. m_bTitleVisible = TRUE;
  962. if (pContainer->GetType() == xtpPaneTypeAutoHidePanel)
  963. {
  964. if (m_hWnd) ShowWindow(SW_HIDE); //?
  965. }
  966. }
  968. BOOL CXTPDockingPaneTabbedContainer::CanAttach(CRect& rcClient, CPoint pt) const
  969. {
  970. CRect rcTitle(rcClient);
  971. BOOL bVertical = IsCaptionVertical();
  973. if (m_bTitleVisible)
  974. {
  975. if (bVertical)
  976. {
  977. rcClient.left += CXTPDockingPaneBase::GetPaintManager()->GetCaptionHeight() + 3;
  978. }
  979. else
  980. {
  981. rcClient.top += CXTPDockingPaneBase::GetPaintManager()->GetCaptionHeight() + 3;
  982. }
  983. }
  984. else
  985. {
  986. SAFE_CALLPTR(m_pDockingSite, GetWindowRect(rcTitle));
  987. }
  989. if (bVertical)
  990. {
  991. rcTitle.right = rcClient.left;
  992. }
  993. else
  994. {
  995. rcTitle.bottom = rcClient.top;
  996. }
  998. if (rcTitle.PtInRect(pt))
  999. return TRUE;
  1001. if (IsTabsVisible())
  1002. {
  1003. CRect rcTabs(rcClient);
  1004. rcClient.bottom -= CXTPDockingPaneBase::GetPaintManager()->GetTabsHeight();
  1005. rcTabs.top = rcClient.bottom;
  1007. if (rcTabs.PtInRect(pt))
  1008. return TRUE;
  1009. }
  1011. return FALSE;
  1012. }
  1014. void CXTPDockingPaneTabbedContainer::Copy(CXTPDockingPaneBase* pCloneBase, CXTPPaneToPaneMap* pMap, DWORD dwIgnoredOptions)
  1015. {
  1016. CXTPDockingPaneTabbedContainer* pClone = (CXTPDockingPaneTabbedContainer*)pCloneBase;
  1017. ASSERT(pClone);
  1018. if (!pClone)
  1019. return;
  1021. m_bActive = FALSE;
  1022. m_pDockingSite = GetDockingPaneManager()->GetSite();
  1023. m_pSelectedPane = m_pTrackingPane = NULL;
  1025. m_rcWindow = pClone->m_rcWindow;
  1026. m_szDocking = pClone->m_szDocking;
  1027. m_bTitleVisible = TRUE;
  1028. m_bLockReposition = FALSE;
  1030. if (pClone->m_pLayout != m_pLayout)
  1031. {
  1032. m_bMaximized = pClone->m_bMaximized;
  1033. }
  1035. CXTPDockingPane* pSelected = NULL;
  1036. if (pMap)
  1037. {
  1038. POSITION pos = pClone->GetHeadPosition();
  1039. while (pos)
  1040. {
  1041. CXTPDockingPane* pPane = (CXTPDockingPane*)pClone->GetNext(pos);
  1042. CXTPDockingPane* pNewPane = (CXTPDockingPane*)pPane->Clone(m_pLayout, pMap);
  1043. if (pClone->GetSelected() == pPane) pSelected = pNewPane;
  1044. _InsertPane(pNewPane);
  1045. }
  1046. }
  1047. else
  1048. {
  1050. POSITION pos = pClone->m_lstPanes.GetHeadPosition();
  1051. while (pos)
  1052. {
  1053. CXTPDockingPane* pPane = (CXTPDockingPane*)pClone->GetNext(pos);
  1055. ASSERT(pPane->GetType() == xtpPaneTypeDockingPane);
  1057. if ((((CXTPDockingPane*)pPane)->GetOptions() & dwIgnoredOptions) == 0)
  1058. {
  1059. if (pClone->GetSelected() == pPane && pSelected == NULL) pSelected = pPane;
  1061. pPane->m_pParentContainer->RemovePane(pPane);
  1062. _InsertPane(pPane);
  1063. }
  1064. }
  1065. }
  1066. if (pSelected) SelectPane(pSelected, FALSE);
  1069. }
  1071. BOOL CXTPDockingPaneTabbedContainer::IsHidden() const
  1072. {
  1073. return GetContainer() && GetContainer()->GetType() == xtpPaneTypeAutoHidePanel;
  1074. }
  1076. void CXTPDockingPaneTabbedContainer::Show(BOOL bSetFocus)
  1077. {
  1078. if (m_pSelectedPane &&m_pParentContainer &&
  1079. m_pParentContainer->GetType() == xtpPaneTypeAutoHidePanel)
  1080. {
  1081. ((CXTPDockingPaneAutoHidePanel*)m_pParentContainer)->ShowPane(m_pSelectedPane, bSetFocus);
  1082. }
  1083. else if (DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, GetParentFrame()))
  1084. {
  1085. ((CXTPDockingPaneMiniWnd*)GetParentFrame())->Expand();
  1086. }
  1087. }
  1089. void CXTPDockingPaneTabbedContainer::ShowPane(CXTPDockingPane* pPane, BOOL bSetFocus)
  1090. {
  1091. ASSERT(pPane);
  1093. if (m_pParentContainer && m_pParentContainer->GetType() == xtpPaneTypeAutoHidePanel)
  1094. {
  1095. ((CXTPDockingPaneAutoHidePanel*)m_pParentContainer)->ShowPane(pPane, bSetFocus);
  1096. }
  1097. else
  1098. {
  1099. SelectPane(pPane, bSetFocus);
  1101. if (DYNAMIC_DOWNCAST(CXTPDockingPaneMiniWnd, GetParentFrame()))
  1102. ((CXTPDockingPaneMiniWnd*)GetParentFrame())->Expand();
  1104. if (m_pParentContainer && m_pParentContainer->GetType() == xtpPaneTypeSidePanel)
  1105. {
  1106. ((CXTPDockingPaneSidePanel*)m_pParentContainer)->Expand();
  1107. }
  1108. }
  1110. }
  1112. BOOL CXTPDockingPaneTabbedContainer::IsAllowMaximize() const
  1113. {
  1114. if (!m_pParentContainer || m_pParentContainer->GetType() != xtpPaneTypeSplitterContainer)
  1115. return FALSE;
  1117. if (!GetDockingPaneManager()->IsCaptionMaximizeButtonsVisible())
  1118. return FALSE;
  1120. CXTPDockingPaneBaseList lst;
  1121. ((CXTPDockingPaneSplitterContainer*)m_pParentContainer)->FindChildPane(xtpPaneTypeTabbedContainer, &lst);
  1123. return lst.GetCount() > 1;
  1124. }
  1126. void CXTPDockingPaneTabbedContainer::Maximize()
  1127. {
  1128. if (!m_pDockingSite || !m_pParentContainer)
  1129. return;
  1131. CXTPDockingPaneBaseList lst;
  1132. ((CXTPDockingPaneSplitterContainer*)m_pParentContainer)->FindChildPane(xtpPaneTypeTabbedContainer, &lst);
  1133. POSITION pos = lst.GetHeadPosition();
  1134. while (pos)
  1135. {
  1136. CXTPDockingPaneTabbedContainer* pTabbedContainer = (CXTPDockingPaneTabbedContainer*)lst.GetNext(pos);
  1137. pTabbedContainer->m_bMaximized = pTabbedContainer == this;
  1138. }
  1140. GetDockingPaneManager()->RecalcFrameLayout(this);
  1141. }
  1143. void CXTPDockingPaneTabbedContainer::Restore()
  1144. {
  1145. if (!m_pDockingSite || !m_pParentContainer)
  1146. return;
  1148. m_bMaximized = FALSE;
  1149. GetDockingPaneManager()->RecalcFrameLayout(this);
  1150. }
  1152. BOOL CXTPDockingPaneTabbedContainer::IsPaneMaximized() const
  1153. {
  1154. if (!IsAllowMaximize())
  1155. return FALSE;
  1157. return m_bMaximized;
  1158. }
  1160. BOOL CXTPDockingPaneTabbedContainer::IsPaneRestored() const
  1161. {
  1162. if (!IsAllowMaximize())
  1163. return FALSE;
  1165. return !m_bMaximized;
  1166. }
  1168. BOOL CXTPDockingPaneTabbedContainer::IsPaneMinimized() const
  1169. {
  1170. if (m_bMaximized)
  1171. return FALSE;
  1173. if (!m_pParentContainer || m_pParentContainer->GetType() != xtpPaneTypeSplitterContainer)
  1174. return FALSE;
  1176. if (!GetDockingPaneManager()->IsCaptionMaximizeButtonsVisible())
  1177. return FALSE;
  1179. CXTPDockingPaneBaseList lst;
  1180. ((CXTPDockingPaneSplitterContainer*)m_pParentContainer)->FindChildPane(xtpPaneTypeTabbedContainer, &lst);
  1181. POSITION pos = lst.GetHeadPosition();
  1182. while (pos)
  1183. {
  1184. CXTPDockingPaneTabbedContainer* pTabbedContainer = (CXTPDockingPaneTabbedContainer*)lst.GetNext(pos);
  1185. if (pTabbedContainer->m_bMaximized)
  1186. return TRUE;
  1187. }
  1188. return FALSE;
  1189. }
  1193. BOOL CXTPDockingPaneTabbedContainer::IsCaptionButtonVisible(CXTPDockingPaneCaptionButton* pButton)
  1194. {
  1195. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_CLOSE)
  1196. return m_pSelectedPane && ((m_pSelectedPane->GetOptions() & xtpPaneNoCloseable) == 0);
  1198. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_AUTOHIDE)
  1199. return m_pSelectedPane && ((m_pSelectedPane->GetOptions() & xtpPaneNoHideable) == 0) && (pButton->GetState() & xtpPanePinVisible);
  1201. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_MAXIMIZE)
  1202. return IsPaneRestored();
  1204. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_RESTORE)
  1205. return IsPaneMaximized();
  1207. if (pButton->GetID() == XTP_IDS_DOCKINGPANE_MENU)
  1208. return m_pSelectedPane && (m_pSelectedPane->GetOptions() & xtpPaneHasMenuButton);
  1210. return TRUE;
  1211. }
  1214. LRESULT CXTPDockingPaneTabbedContainer::OnHelpHitTest(WPARAM, LPARAM lParam)
  1215. {
  1216. CXTPDockingPane* pPane = GetSelected();
  1217. CPoint point((DWORD)lParam);
  1219. int nHit = HitTest(point);
  1221. if (nHit >= 0)
  1222. {
  1223. pPane = GetItemPane(nHit);
  1224. }
  1226. if (!pPane)
  1227. return 0;
  1229. int nIDHelp = pPane->m_nIDHelp;
  1231. if (nIDHelp == 0)
  1232. {
  1233. pPane->m_hwndChild ? (int)::GetDlgCtrlID(pPane->m_hwndChild): 0;
  1234. }
  1236. if (nIDHelp == 0)
  1237. {
  1238. nIDHelp = pPane->GetID();
  1239. }
  1241. return HID_BASE_RESOURCE + nIDHelp;
  1242. }
  1244. CXTPDockingPaneCaptionButton* CXTPDockingPaneTabbedContainer::HitTestCaptionButton(CPoint point) const
  1245. {
  1246. if (IsTitleVisible())
  1247. {
  1248. for (int i = 0; i < m_pCaptionButtons->GetSize(); i++)
  1249. {
  1250. CXTPDockingPaneCaptionButton* pButton = m_pCaptionButtons->GetAt(i);
  1251. if (pButton->PtInRect(point))
  1252. return pButton->IsEnabled() ? pButton : NULL;
  1253. }
  1254. }
  1256. return NULL;
  1257. }
  1259. INT_PTR CXTPDockingPaneTabbedContainer::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1260. {
  1262. ASSERT_VALID(this);
  1263. ASSERT(::IsWindow(m_hWnd));
  1265. // check child windows first by calling CControlBar
  1266. INT_PTR nHit = CWnd::OnToolHitTest(point, pTI);
  1267. if (nHit != -1)
  1268. return nHit;
  1270. CXTPDockingPaneCaptionButton* pButton = HitTestCaptionButton(point);
  1272. if (pButton)
  1273. {
  1274. nHit = (INT_PTR)pButton->GetID();
  1275. CString strTip;
  1276. XTPResourceManager()->LoadString(&strTip, (UINT)nHit);
  1278. if (strTip.GetLength() == 0)
  1279. return -1;
  1281. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, pButton->GetRect(), nHit, strTip);
  1283. return nHit;
  1284. }
  1286. return PerformToolHitTest(m_hWnd, point, pTI);
  1287. }
  1289. void CXTPDockingPaneTabbedContainer::AdjustMinMaxInfoClientRect(LPMINMAXINFO pMinMaxInfo, BOOL bCaptionOnly) const
  1290. {
  1291. CRect rc(0, 0, 1000, 1000);
  1292. if (bCaptionOnly)
  1293. {
  1294. CXTPDockingPaneBase::GetPaintManager()->AdjustCaptionRect(this, rc);
  1295. }
  1296. else
  1297. {
  1298. CXTPDockingPaneBase::GetPaintManager()->AdjustClientRect((CXTPDockingPaneTabbedContainer*)this, rc, FALSE);
  1299. }
  1301. pMinMaxInfo->ptMinTrackSize.x += 1000 - rc.Width();
  1302. pMinMaxInfo->ptMinTrackSize.y += 1000 - rc.Height();
  1304. pMinMaxInfo->ptMaxTrackSize.x += 1000 - rc.Width();
  1305. pMinMaxInfo->ptMaxTrackSize.y += 1000 - rc.Height();
  1307. }
  1309. void CXTPDockingPaneTabbedContainer::GetMinMaxInfo(LPMINMAXINFO pMinMaxInfo) const
  1310. {
  1311. CXTPDockingPaneBase::GetMinMaxInfo(pMinMaxInfo);
  1313. if (IsEmpty())
  1314. return;
  1316. if (IsPaneMinimized())
  1317. {
  1318. if (((CXTPDockingPaneSplitterContainer*)m_pParentContainer)->IsHoriz())
  1319. pMinMaxInfo->ptMaxTrackSize.x = 0;
  1320. else
  1321. pMinMaxInfo->ptMaxTrackSize.y = 0;
  1323. AdjustMinMaxInfoClientRect(pMinMaxInfo, FALSE);
  1324. }
  1325. else
  1326. {
  1327. POSITION pos = GetHeadPosition();
  1328. while (pos)
  1329. {
  1330. CXTPDockingPaneBase* pPane = GetNext(pos);
  1332. MINMAXINFO info;
  1333. pPane->GetMinMaxInfo(&info);
  1335. pMinMaxInfo->ptMinTrackSize.x = max(pMinMaxInfo->ptMinTrackSize.x, info.ptMinTrackSize.x);
  1336. pMinMaxInfo->ptMinTrackSize.y = max(pMinMaxInfo->ptMinTrackSize.y, info.ptMinTrackSize.y);
  1338. pMinMaxInfo->ptMaxTrackSize.x = min(pMinMaxInfo->ptMaxTrackSize.x, info.ptMaxTrackSize.x);
  1339. pMinMaxInfo->ptMaxTrackSize.y = min(pMinMaxInfo->ptMaxTrackSize.y, info.ptMaxTrackSize.y);
  1340. }
  1341. AdjustMinMaxInfoClientRect(pMinMaxInfo);
  1342. }
  1343. }
  1346. BOOL CXTPDockingPaneTabbedContainer::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1347. {
  1348. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  1350. if (pManager)
  1351. {
  1352. pManager->GetToolTipContext()->FilterToolTipMessage(this, message, wParam, lParam);
  1353. }
  1355. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  1356. }
  1359. BOOL CXTPDockingPaneTabbedContainer::IsCaptionVertical() const
  1360. {
  1361. CXTPDockingPaneManager* pManager = GetDockingPaneManager();
  1363. switch (pManager->GetCaptionDirection())
  1364. {
  1365. case xtpPaneCaptionHorizontal:
  1366. return FALSE;
  1368. case xtpPaneCaptionAutoBySize:
  1369. return m_rcWindow.Width() > m_rcWindow.Height();
  1371. case xtpPaneCaptionAutoByPosition:
  1372. XTPDockingPaneDirection direction = pManager->GetPaneDirection(this);
  1373. return (direction == xtpPaneDockTop) || (direction == xtpPaneDockBottom);
  1375. }
  1376. return TRUE;
  1377. }
  1379. //////////////////////////////////////////////////////////////////////////
  1380. // Accessible
  1382. CCmdTarget* CXTPDockingPaneTabbedContainer::GetAccessible()
  1383. {
  1384. return this;
  1385. }
  1387. HRESULT CXTPDockingPaneTabbedContainer::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  1388. {
  1389. *ppdispParent = NULL;
  1391. if (GetSafeHwnd())
  1392. {
  1393. return AccessibleObjectFromWindow(GetSafeHwnd(), OBJID_WINDOW, IID_IDispatch, (void**)ppdispParent);
  1394. }
  1395. return E_FAIL;
  1396. }
  1398. HRESULT CXTPDockingPaneTabbedContainer::GetAccessibleChildCount(long FAR* pChildCount)
  1399. {
  1400. if (pChildCount == 0)
  1401. return E_INVALIDARG;
  1403. *pChildCount = GetItemCount() + 1;
  1405. return S_OK;
  1406. }
  1408. HRESULT CXTPDockingPaneTabbedContainer::GetAccessibleChild(VARIANT varChild, IDispatch* FAR* ppdispChild)
  1409. {
  1410. *ppdispChild = NULL;
  1411. int nChild = GetChildIndex(&varChild);
  1413. if (nChild == 1 && GetSelected())
  1414. return AccessibleObjectFromWindow(GetSelected()->m_hwndChild, OBJID_WINDOW, IID_IDispatch, (void**)ppdispChild);
  1416. if (nChild > 1 && nChild <= GetItemCount() + 1)
  1417. {
  1418. CXTPDockingPane* pPane = GetItemPane(nChild - 2);
  1419. if (pPane)
  1420. {
  1421. *ppdispChild = pPane->GetIDispatch(TRUE);
  1422. }
  1423. }
  1425. return S_OK;
  1426. }
  1428. HRESULT CXTPDockingPaneTabbedContainer::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  1429. {
  1430. int nChild = GetChildIndex(&varChild);
  1432. if (nChild == CHILDID_SELF || nChild == -1)
  1433. {
  1434. *pszName = SysAllocString(L"XTPDockingPaneTabbedContainer");
  1435. return S_OK;
  1436. }
  1438. return E_INVALIDARG;
  1439. }
  1441. HRESULT CXTPDockingPaneTabbedContainer::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  1442. {
  1443. pvarRole->vt = VT_EMPTY;
  1444. int nChild = GetChildIndex(&varChild);
  1446. if (nChild == CHILDID_SELF)
  1447. {
  1448. pvarRole->vt = VT_I4;
  1449. pvarRole->lVal = ROLE_SYSTEM_PAGETABLIST;
  1450. return S_OK;
  1451. }
  1453. return E_INVALIDARG;
  1454. }
  1456. HRESULT CXTPDockingPaneTabbedContainer::GetAccessibleState(VARIANT /*varChild*/, VARIANT* pvarState)
  1457. {
  1458. pvarState->vt = VT_I4;
  1459. pvarState->lVal = 0;
  1461. return S_OK;
  1462. }
  1465. HRESULT CXTPDockingPaneTabbedContainer::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  1466. {
  1467. *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
  1469. if (!GetSafeHwnd())
  1470. return S_OK;
  1472. int nChild = GetChildIndex(&varChild);
  1474. if (nChild != CHILDID_SELF)
  1475. return E_INVALIDARG;
  1477. CRect rc;
  1478. GetWindowRect(&rc);
  1480. *pxLeft = rc.left;
  1481. *pyTop = rc.top;
  1482. *pcxWidth = rc.Width();
  1483. *pcyHeight = rc.Height();
  1485. return S_OK;
  1486. }
  1488. HRESULT CXTPDockingPaneTabbedContainer::AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarID)
  1489. {
  1490. if (pvarID == NULL)
  1491. return E_INVALIDARG;
  1493. pvarID->vt = VT_EMPTY;
  1495. if (!GetSafeHwnd())
  1496. return S_FALSE;
  1498. if (!CXTPWindowRect(this).PtInRect(CPoint(xLeft, yTop)))
  1499. return S_FALSE;
  1501. CPoint pt(xLeft, yTop);
  1502. ScreenToClient(&pt);
  1504. int nItem = HitTest(pt);
  1505. if (nItem == DOCKINGPANE_HITCAPTION)
  1506. {
  1507. pvarID->vt = VT_I4;
  1508. pvarID->lVal = 0;
  1509. return S_OK;
  1510. }
  1512. if (nItem == -1)
  1513. {
  1514. pvarID->vt = VT_DISPATCH;
  1515. if (GetSelected())
  1516. return AccessibleObjectFromWindow(GetSelected()->m_hwndChild, OBJID_WINDOW, IID_IDispatch, (void**)&pvarID->pdispVal);
  1518. return S_FALSE;
  1519. }
  1521. pvarID->vt = VT_DISPATCH;
  1522. pvarID->pdispVal = GetItemPane(nItem)->GetIDispatch(TRUE);
  1524. return S_OK;
  1525. }
  1528. LRESULT CXTPDockingPaneTabbedContainer::OnGetObject(WPARAM wParam, LPARAM lParam)
  1529. {
  1530. if (lParam != OBJID_CLIENT)
  1531. return (LRESULT)Default();
  1533. LPUNKNOWN lpUnknown = GetInterface(&IID_IAccessible);
  1534. if (!lpUnknown)
  1535. return E_FAIL;
  1537. return LresultFromObject(IID_IAccessible, wParam, lpUnknown);
  1538. }
  1541. BEGIN_INTERFACE_MAP(CXTPDockingPaneTabbedContainer, CCmdTarget)
  1542. INTERFACE_PART(CXTPDockingPaneTabbedContainer, IID_IAccessible, ExternalAccessible)
  1543. END_INTERFACE_MAP()