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

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

对话框与窗口

开发平台：

Visual C++

XTPDockingPane.cpp：源码内容
  1. // XTPDockingPane.cpp : implementation of the CXTPDockingPaneclass.
  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 "TabManager/XTPTabManager.h"
  23. #include "Common/XTPDrawHelpers.h"
  25. #include "XTPDockingPane.h"
  26. #include "XTPDockingPaneContext.h"
  27. #include "XTPDockingPaneManager.h"
  28. #include "XTPDockingPaneTabbedContainer.h"
  29. #include "XTPDockingPaneAutoHidePanel.h"
  30. #include "XTPDockingPaneMiniWnd.h"
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  38. CXTPDockingPane::CXTPDockingPane(CXTPDockingPaneLayout* pLayout)
  39. : CXTPDockingPaneBase(xtpPaneTypeDockingPane, pLayout)
  40. {
  41. m_dwOptions = 0;
  42. m_hwndChild = 0;
  43. m_nID = 0;
  44. m_nIconID = -1;
  45. m_dwData = 0;
  46. m_clrItemTab = COLORREF_NULL;
  47. m_nIDHelp = 0;
  48. m_bEnabled = xtpPaneEnabled;
  50. m_ptMinTrackSize = CPoint(0, 0);
  51. m_ptMaxTrackSize = CPoint(32000, 32000);
  53. EnableAutomation();
  56. }
  58. CXTPDockingPane::~CXTPDockingPane()
  59. {
  61. }
  63. void CXTPDockingPane::SetID(int nID)
  64. {
  65. ASSERT(nID != 0);
  67. m_nID = nID;
  68. CString strTitle;
  69. if (strTitle.LoadString(nID))
  70. {
  71. m_strTitle = strTitle;
  72. }
  74. }
  76. void CXTPDockingPane::SetWindowRect(CRect rc)
  77. {
  78. m_rcWindow = rc;
  79. m_szDocking = m_rcWindow.Size();
  80. }
  82. XTPXTPDockingPaneEnableOptions CXTPDockingPane::GetEnabled() const
  83. {
  84. return m_bEnabled;
  85. }
  87. void CXTPDockingPane::SetEnabled(XTPXTPDockingPaneEnableOptions bEnabled)
  88. {
  89. if (m_bEnabled != bEnabled)
  90. {
  91. m_bEnabled = bEnabled;
  92. InvalidatePane(TRUE);
  93. }
  94. }
  96. void CXTPDockingPane::OnSizeParent(CWnd* pParent, CRect rect, LPVOID lParam)
  97. {
  98. AFX_SIZEPARENTPARAMS* lpLayout = (AFX_SIZEPARENTPARAMS*)lParam;
  99. SetDockingSite(pParent);
  101. if (lpLayout == 0 || lpLayout->hDWP != NULL)
  102. {
  103. m_rcWindow = rect;
  105. if (pParent && m_pParentContainer)
  106. {
  107. MapWindowPoints(pParent->GetSafeHwnd(), m_pParentContainer->GetPaneHwnd(), (LPPOINT)&rect, 2);
  108. if (m_hwndChild) ::MoveWindow(m_hwndChild, rect.left, rect.top, rect.Width(), rect.Height(), TRUE);
  109. if (m_hwndChild) ::EnableWindow(m_hwndChild, m_bEnabled & xtpPaneEnableClient ? TRUE : FALSE);
  110. }
  111. }
  112. }
  114. void CXTPDockingPane::SetFocus()
  115. {
  116. if (m_hwndChild)
  117. {
  118. if (!IsChild(m_hwndChild, ::GetFocus()))
  119. ::SetFocus(m_hwndChild);
  120. }
  121. }
  122. BOOL CXTPDockingPane::IsFocus() const
  123. {
  124. HWND hwndFocus = ::GetFocus();
  125. return (m_hwndChild != 0) && (hwndFocus == m_hwndChild || IsChild(m_hwndChild, hwndFocus));
  127. }
  129. void CXTPDockingPane::SetParentContainer(CXTPDockingPaneBase* pContainer)
  130. {
  131. m_pParentContainer = pContainer;
  133. if (m_hwndChild == 0)
  134. return;
  136. if (pContainer)
  137. {
  138. ASSERT(pContainer->GetType() == xtpPaneTypeTabbedContainer);
  139. ::SetParent(m_hwndChild, pContainer->GetPaneHwnd());
  141. }
  142. else
  143. {
  144. ::ShowWindow(m_hwndChild, SW_HIDE);
  145. ::SetParent(m_hwndChild, GetDockingPaneManager()->GetSafeHwnd());
  147. m_pDockingSite = NULL;
  148. }
  149. }
  151. void CXTPDockingPane::ShowWindow(BOOL bShow)
  152. {
  153. if (bShow)
  154. {
  155. GetDockingPaneManager()->NotifyOwner(XTP_DPN_SHOWWINDOW, (LPARAM)this);
  156. }
  157. if (m_hwndChild)
  158. {
  159. ::ShowWindow(m_hwndChild, bShow ? SW_SHOW : SW_HIDE);
  160. }
  161. }
  163. void CXTPDockingPane::Close()
  164. {
  165. GetDockingPaneManager()->ClosePane(this);
  166. }
  168. void CXTPDockingPane::Hide()
  169. {
  170. GetDockingPaneManager()->HidePane(this);
  171. }
  173. void CXTPDockingPane::Select()
  174. {
  175. GetDockingPaneManager()->ShowPane(this);
  176. }
  178. CWnd* CXTPDockingPane::GetDockingSite() const
  179. {
  180. return m_pParentContainer ? m_pParentContainer->m_pDockingSite : 0;
  182. }
  184. CFrameWnd* CXTPDockingPane::GetParentFrame() const
  185. {
  186. CWnd* pSite = GetDockingSite();
  188. return pSite && pSite->IsFrameWnd() ? (CFrameWnd*)pSite : NULL;
  189. }
  191. void CXTPDockingPane::Copy(CXTPDockingPaneBase* pCloneBase, CXTPPaneToPaneMap* /*pMap*/, DWORD /*dwIgnoredOptions*/)
  192. {
  193. Copy((CXTPDockingPane*)pCloneBase);
  194. }
  196. void CXTPDockingPane::Copy(CXTPDockingPane* pClone)
  197. {
  198. m_szDocking = pClone->m_szDocking;
  199. m_strTitle = pClone->m_strTitle;
  200. m_nIconID = pClone->m_nIconID;
  201. m_dwOptions = pClone->m_dwOptions;
  202. m_dwData = pClone->m_dwData;
  203. m_nID = pClone->m_nID;
  204. m_bEnabled = pClone->m_bEnabled;
  206. m_ptMinTrackSize = pClone->m_ptMinTrackSize;
  207. m_ptMaxTrackSize = pClone->m_ptMaxTrackSize;
  209. m_hwndChild = 0;
  210. }
  212. BOOL CXTPDockingPane::IsValid() const
  213. {
  214. return m_hwndChild != NULL;
  216. }
  217. void CXTPDockingPane::Attach(CWnd* pWnd)
  218. {
  219. if (pWnd)
  220. {
  221. m_hwndChild = pWnd->GetSafeHwnd();
  222. GetDockingPaneManager()->_Redraw();
  223. if (m_pParentContainer)
  224. {
  225. ::SetParent(m_hwndChild, m_pParentContainer->GetPaneHwnd());
  226. }
  228. if (GetDockingPaneManager()->m_bInitialUpdateCalled)
  229. {
  230. pWnd->SendMessage(WM_INITIALUPDATE, 0, 0);
  231. pWnd->SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);
  232. }
  233. }
  234. }
  236. CWnd* CXTPDockingPane::AttachView(CWnd* pParentWnd, CRuntimeClass* pViewClass, CDocument* pDocument/*= NULL*/, CCreateContext* pContext/*= NULL*/)
  237. {
  238. if (!pContext && !pViewClass)
  239. return NULL;
  241. #ifdef _DEBUG
  242. ASSERT(pContext != NULL || pViewClass != NULL);
  243. ASSERT(pContext != NULL || pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  244. ASSERT(pContext != NULL || AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  245. #endif
  247. CCreateContext contextT;
  248. if (pContext == NULL)
  249. {
  250. // if no context specified, generate one from the
  251. // currently selected client if possible.
  252. contextT.m_pLastView = NULL;
  253. contextT.m_pCurrentFrame = NULL;
  254. contextT.m_pNewDocTemplate = NULL;
  255. contextT.m_pCurrentDoc = pDocument;
  256. contextT.m_pNewViewClass = pViewClass;
  258. if (pDocument != NULL)
  259. contextT.m_pNewDocTemplate = pDocument->GetDocTemplate();
  261. pContext = &contextT;
  262. }
  264. CFrameWnd* pFrame = new CFrameWnd;
  266. pFrame->Create(NULL, NULL, WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
  267. CRect(0, 0, 0, 0), pParentWnd, NULL, 0, pContext);
  269. pFrame->ModifyStyleEx(WS_EX_CLIENTEDGE, 0);
  271. Attach(pFrame);
  273. CWnd* pView = pFrame->GetDescendantWindow(AFX_IDW_PANE_FIRST, TRUE);
  275. if (DYNAMIC_DOWNCAST(CView, pView))
  276. {
  277. pFrame->SetActiveView((CView*)pView);
  278. }
  280. return pView;
  281. }
  283. void CXTPDockingPane::Detach()
  284. {
  285. if (m_hwndChild)
  286. {
  287. ::ShowWindow(m_hwndChild, SW_HIDE);
  288. ::SetParent(m_hwndChild, GetDockingPaneManager()->GetSite()->GetSafeHwnd());
  289. m_hwndChild = 0;
  290. }
  291. GetDockingPaneManager()->_Redraw();
  292. }
  294. CString CXTPDockingPane::GetTitle() const
  295. {
  296. int nIndex = m_strTitle.Find('n');
  297. if (nIndex == -1)
  298. return m_strTitle;
  299. return m_strTitle.Left(nIndex);
  300. }
  302. CString CXTPDockingPane::GetShortTitle() const
  303. {
  304. int nIndex = m_strTitle.Find('n');
  305. if (nIndex == -1)
  306. return m_strTitle;
  307. return m_strTitle.Mid(nIndex + 1);
  308. }
  310. void CXTPDockingPane::SetTitle(LPCTSTR lpszTitle)
  311. {
  312. m_strTitle = lpszTitle;
  313. InvalidatePane(FALSE);
  314. }
  316. BOOL CXTPDockingPane::IsClosed() const
  317. {
  318. return m_pParentContainer == NULL;
  319. }
  321. BOOL CXTPDockingPane::IsHidden() const
  322. {
  323. if (m_pParentContainer == NULL)
  324. return FALSE;
  326. return m_pParentContainer->IsHidden();
  327. }
  329. BOOL CXTPDockingPane::IsSelected() const
  330. {
  331. if (m_pParentContainer == NULL) return FALSE;
  332. ASSERT(m_pParentContainer->GetType() == xtpPaneTypeTabbedContainer);
  333. return ((CXTPDockingPaneTabbedContainer*)m_pParentContainer)->GetSelected() == this;
  334. }
  336. BOOL CXTPDockingPane::IsFloating() const
  337. {
  338. if (m_pParentContainer == NULL) return FALSE;
  339. if (IsHidden()) return FALSE;
  340. ASSERT(m_pParentContainer->GetType() == xtpPaneTypeTabbedContainer);
  342. if (m_pParentContainer->GetPaneHwnd() == 0) return FALSE;
  344. CWnd* pFrame = m_pParentContainer->GetDockingSite();
  345. return pFrame && pFrame->IsKindOf(RUNTIME_CLASS(CXTPDockingPaneMiniWnd));
  346. }
  349. CXTPImageManagerIcon* CXTPDockingPane::GetIcon(int nWidth) const
  350. {
  351. return GetDockingPaneManager()->GetIcon(GetIconID(), nWidth);
  352. }
  355. void CXTPDockingPane::SetItemColor(COLORREF clr)
  356. {
  357. m_clrItemTab = clr;
  358. InvalidatePane(FALSE);
  359. }
  361. COLORREF CXTPDockingPane::GetItemColor() const
  362. {
  363. if (m_clrItemTab != COLORREF_NULL)
  364. return m_clrItemTab;
  366. if (m_hwndChild)
  367. {
  368. COLORREF clr = (COLORREF)::SendMessage(m_hwndChild, WM_XTP_GETTABCOLOR, 0, 0);
  369. if (clr != 0)
  370. return clr;
  371. }
  372. return xtpTabColorBlue + GetID() % 8;
  373. }
  375. void CXTPDockingPane::GetMinMaxInfo(LPMINMAXINFO pMinMaxInfo) const
  376. {
  377. ZeroMemory(pMinMaxInfo, sizeof(MINMAXINFO));
  378. pMinMaxInfo->ptMinTrackSize = m_ptMinTrackSize;
  379. pMinMaxInfo->ptMaxTrackSize = m_ptMaxTrackSize;
  380. }
  382. DWORD CXTPDockingPane::GetOptions() const
  383. {
  384. return GetDockingPaneManager()->m_dwDefaultPaneOptions | m_dwOptions;
  385. }
  387. void CXTPDockingPane::DeletePane()
  388. {
  389. InternalRelease();
  390. }
  392. //////////////////////////////////////////////////////////////////////////
  393. // Accessible
  395. CCmdTarget* CXTPDockingPane::GetAccessible()
  396. {
  397. return this;
  398. }
  400. HRESULT CXTPDockingPane::GetAccessibleParent(IDispatch* FAR* ppdispParent)
  401. {
  402. SAFE_MANAGE_STATE(m_pModuleState);
  404. *ppdispParent = NULL;
  406. if (m_pParentContainer)
  407. {
  408. *ppdispParent = ((CXTPDockingPaneTabbedContainer*)m_pParentContainer)->GetIDispatch(TRUE);
  409. return S_OK;
  410. }
  411. return E_FAIL;
  412. }
  414. HRESULT CXTPDockingPane::GetAccessibleChildCount(long FAR* pChildCount)
  415. {
  416. if (pChildCount == 0)
  417. return E_INVALIDARG;
  419. *pChildCount = m_hwndChild ? 1 : 0;
  421. return S_OK;
  422. }
  424. HRESULT CXTPDockingPane::GetAccessibleChild(VARIANT varChild, IDispatch* FAR* ppdispChild)
  425. {
  426. SAFE_MANAGE_STATE(m_pModuleState);
  428. *ppdispChild = NULL;
  430. if (GetChildIndex(&varChild) == 1)
  431. {
  432. return AccessibleObjectFromWindow(m_hwndChild, OBJID_WINDOW, IID_IDispatch, (void**)ppdispChild);
  433. }
  435. return S_OK;
  436. }
  438. HRESULT CXTPDockingPane::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  439. {
  440. if (GetChildIndex(&varChild) != CHILDID_SELF)
  441. return E_INVALIDARG;
  443. *pszName = GetShortTitle().AllocSysString();
  444. return S_OK;
  445. }
  447. HRESULT CXTPDockingPane::GetAccessibleDescription(VARIANT varChild, BSTR* pszDescription)
  448. {
  449. if (GetChildIndex(&varChild) != CHILDID_SELF)
  450. return E_INVALIDARG;
  452. *pszDescription = GetTitle().AllocSysString();
  453. return S_OK;
  454. }
  456. HRESULT CXTPDockingPane::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  457. {
  458. pvarRole->vt = VT_EMPTY;
  460. if (GetChildIndex(&varChild) == CHILDID_SELF)
  461. {
  462. pvarRole->vt = VT_I4;
  463. pvarRole->lVal = ROLE_SYSTEM_PAGETAB;
  464. return S_OK;
  465. }
  467. return E_INVALIDARG;
  468. }
  470. HRESULT CXTPDockingPane::AccessibleSelect(long /*flagsSelect*/, VARIANT varChild)
  471. {
  472. SAFE_MANAGE_STATE(m_pModuleState);
  474. if (GetChildIndex(&varChild) != CHILDID_SELF)
  475. return E_INVALIDARG;
  477. Select();
  479. return S_OK;
  480. }
  483. HRESULT CXTPDockingPane::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  484. {
  485. if (GetChildIndex(&varChild) != CHILDID_SELF)
  486. return E_INVALIDARG;
  488. pvarState->vt = VT_I4;
  489. pvarState->lVal = STATE_SYSTEM_SELECTABLE;
  491. if (!m_pParentContainer)
  492. pvarState->lVal |= STATE_SYSTEM_INVISIBLE;
  494. if (m_pParentContainer && ((CXTPDockingPaneTabbedContainer*)m_pParentContainer)->GetSelected() == this)
  495. pvarState->lVal |= STATE_SYSTEM_SELECTED;
  497. return S_OK;
  498. }
  500. HRESULT CXTPDockingPane::GetAccessibleDefaultAction(VARIANT varChild, BSTR* pszDefaultAction)
  501. {
  502. if (GetChildIndex(&varChild) != CHILDID_SELF)
  503. return E_INVALIDARG;
  505. *pszDefaultAction = SysAllocString(L"Switch");
  507. return S_OK;
  508. }
  510. HRESULT CXTPDockingPane::AccessibleDoDefaultAction(VARIANT varChild)
  511. {
  512. SAFE_MANAGE_STATE(m_pModuleState);
  514. if (GetChildIndex(&varChild) != CHILDID_SELF)
  515. return E_INVALIDARG;
  517. Select();
  519. return S_OK;
  520. }
  522. HRESULT CXTPDockingPane::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  523. {
  524. CRect rc;
  526. if (GetChildIndex(&varChild) == 1)
  527. {
  528. GetWindowRect(m_hwndChild, &rc);
  529. }
  530. else if (GetChildIndex(&varChild) != CHILDID_SELF)
  531. {
  532. return E_INVALIDARG;
  533. }
  534. else
  535. {
  536. CXTPDockingPaneTabbedContainer* pContainer = (CXTPDockingPaneTabbedContainer*)m_pParentContainer;
  537. if (!pContainer)
  538. return S_FALSE;
  540. pContainer->GetWindowRect(&rc);
  542. if (pContainer->GetItemCount() > 1)
  543. {
  544. for (int i = 0; i < pContainer->GetItemCount(); i++)
  545. {
  546. CXTPTabManagerItem* pItem = pContainer->GetItem(i);
  547. if (pItem->GetData() == (DWORD_PTR)this)
  548. {
  549. CRect rcItem = pItem->GetRect();
  550. rc = CRect(CPoint(rc.left + rcItem.left, rc.top + rcItem.top), rcItem.Size());
  551. break;
  552. }
  553. }
  554. }
  555. }
  558. *pxLeft = rc.left;
  559. *pyTop = rc.top;
  560. *pcxWidth = rc.Width();
  561. *pcyHeight = rc.Height();
  563. return S_OK;
  564. }
  566. HRESULT CXTPDockingPane::AccessibleHitTest(long /*xLeft*/, long /*yTop*/, VARIANT* pvarID)
  567. {
  568. pvarID->vt = VT_I4;
  569. pvarID->lVal = 0;
  571. return S_OK;
  572. }
  578. BEGIN_INTERFACE_MAP(CXTPDockingPane, CCmdTarget)
  579. INTERFACE_PART(CXTPDockingPane, IID_IAccessible, ExternalAccessible)
  580. END_INTERFACE_MAP()