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

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

对话框与窗口

开发平台：

Visual C++

XTPTabClientWnd.cpp：源码内容
  1. // XTPTabClientWnd.cpp : implementation of the CXTPTabClientWnd class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS 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/XTPImageManager.h"
  26. #include "Common/XTPDrawHelpers.h"
  27. #include "Common/XTPToolTipContext.h"
  29. #include "Common/Resource.h"
  30. #include "TabManager/XTPTabManager.h"
  32. #include "XTPCommandBarsDefines.h"
  33. #include "XTPTabClientWnd.h"
  34. #include "XTPMouseManager.h"
  35. #include "XTPPaintManager.h"
  36. #include "XTPPopupBar.h"
  37. #include "XTPToolBar.h"
  38. #include "XTPCommandBars.h"
  39. #include "XTPFrameWnd.h"
  40. #include "XTPControls.h"
  41. #include "XTPControlExt.h"
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  50. #ifndef OIC_WINLOGO
  51. #define OIC_WINLOGO         32517
  52. #endif
  54. #define xtpTabNavigateButtonActiveFiles 4
  56. #define ACTION_CANCEL       0
  57. #define ACTION_POPUP        1
  58. #define ACTION_ATTACH       2
  59. #define ACTION_INSERTHORIZ  3
  60. #define ACTION_INSERTVERT   4
  62. class CXTPTabClientWnd::CNavigateButtonActiveFiles : public CXTPTabManagerNavigateButton
  63. {
  64. public:
  65. CNavigateButtonActiveFiles(CXTPTabManager* pManager, CXTPTabClientWnd* pTabClientWnd)
  66. : CXTPTabManagerNavigateButton(pManager, xtpTabNavigateButtonActiveFiles, xtpTabNavigateButtonNone)
  67. {
  68. m_bHiddenTabs = FALSE;
  69. m_pTabClientWnd = pTabClientWnd;
  70. XTPResourceManager()->LoadString(&m_strToolTip, XTP_IDS_TABNAVIGATEBUTTON_ACTIVEFILES);
  71. }
  73. void DrawEntry(CDC* pDC, CRect rc)
  74. {
  75. CPoint pt(rc.CenterPoint().x, rc.CenterPoint().y + 1);
  76. CPoint pts[] =
  77. {
  78. CPoint(pt.x - 4, pt.y - 1), CPoint(pt.x - 1, pt.y + 2) , CPoint(pt.x, pt.y + 2), CPoint(pt.x + 3, pt.y - 1)
  79. };
  80. pDC->Polygon(pts, 4);
  82. if (m_bHiddenTabs)
  83. {
  84. pDC->Rectangle(pt.x - 4, pt.y - 5, pt.x + 4, pt.y - 3);
  85. }
  86. }
  88. void Reposition(CRect& rcNavigateButtons)
  89. {
  90. CRect rc = m_pManager->GetAppearanceSet()->GetHeaderMargin();
  92. m_bHiddenTabs = m_pManager->GetItemsLength() > m_pManager->GetRectLength(rcNavigateButtons) - rc.left - rc.right - GetSize().cx;
  94. CXTPTabManagerNavigateButton::Reposition(rcNavigateButtons);
  95. }
  96. void PerformClick(HWND hWnd, CPoint /*pt*/)
  97. {
  98. CXTPCommandBars* pCommandBars = m_pTabClientWnd->GetCommandBars();
  99. if (!pCommandBars || pCommandBars->IsCustomizeMode())
  100. return;
  102. m_bPressed = TRUE;
  103. m_pManager->RedrawControl(NULL, FALSE);
  105. CPoint pt(m_rcButton.left, m_rcButton.bottom);
  106. m_pTabClientWnd->WorkspaceToScreen(&pt);
  107. CRect rcExclude(pt.x, pt.y - m_rcButton.Height(), pt.x + m_rcButton.Width(), pt.y);
  109. CXTPPopupBar* pPopupBar = CXTPPopupBar::CreatePopupBar(pCommandBars);
  111. CXTPImageManager* pImageManager = new CXTPImageManager();
  112. pPopupBar->SetImageManager(pImageManager);
  114. int nIconId = 0;
  115. HICON hIconLast = 0;
  117. for (int nIndex = 0; nIndex < m_pManager->GetItemCount(); nIndex++)
  118. {
  119. CXTPTabManagerItem* pItem = m_pManager->GetItem(nIndex);
  121. CString pCaption = pItem->GetCaption();
  122. CXTPControl* pControl = pPopupBar->GetControls()->Add(xtpControlButton, nIndex + 1, _T(""), nIndex, TRUE);
  124. HICON hIcon = m_pTabClientWnd->GetItemIcon(pItem);
  125. if (hIconLast != hIcon)
  126. {
  127. nIconId++;
  128. pImageManager->SetIcon(CXTPImageManagerIconHandle(hIcon, FALSE), nIconId);
  129. hIconLast = hIcon;
  130. }
  132. pControl->SetIconId(nIconId);
  133. pControl->SetCaption(CXTPControlWindowList::ConstructCaption(pCaption, 0));
  134. pControl->SetDescription(_T(""));
  135. }
  137. int nItem = pCommandBars->TrackPopupMenu(pPopupBar, TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_NONOTIFY, pt.x, pt.y, m_pTabClientWnd, &rcExclude);
  138. pPopupBar->InternalRelease();
  140. m_bPressed = FALSE;
  141. m_pManager->PerformMouseMove(hWnd, CPoint(-1, -1));
  142. m_pManager->RedrawControl(NULL, FALSE);
  144. if (nItem > 0)
  145. {
  146. CXTPTabManagerItem* pItem = m_pManager->GetItem(nItem - 1);
  148. if (pItem)
  149. {
  150. m_pTabClientWnd->MDIActivate(CWnd::FromHandle(pItem->GetHandle()));
  151. }
  152. }
  153. }
  155. protected:
  156. BOOL m_bHiddenTabs;
  157. CXTPTabClientWnd* m_pTabClientWnd;
  159. };
  161. class CXTPTabClientWnd::CTabClientDropTarget : public COleDropTarget
  162. {
  163. virtual DROPEFFECT OnDragOver(CWnd* /*pWnd*/, COleDataObject* /*pDataObject*/, DWORD /*dwKeyState*/, CPoint point)
  164. {
  165. ASSERT(m_pTabClientWnd);
  167. if (!m_pTabClientWnd || !m_pTabClientWnd->GetPaintManager()->m_bSelectOnDragOver)
  168. return DROPEFFECT_NONE;
  170. CXTPTabManagerItem* pItem = m_pTabClientWnd->HitTest(point);
  172. if (pItem && !pItem->IsSelected())
  173. {
  174. m_pTabClientWnd->MDIActivate(CWnd::FromHandle(pItem->GetHandle()));
  175. }
  177. return DROPEFFECT_NONE;
  178. }
  179. public:
  180. CXTPTabClientWnd* m_pTabClientWnd;
  181. };
  183. //////////////////////////////////////////////////////////////////////////
  184. // CWorkspace
  186. CXTPTabClientWnd::CWorkspace::CWorkspace()
  187. {
  188. m_pTabClientWnd = NULL;
  189. m_dHeight = 100;
  190. }
  192. CXTPTabClientWnd::CWorkspace::~CWorkspace()
  193. {
  195. }
  197. void CXTPTabClientWnd::CWorkspace::SetSelectedItem(CXTPTabManagerItem* pItem)
  198. {
  199. if (m_pSelected != pItem)
  200. {
  201. }
  203. CXTPTabManager::SetSelectedItem(pItem);
  205. }
  208. BOOL CXTPTabClientWnd::CWorkspace::IsMouseLocked() const
  209. {
  210. return CXTPTabManager::IsMouseLocked() || XTPMouseManager()->IsTrackedLock();
  211. }
  213. void CXTPTabClientWnd::CWorkspace::RedrawControl(LPCRECT lpRect, BOOL /*bAnimate*/)
  214. {
  215. if (!m_pTabClientWnd->m_bLockReposition)
  216. m_pTabClientWnd->InvalidateRect(lpRect, FALSE);
  217. }
  219. void CXTPTabClientWnd::CWorkspace::Reposition()
  220. {
  221. if (!m_pTabClientWnd)
  222. return;
  224. if (m_pTabClientWnd->m_bLockReposition)
  225. {
  226. m_pTabClientWnd->m_bForceToRecalc = TRUE;
  227. }
  228. else
  229. {
  230. m_pTabClientWnd->Reposition();
  231. }
  232. }
  234. BOOL CXTPTabClientWnd::CWorkspace::IsAllowReorder() const
  235. {
  236. return m_pTabClientWnd->m_bAllowReorder;
  237. }
  239. void CXTPTabClientWnd::CWorkspace::SetAllowReorder(BOOL bAllowReorder)
  240. {
  241. m_pTabClientWnd->m_bAllowReorder = bAllowReorder;
  242. }
  244. BOOL CXTPTabClientWnd::CWorkspace::IsDrawStaticFrame() const
  245. {
  246. return GetPaintManager()->m_bStaticFrame && !m_pTabClientWnd->m_bEnableGroups;
  247. }
  251. BOOL CXTPTabClientWnd::CWorkspace::DrawIcon(CDC* pDC, CPoint pt, CXTPTabManagerItem* pItem, BOOL bDraw, CSize& szIcon) const
  252. {
  253. if (GetPaintManager()->m_bShowIcons == FALSE)
  254. return FALSE;
  256. if (!bDraw)
  257. {
  258. return TRUE;
  259. }
  261. HICON hIcon = GetItemIcon(pItem);
  262. if (hIcon)
  263. {
  264. DrawIconEx(pDC->GetSafeHdc(), pt.x, pt.y, hIcon, szIcon.cx, szIcon.cy, 0, NULL, DI_NORMAL);
  265. }
  267. return TRUE;
  268. }
  270. CXTPTabPaintManager* CXTPTabClientWnd::CWorkspace::GetPaintManager() const
  271. {
  272. return m_pTabClientWnd ? m_pTabClientWnd->m_pPaintManager : NULL;
  273. }
  275. CString CXTPTabClientWnd::CWorkspace::GetItemTooltip(const CXTPTabManagerItem* pItem) const
  276. {
  277. return m_pTabClientWnd->GetItemTooltip(pItem);
  278. }
  280. // finds the tab item for specified window. Returns NULL if not found
  281. CXTPTabManagerItem* CXTPTabClientWnd::CWorkspace::FindItem(const HWND hWnd) const
  282. {
  283. // loop through all tab items
  284. for (int nIndex = 0; nIndex < GetItemCount(); nIndex++)
  285. {
  286. // check for window handle
  287. if (GetItem(nIndex)->GetHandle() == hWnd)
  288. {
  289. return GetItem(nIndex);
  290. }
  291. }
  293. return NULL;
  294. }
  297. // add new item into the tab control for specified MDIChild. If bRedraw is
  298. // set to TRUE then framework will be redrawn in order to show new item.
  299. CXTPTabManagerItem* CXTPTabClientWnd::CWorkspace::AddItem(const CWnd* pChildWnd)
  300. {
  301. ASSERT(pChildWnd != NULL);
  302. if (!pChildWnd)
  303. return NULL;
  304. ASSERT(::IsWindow(pChildWnd->GetSafeHwnd()));
  306. // make sure we add MDIChild window
  307. if ((pChildWnd->GetExStyle() & WS_EX_MDICHILD) == 0)
  308. return NULL;
  310. int nIndex = GetItemCount();
  311. switch (m_pTabClientWnd->GetNewTabPositon())
  312. {
  313. case xtpWorkspaceNewTabLeftMost:
  314. nIndex = 0;
  315. break;
  317. case xtpWorkspaceNewTabNextToActive:
  318. nIndex = GetCurSel() + 1;
  319. break;
  320. }
  322. // save information about new entry
  323. CXTPTabManagerItem* pItem = CXTPTabManager::AddItem(nIndex);
  324. pItem->SetCaption(m_pTabClientWnd->GetItemText(pChildWnd));
  326. return pItem;
  327. }
  329. BOOL CXTPTabClientWnd::CWorkspace::OnBeforeItemClick(CXTPTabManagerItem* pItem)
  330. {
  331. return m_pTabClientWnd->OnBeforeItemClick(pItem);
  332. }
  334. void CXTPTabClientWnd::CWorkspace::OnItemClick(CXTPTabManagerItem* pItem)
  335. {
  336. ASSERT(pItem);
  337. if (!pItem)
  338. return;
  340. CWnd* pWnd = CWnd::FromHandle(pItem->GetHandle());
  341. if (pWnd)
  342. {
  343. m_pTabClientWnd->MDIActivate(pWnd);
  345. CWnd* pFocus = GetFocus();
  347. BOOL bHasFocus = pFocus->GetSafeHwnd() &&
  348. (pFocus == pWnd || pWnd->IsChild(pFocus) || (pFocus->GetOwner()->GetSafeHwnd() && pWnd->IsChild(pFocus->GetOwner())));
  350. if (!bHasFocus)
  351. pWnd->SetFocus();
  352. }
  353. }
  355. CWnd* CXTPTabClientWnd::CWorkspace::GetWindow() const
  356. {
  357. return m_pTabClientWnd;
  358. }
  360. void CXTPTabClientWnd::CWorkspace::OnNavigateButtonClick(CXTPTabManagerNavigateButton* pButton)
  361. {
  362. if (pButton->GetID() != xtpTabNavigateButtonClose)
  363. return;
  365. CXTPTabManagerItem* pItem = pButton->GetItem() ? pButton->GetItem() : m_pSelected;
  367. if (!pItem)
  368. return;
  370. m_pTabClientWnd->PostMessage(WM_IDLEUPDATECMDUI);
  372. HWND hWnd = pItem->GetHandle();
  373. ::SendMessage(hWnd, WM_CLOSE, 0, 0);
  374. }
  376. void CXTPTabClientWnd::CWorkspace::OnRecalcLayout()
  377. {
  379. }
  381. HICON CXTPTabClientWnd::CWorkspace::GetItemIcon(const CXTPTabManagerItem* pItem) const
  382. {
  383. return m_pTabClientWnd->GetItemIcon(pItem);
  384. }
  386. COLORREF CXTPTabClientWnd::CWorkspace::GetItemColor(const CXTPTabManagerItem* pItem) const
  387. {
  388. COLORREF clr = m_pTabClientWnd->GetItemColor(pItem);
  390. if (clr != COLORREF_NULL)
  391. {
  392. if (clr >= xtpTabColorBlue && clr <= xtpTabColorMagenta)
  393. return CXTPTabPaintManager::GetOneNoteColor((XTPTabOneNoteColor)clr);
  395. return clr;
  396. }
  398. return CXTPTabManager::GetItemColor(pItem);
  399. }
  401. void CXTPTabClientWnd::CWorkspace::ReOrder(HWND hWnd, CPoint pt, CXTPTabManagerItem* pItem)
  402. {
  403. if (m_pTabClientWnd->GetWorkspaceCount() == 1 && pItem->GetTabManager()->GetItemCount() == 1)
  404. {
  405. OnItemClick(pItem);
  406. return;
  407. }
  409. if (m_pSelected != pItem)
  410. {
  411. m_pSelected = pItem;
  412. }
  415. m_pTabClientWnd->m_bLockReposition = TRUE;
  416. m_pTabClientWnd->SetActiveWorkspace(this);
  417. m_pTabClientWnd->m_bLockReposition = FALSE;
  419. if (GetPaintManager()->m_bHotTracking)
  420. m_pHighlighted = pItem;
  422. ::SetCapture(hWnd);
  424. Reposition();
  426. CArray<CRect, CRect&> arrRects;
  428. for (int j = 0; j < GetItemCount(); j++)
  429. {
  430. CRect rc = GetItem(j)->GetRect();
  431. arrRects.Add(rc);
  432. }
  434. BOOL bRefreshCursor = FALSE;
  435. BOOL bAccept = FALSE;
  437. for (;;)
  438. {
  439. MSG msg;
  440. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  442. if (::GetCapture() != hWnd)
  443. {
  444. DispatchMessage (&msg);
  445. goto ExitLoop;
  446. }
  447. switch (msg.message)
  448. {
  449. case WM_MOUSEMOVE:
  450. {
  451. pt = CPoint((short signed)LOWORD(msg.lParam), (short signed)HIWORD(msg.lParam));
  453. if (m_rcHeaderRect.IsRectEmpty() || m_rcHeaderRect.PtInRect(pt))
  454. {
  455. if (bRefreshCursor)
  456. {
  457. m_pTabClientWnd->CancelLoop();
  458. ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  459. bRefreshCursor = FALSE;
  461. }
  462. for (int i = 0; i < arrRects.GetSize(); i++)
  463. {
  464. if (i != pItem->GetIndex() && arrRects[i].PtInRect(pt))
  465. {
  467. CXTPTabManagerItem* p = pItem;
  468. m_arrItems[pItem->GetIndex()] = m_arrItems[i];
  469. m_arrItems[i] = p;
  471. OnItemsChanged();
  472. break;
  473. }
  474. }
  476. }
  477. else if (m_pTabClientWnd->m_bEnableGroups)
  478. {
  479. if (!bRefreshCursor)
  480. {
  481. m_pTabClientWnd->InitLoop();
  482. bRefreshCursor = TRUE;
  483. }
  484. m_pTabClientWnd->ReorderWorkspace(pt, pItem);
  485. }
  486. }
  488. break;
  490. case WM_KEYDOWN:
  491. if (msg.wParam != VK_ESCAPE)
  492. break;
  493. case WM_CANCELMODE:
  494. case WM_RBUTTONDOWN:
  495. goto ExitLoop;
  497. case WM_LBUTTONUP:
  498. bAccept = TRUE;
  499. goto ExitLoop;
  502. default:
  503. DispatchMessage (&msg);
  504. break;
  505. }
  506. }
  508. ExitLoop:
  510. ReleaseCapture();
  511. PerformMouseMove(hWnd, pt);
  512. OnItemClick(pItem);
  514. if (bRefreshCursor)
  515. {
  516. m_pTabClientWnd->CancelLoop();
  517. ::SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
  519. if (bAccept && m_pTabClientWnd->m_nFocusedAction != ACTION_CANCEL)
  520. {
  521. if (m_pTabClientWnd->m_nFocusedAction == ACTION_POPUP)
  522. m_pTabClientWnd->ContextMenu(pt);
  523. else  m_pTabClientWnd->DoWorkspaceCommand(pItem, m_pTabClientWnd->m_pFocusWorkspace, m_pTabClientWnd->m_nFocusedAction);
  524. }
  525. }
  527. pItem->GetTabManager()->EnsureVisible(pItem);
  528. }
  530. //////////////////////////////////////////////////////////////////////////
  531. // CSingleWorkspace
  533. CXTPTabClientWnd::CSingleWorkspace::~CSingleWorkspace()
  534. {
  535. DestroyWindow();
  536. }
  538. CWnd* CXTPTabClientWnd::CSingleWorkspace::GetWindow() const
  539. {
  540. return (CWnd*)this;
  541. }
  543. INT_PTR CXTPTabClientWnd::CSingleWorkspace::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  544. {
  545. return PerformToolHitTest(m_hWnd, point, pTI);
  546. }
  548. BOOL CXTPTabClientWnd::CSingleWorkspace::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  549. {
  550. if (m_pTabClientWnd)
  551. {
  552. m_pTabClientWnd->m_pToolTipContext->FilterToolTipMessage(this, message, wParam, lParam);
  553. }
  555. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  556. }
  558. BOOL CXTPTabClientWnd::CSingleWorkspace::PreTranslateMessage(MSG* pMsg)
  559. {
  560. if (pMsg->message == WM_LBUTTONDOWN ||
  561. pMsg->message == WM_RBUTTONDOWN ||
  562. pMsg->message == WM_MBUTTONDOWN ||
  563. pMsg->message == WM_LBUTTONDBLCLK ||
  564. pMsg->message == WM_RBUTTONDBLCLK)
  565. {
  567. if (GetParentFrame()->SendMessage(WM_XTP_PRETRANSLATEMOUSEMSG, (WPARAM)pMsg->message, pMsg->lParam))
  568. return TRUE;
  569. }
  572. return CWnd::PreTranslateMessage(pMsg);
  573. }
  575. void CXTPTabClientWnd::CSingleWorkspace::RedrawControl(LPCRECT lpRect, BOOL /*bAnimate*/)
  576. {
  577. if (!m_pTabClientWnd->m_bLockReposition)
  578. InvalidateRect(lpRect, FALSE);
  579. }
  581. BEGIN_MESSAGE_MAP(CXTPTabClientWnd::CSingleWorkspace, CWnd)
  582. { WM_LBUTTONDBLCLK, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(UINT, CPoint))&CXTPTabClientWnd::CSingleWorkspace::OnLButtonDblClk },
  583. { WM_PAINT, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(void))&CXTPTabClientWnd::CSingleWorkspace::OnPaint },
  584. { WM_PRINTCLIENT, 0, 0, 0, AfxSig_lwl, (AFX_PMSG)(AFX_PMSGW)(LRESULT (AFX_MSG_CALL CWnd::*)(WPARAM, LPARAM))&CXTPTabClientWnd::CSingleWorkspace::OnPrintClient },
  585. { WM_ERASEBKGND, 0, 0, 0, AfxSig_bD, (AFX_PMSG)(AFX_PMSGW)(BOOL (AFX_MSG_CALL CWnd::*)(CDC*))&CXTPTabClientWnd::CSingleWorkspace::OnEraseBkgnd },
  586. { WM_LBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(UINT, CPoint))&CXTPTabClientWnd::CSingleWorkspace::OnLButtonDown },
  587. { WM_MOUSEMOVE, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(UINT, CPoint))&CXTPTabClientWnd::CSingleWorkspace::OnMouseMove },
  588. { WM_MOUSELEAVE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(void))&CXTPTabClientWnd::CSingleWorkspace::OnMouseLeave },
  589. { WM_RBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(UINT, CPoint))&CXTPTabClientWnd::CSingleWorkspace::OnRButtonDown },
  590. END_MESSAGE_MAP()
  592. void CXTPTabClientWnd::CSingleWorkspace::OnRButtonDown(UINT /*nFlags*/, CPoint point)
  593. {
  594. UNREFERENCED_PARAMETER(point);
  596. }
  598. void CXTPTabClientWnd::CSingleWorkspace::OnPaint()
  599. {
  600. CPaintDC dcPaint(this);
  601. CXTPClientRect rc(this);
  602. CXTPBufferDC dc(dcPaint);
  604. if (m_pTabClientWnd)
  605. {
  606. CRect rectClient;
  607. m_pTabClientWnd->GetWindowRect(rectClient);
  608. ScreenToClient(&rectClient);
  609. dcPaint.ExcludeClipRect(rectClient);
  610. dc.ExcludeClipRect(rectClient);
  612. }
  613. GetPaintManager()->DrawTabControl(this, &dc, rc);
  614. }
  616. LRESULT CXTPTabClientWnd::CSingleWorkspace::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  617. {
  618. CDC* pDC = CDC::FromHandle((HDC)wParam);
  619. if (pDC)
  620. {
  621. if (m_pTabClientWnd)
  622. {
  623. CRect rectClient;
  624. m_pTabClientWnd->GetWindowRect(rectClient);
  625. ScreenToClient(&rectClient);
  626. pDC->ExcludeClipRect(rectClient);
  628. }
  629. CXTPClientRect rc(this);
  630. GetPaintManager()->DrawTabControl(this, pDC, rc);
  631. }
  632. return TRUE;
  633. }
  635. BOOL CXTPTabClientWnd::CSingleWorkspace::OnEraseBkgnd(CDC* /*pDC*/)
  636. {
  637. return TRUE;
  638. }
  640. void CXTPTabClientWnd::CSingleWorkspace::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  641. {
  642. m_pTabClientWnd->m_bLockUpdate = TRUE;
  643. m_pTabClientWnd->m_bDelayLock = TRUE;
  645. PerformClick(m_hWnd, point);
  648. }
  650. void CXTPTabClientWnd::CSingleWorkspace::OnLButtonDblClk(UINT nFlags, CPoint point)
  651. {
  652. OnLButtonDown(nFlags, point);
  653. }
  656. void CXTPTabClientWnd::CSingleWorkspace::OnMouseMove(UINT /*nFlags*/, CPoint point)
  657. {
  658. PerformMouseMove(m_hWnd, point);
  659. }
  661. void CXTPTabClientWnd::CSingleWorkspace::OnMouseLeave()
  662. {
  663. PerformMouseMove(m_hWnd, CPoint(-1, -1));
  664. }
  666. //////////////////////////////////////////////////////////////////////////
  667. // CXTPControlTabWorkspace
  669. IMPLEMENT_XTP_CONTROL(CXTPControlTabWorkspace, CXTPControlButton)
  671. CXTPControlTabWorkspace::CXTPControlTabWorkspace()
  672. {
  673. m_bForceRecalc = FALSE;
  674. m_nWidth = 220;
  676. SetFlags(xtpFlagSkipFocus | xtpFlagNoMovable);
  677. }
  679. CXTPControlTabWorkspace::~CXTPControlTabWorkspace()
  680. {
  682. }
  684. void CXTPControlTabWorkspace::RedrawControl(LPCRECT lpRect, BOOL bAnimate)
  685. {
  686. m_pParent->Redraw(lpRect, bAnimate);
  687. }
  689. CXTPTabPaintManager* CXTPControlTabWorkspace::GetPaintManager() const
  690. {
  691. return CWorkspace::GetPaintManager();
  692. }
  694. CWnd* CXTPControlTabWorkspace::GetWindow() const
  695. {
  696. return (CWnd*)GetParent();
  697. }
  699. void CXTPControlTabWorkspace::OnMouseMove(CPoint point)
  700. {
  701. CXTPControl::OnMouseMove(point);
  703. if (!m_pTabClientWnd)
  704. return;
  706. PerformMouseMove(m_pParent->m_hWnd, point);
  707. }
  709. void CXTPControlTabWorkspace::OnRecalcLayout()
  710. {
  711. m_bForceRecalc = TRUE;
  712. m_pParent->OnRecalcLayout();
  713. RedrawControl(GetRect(), FALSE);
  714. }
  716. XTPTabPosition CXTPControlTabWorkspace::GetPosition() const
  717. {
  718. switch (m_pParent->GetPosition())
  719. {
  720. case xtpBarLeft: return xtpTabPositionLeft;
  721. case xtpBarRight: return xtpTabPositionRight;
  722. case xtpBarBottom: return xtpTabPositionBottom;
  723. }
  724. return xtpTabPositionTop;
  725. }
  727. void CXTPControlTabWorkspace::OnRemoved()
  728. {
  729. if (m_pTabClientWnd && m_pTabClientWnd->m_pTabWorkspace == this)
  730. {
  731. m_pTabClientWnd->m_pTabWorkspace = NULL;
  732. m_pTabClientWnd->m_arrWorkspace.RemoveAll();
  733. }
  734. }
  736. void CXTPControlTabWorkspace::SetRect(CRect rcControl)
  737. {
  738. if (rcControl == CXTPControl::m_rcControl && !m_bForceRecalc)
  739. return;
  741. m_bForceRecalc = FALSE;
  742. CXTPControl::SetRect(rcControl);
  744. CXTPTabPaintManager* pPaintManager = GetPaintManager();
  745. if (!pPaintManager)
  746. return;
  748. CClientDC dc(m_pParent);
  749. pPaintManager->RepositionTabControl(this, &dc, rcControl);
  750. }
  752. void CXTPControlTabWorkspace::Draw(CDC* pDC)
  753. {
  754. CXTPTabPaintManager* pPaintManager = GetPaintManager();
  755. if (!pPaintManager)
  756. {
  757. CXTPControlButton::Draw(pDC);
  758. return;
  759. }
  760. pPaintManager->DrawTabControl(this, pDC, GetRect());
  761. }
  763. CSize CXTPControlTabWorkspace::GetSize(CDC* pDC)
  764. {
  765. CXTPTabPaintManager* pPaintManager = GetPaintManager();
  766. if (!pPaintManager)
  767. return CXTPControl::GetSize(pDC);
  769. int nHeight = pPaintManager->GetAppearanceSet()->GetHeaderHeight(this);
  770. if (pPaintManager->m_bStaticFrame) nHeight += 2;
  772. return IsVerticalPosition(m_pParent->GetPosition()) ? CSize(nHeight, m_nWidth) : CSize(m_nWidth, nHeight);
  773. }
  775. INT_PTR CXTPControlTabWorkspace::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  776. {
  777. if (!m_pTabClientWnd)
  778. return -1;
  780. CXTPTabManagerItem* pItem = HitTest(point);
  782. if (pItem)
  783. {
  784. if (GetPaintManager()->m_toolBehaviour == xtpTabToolTipNever)
  785. return 0;
  787. if (GetPaintManager()->m_toolBehaviour == xtpTabToolTipShrinkedOnly && !pItem->IsItemShrinked())
  788. return 0;
  790. CString strTip = GetItemTooltip(pItem);
  791. if (strTip.IsEmpty())
  792. return 0;
  794. INT_PTR nHit = pItem->GetIndex();
  796. CXTPToolTipContext::FillInToolInfo(pTI, GetParent()->GetSafeHwnd(), pItem->GetRect(), nHit, strTip);
  798. return nHit;
  799. }
  801. return 0;
  802. }
  804. void CXTPControlTabWorkspace::OnClick(BOOL bKeyboard, CPoint point)
  805. {
  806. if (!m_pTabClientWnd)
  807. {
  808. CXTPControlButton::OnClick(bKeyboard, point);
  809. return;
  810. }
  812. if (!bKeyboard)
  813. {
  814. m_pTabClientWnd->m_bLockUpdate = TRUE;
  815. m_pTabClientWnd->m_bDelayLock = TRUE;
  817. PerformClick(m_pParent->m_hWnd, point);
  819. }
  820. }
  822. /////////////////////////////////////////////////////////////////////////////
  823. // CXTPTabClientWnd
  825. IMPLEMENT_DYNAMIC(CXTPTabClientWnd, CWnd)
  827. CXTPTabClientWnd::CXTPTabClientWnd()
  828. {
  829. m_pParentFrame = NULL;
  830. m_bAllowReorder = TRUE;
  832. m_pPaintManager = new CXTPTabPaintManager();
  833. m_pPaintManager->m_bBoldSelected = TRUE;
  835. m_themeCommandBars = xtpThemeOffice2000;
  836. m_bAutoTheme = TRUE;
  838. m_bLockUpdate = FALSE;
  839. m_bLockReposition = FALSE;
  840. m_bForceToRecalc = FALSE;
  842. m_pActiveWorkspace = NULL;
  843. m_bHorizSplitting = TRUE;
  845. m_bRefreshed = FALSE;
  847. m_bThemedBackColor = TRUE;
  848. m_bUpdateContents = FALSE;
  849. m_bRightToLeft = FALSE;
  851. m_bUseSplitterTracker = TRUE;
  852. m_bIgnoreFlickersOnActivate = FALSE;
  854. m_nSplitterSize = 5;
  856. m_pDC = NULL;
  858. m_hCursorHoriz = XTPResourceManager()->LoadCursor(XTP_IDC_HSPLITBAR);
  859. m_hCursorVert = XTPResourceManager()->LoadCursor(XTP_IDC_VSPLITBAR);
  860. m_hCursorNew = XTPResourceManager()->LoadCursor(XTP_IDC_WORKSPACE_NEW);
  861. m_hCursorDelete = XTPResourceManager()->LoadCursor(XTP_IDC_WORKSPACE_DELETE);
  863. m_bShowWorkspace = TRUE;
  864. m_pTabWorkspace = NULL;
  865. m_bEnableGroups = FALSE;
  866. m_bUserWorkspace = FALSE;
  868. m_nMsgUpdateSkinState = RegisterWindowMessage(_T("WM_SKINFRAMEWORK_UPDATESTATE"));
  869. m_nMsgQuerySkinState = RegisterWindowMessage(_T("WM_SKINFRAMEWORK_QUERYSTATE"));
  871. CImageList il;
  872. il.Create(XTP_IDB_WORKSPACE_ICONS, 16, 1, RGB(0, 255, 0));
  873. UINT nIDs[] =
  874. {
  875. XTP_ID_WORKSPACE_NEWHORIZONTAL, XTP_ID_WORKSPACE_NEWVERTICAL
  876. };
  877. XTPImageManager()->SetIcons(il, nIDs, 2, CSize(16, 16));
  879. m_dwFlags = 0;
  881. m_pDropTarget = new CTabClientDropTarget();
  882. m_pDropTarget->m_pTabClientWnd = this;
  884. m_pToolTipContext = new CXTPToolTipContext;
  886. m_bDelayLock = FALSE;
  888. m_newTabPosition = xtpWorkspaceNewTabRightMost;
  889. m_afterCloseTabPosition = xtpWorkspaceActivateTopmost;
  891. }
  893. CXTPTabClientWnd::~CXTPTabClientWnd()
  894. {
  895. CMDTARGET_RELEASE(m_pPaintManager);
  897. if (m_pTabWorkspace != NULL)
  898. {
  899. m_pTabWorkspace->m_pTabClientWnd = NULL;
  900. m_pTabWorkspace->DeleteAllItems();
  901. }
  902. else
  903. {
  904. for (int i = 0; i < GetWorkspaceCount(); i++)
  905. {
  906. delete GetWorkspace(i);
  907. }
  908. }
  910. SAFE_DELETE(m_pDropTarget);
  912. CMDTARGET_RELEASE(m_pToolTipContext);
  914. }
  916. BOOL CXTPTabClientWnd::IsLayoutRTL() const
  917. {
  918. if (GetParentFrame()->GetExStyle() & WS_EX_LAYOUTRTL)
  919. return TRUE;
  921. return m_bRightToLeft;
  922. }
  924. #ifndef WS_EX_NOINHERITLAYOUT
  925. #define WS_EX_NOINHERITLAYOUT   0x00100000L
  926. #endif
  928. void CXTPTabClientWnd::SetLayoutRTL(BOOL bRightToLeft)
  929. {
  930. if (!XTPSystemVersion()->IsLayoutRTLSupported())
  931. return;
  933. if (m_bUserWorkspace)
  934. return;
  936. m_bRightToLeft = bRightToLeft;
  938. if (!m_bEnableGroups && GetWorkspaceCount() == 1)
  939. {
  940. ((CSingleWorkspace*)GetWorkspace(0))->ModifyStyleEx(m_bRightToLeft ? 0 : WS_EX_LAYOUTRTL,
  941. m_bRightToLeft ? WS_EX_LAYOUTRTL : 0);
  942. }
  944. if (m_bEnableGroups)
  945. {
  946. ModifyStyleEx(m_bRightToLeft ? 0 : WS_EX_LAYOUTRTL,
  947. m_bRightToLeft ? WS_EX_LAYOUTRTL | WS_EX_NOINHERITLAYOUT : 0);
  948. }
  950. RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);
  951. m_pParentFrame->DelayRecalcLayout();
  952. }
  955. CXTPTabManagerItem* CXTPTabClientWnd::FindItem(const HWND hWnd) const
  956. {
  957. // loop through all tab items
  958. for (int nIndex = 0; nIndex < GetWorkspaceCount(); nIndex++)
  959. {
  960. CXTPTabManagerItem* pItem = GetWorkspace(nIndex)->FindItem(hWnd);
  962. if (pItem)
  963. return pItem;
  964. }
  966. return NULL;
  967. }
  969. BOOL CXTPTabClientWnd::OnBeforeItemClick(CXTPTabManagerItem* pItem)
  970. {
  971. UNREFERENCED_PARAMETER(pItem);
  974. return TRUE;
  975. }
  977. CWnd* CXTPTabClientWnd::MDIGetActive()
  978. {
  979. return (GetParentFrame()->MDIGetActive());
  981. }
  983. void CXTPTabClientWnd::MDIActivate(CWnd* pWnd)
  984. {
  985. if (!pWnd || !::IsWindow(pWnd->GetSafeHwnd()))
  986. return;
  988. SendMessage(WM_MDIACTIVATE, (WPARAM)pWnd->m_hWnd, 0);
  990. if (pWnd->GetStyle() & WS_MINIMIZE)
  991. {
  992. pWnd->SendMessage(WM_SYSCOMMAND, (WPARAM)SC_RESTORE, 0L);
  993. }
  994. }
  996. CString CXTPTabClientWnd::GetItemTooltip(const CXTPTabManagerItem* pItem) const
  997. {
  998. CString strTooltip = pItem->m_strToolTip;
  999. if (!strTooltip.IsEmpty())
  1000. return strTooltip;
  1002. CMDIChildWnd* pChild = DYNAMIC_DOWNCAST(CMDIChildWnd, CWnd::FromHandle(pItem->GetHandle()));
  1003. if (pChild)
  1004. {
  1005. strTooltip = (LPCTSTR)pChild->SendMessage(WM_XTP_GETWINDOWTOOLTIP, (WPARAM)pItem);
  1006. if (!strTooltip.IsEmpty())
  1007. return strTooltip;
  1010. if (pChild->GetActiveDocument())
  1011. strTooltip = pChild->GetActiveDocument()->GetPathName();
  1013. if (!strTooltip.IsEmpty())
  1014. return strTooltip;
  1015. }
  1016. return pItem->GetCaption();
  1017. }
  1019. CString CXTPTabClientWnd::GetItemText(const CWnd* pChildWnd) const
  1020. {
  1021. ASSERT(pChildWnd != NULL);
  1022. if (!pChildWnd)
  1023. return _T("");
  1025. ASSERT(pChildWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)));
  1027. CString sWindowText = (LPCTSTR)((CWnd*)pChildWnd)->
  1028. SendMessage(WM_XTP_GETWINDOWTEXT);
  1030. if (sWindowText.IsEmpty())
  1031. {
  1032. CDocument* pDoc = ((CMDIChildWnd*)pChildWnd)->GetActiveDocument();
  1033. if (pDoc != NULL)
  1034. sWindowText = pDoc->GetTitle();
  1036. if (sWindowText.IsEmpty())
  1037. CXTPDrawHelpers::GetWindowCaption(pChildWnd->GetSafeHwnd(), sWindowText);
  1038. }
  1040. return sWindowText;
  1041. }
  1043. COLORREF CXTPTabClientWnd::GetItemColor(const CXTPTabManagerItem* pItem) const
  1044. {
  1045. COLORREF clr = (COLORREF)::SendMessage(pItem->GetHandle(), WM_XTP_GETTABCOLOR, 0, 0);
  1047. if (clr != 0)
  1048. {
  1049. return clr;
  1050. }
  1052. return COLORREF_NULL;
  1053. }
  1056. HICON CXTPTabClientWnd::GetItemIcon(const CXTPTabManagerItem* pItem) const
  1057. {
  1058. HWND hWnd = pItem->GetHandle();
  1059. HICON hIcon;
  1061. hIcon = (HICON)::SendMessage(hWnd, WM_XTP_GETTABICON, 0, 0);
  1063. if (!hIcon) hIcon = (HICON)::SendMessage(hWnd, WM_GETICON, ICON_SMALL, 0);
  1064. if (!hIcon) hIcon = (HICON)::SendMessage(hWnd, WM_GETICON, ICON_BIG, 0);
  1065. if (!hIcon) hIcon = (HICON)(ULONG_PTR)::GetClassLongPtr(hWnd, GCLP_HICONSM);
  1066. if (!hIcon) hIcon = (HICON)(ULONG_PTR)::GetClassLongPtr(hWnd, GCLP_HICON);
  1068. return hIcon ? hIcon : AfxGetApp()->LoadOEMIcon(OIC_WINLOGO);
  1069. }
  1072. BEGIN_MESSAGE_MAP(CXTPTabClientWnd, CWnd)
  1073. //{{AFX_MSG_MAP(CXTPTabClientWnd)
  1074. ON_MESSAGE(WM_MDIACTIVATE, OnMDIActivate)
  1075. ON_MESSAGE(WM_MDINEXT, OnMDINext)
  1076. ON_MESSAGE(WM_MDICREATE, OnMDICreate)
  1077. ON_MESSAGE(WM_MDIDESTROY, OnMDIDestroy)
  1078. ON_WM_SIZE()
  1079. ON_MESSAGE_VOID(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  1080. ON_WM_PAINT()
  1081. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  1082. ON_WM_ERASEBKGND()
  1083. ON_WM_NCPAINT()
  1084. ON_WM_NCCALCSIZE()
  1085. ON_WM_NCACTIVATE()
  1086. ON_WM_LBUTTONDBLCLK()
  1087. ON_WM_PAINT()
  1088. ON_WM_ERASEBKGND()
  1089. ON_WM_LBUTTONDOWN()
  1090. ON_WM_MOUSEMOVE()
  1091. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  1092. ON_WM_SYSCOLORCHANGE()
  1093. ON_WM_SETCURSOR()
  1094. ON_WM_RBUTTONDOWN()
  1096. ON_COMMAND_RANGE(XTP_ID_WORKSPACE_MOVEPREVIOUS, XTP_ID_WORKSPACE_NEWVERTICAL, OnWorkspaceCommand)
  1097. ON_UPDATE_COMMAND_UI_RANGE(XTP_ID_WORKSPACE_MOVEPREVIOUS, XTP_ID_WORKSPACE_NEWVERTICAL, OnUpdateWorkspaceCommand)
  1098. //}}AFX_MSG_MAP
  1099. END_MESSAGE_MAP()
  1101. CXTPTabClientWnd::CWorkspace* CXTPTabClientWnd::CreateWorkspace()
  1102. {
  1103. if (m_pTabWorkspace != NULL)
  1104. return m_pTabWorkspace;
  1106. if (m_bUserWorkspace)
  1107. return NULL;
  1109. if (m_bEnableGroups)
  1110. return new CWorkspace();
  1112. return new CSingleWorkspace();
  1113. }
  1115. CXTPTabClientWnd::CWorkspace*  CXTPTabClientWnd::AddWorkspace(int nIndex)
  1116. {
  1117. if (m_pDropTarget) m_pDropTarget->Revoke();
  1119. CWorkspace* pWorkspace = CreateWorkspace();
  1120. if (!pWorkspace)
  1121. return NULL;
  1123. if (m_bEnableGroups)
  1124. {
  1125. if (m_pDropTarget) m_pDropTarget->Register(this);
  1126. }
  1127. else if (!m_bUserWorkspace)
  1128. {
  1129. VERIFY(((CSingleWorkspace*)pWorkspace)->Create(AfxRegisterWndClass(CS_DBLCLKS, AfxGetApp()->LoadStandardCursor(IDC_ARROW)), _T(""), WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CHILD | WS_VISIBLE, CXTPEmptyRect(), m_pParentFrame, 0));
  1130. if (m_pDropTarget) m_pDropTarget->Register((CSingleWorkspace*)pWorkspace);
  1132. if (IsLayoutRTL())
  1133. {
  1134. ((CSingleWorkspace*)pWorkspace)->ModifyStyleEx(0, WS_EX_LAYOUTRTL);
  1135. }
  1136. }
  1138. if (nIndex == -1) nIndex = GetWorkspaceCount();
  1139. m_arrWorkspace.InsertAt(nIndex, pWorkspace);
  1141. pWorkspace->m_pTabClientWnd = this;
  1142. pWorkspace->SetActive(FALSE);
  1143. pWorkspace->SetItemMetrics(CSize(70, 18), 0, CSize(220, 0));
  1144. pWorkspace->GetNavigateButtons()->InsertAt(2, new CNavigateButtonActiveFiles(pWorkspace, this));
  1146. UpdateFlags(pWorkspace);
  1148. m_bForceToRecalc = TRUE;
  1150. return pWorkspace;
  1152. }
  1155. BOOL CXTPTabClientWnd::Attach(CXTPMDIFrameWnd* pParentFrame,
  1156. BOOL bEnableGroups /*= FALSE*/)
  1157. {
  1158. ASSERT(GetWorkspaceCount() == 0);
  1159. ASSERT(pParentFrame != NULL);
  1160. if (!pParentFrame)
  1161. return FALSE;
  1162. ASSERT(::IsWindow(pParentFrame->GetSafeHwnd()));
  1164. m_bEnableGroups = bEnableGroups;
  1167. // check if already attached
  1168. if (IsAttached())
  1169. {
  1170. TRACE(_T("CXTPTabClientWnd::Attach: window has already been attached. Call Detach() function before !n"));
  1171. return FALSE;
  1172. }
  1174. // make sure the specified window is/derived from CMDIFrameWnd class
  1175. if (!pParentFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd)))
  1176. {
  1177. TRACE(_T("CXTPTabClientWnd::Attach: specified frame window is not of CMDIFrameWnd class (or derived)!n"));
  1178. return FALSE;
  1179. }
  1181. // try to sublass MDIClient window
  1182. if (!SubclassWindow(pParentFrame->m_hWndMDIClient))
  1183. {
  1184. TRACE(_T("CXTPTabClientWnd::Attach: failed to subclass MDI Client windown"));
  1185. return FALSE;
  1186. }
  1188. SendMessage(m_nMsgUpdateSkinState);
  1190. // save the pointer to parent MDIFrame
  1191. m_pParentFrame = pParentFrame;
  1193. CheckCommandBarsTheme();
  1194. GetPaintManager()->RefreshMetrics();
  1197. SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOZORDER);
  1199. // update the size and position of the tab control and MDIClient window
  1200. Reposition();
  1202. if (bEnableGroups)
  1203. {
  1204. ::SetClassLong(m_hWnd, GCL_STYLE, ::GetClassLong(m_hWnd, GCL_STYLE) | CS_DBLCLKS);
  1205. }
  1207. // populate tab control with MDIChild windows if any exist at the moment
  1208. UpdateContents();
  1210. return TRUE;
  1211. }
  1213. void CXTPTabClientWnd::EnableToolTips(XTPTabToolTipBehaviour behaviour /*= xtpTabToolTipAlways*/)
  1214. {
  1215. m_pPaintManager->EnableToolTips(behaviour);
  1216. }
  1218. void CXTPTabClientWnd::ShowWorkspace(BOOL bShow)
  1219. {
  1220. if (m_bShowWorkspace == bShow)
  1221. return;
  1223. if (!m_bEnableGroups && !m_bUserWorkspace)
  1224. {
  1225. if (GetWorkspaceCount() == 1 && ((CSingleWorkspace*)GetWorkspace(0))->m_hWnd)
  1226. {
  1227. ((CSingleWorkspace*)GetWorkspace(0))->ShowWindow(bShow ? SW_SHOW : SW_HIDE);
  1228. }
  1230. m_bShowWorkspace = bShow;
  1231. UpdateContents();
  1232. Reposition();
  1233. }
  1234. }
  1236. BOOL CXTPTabClientWnd::Detach()
  1237. {
  1238. // check if any attached
  1239. if (!IsAttached())
  1240. {
  1241. TRACE(_T("CXTPTabClientWnd::Attach: there is nothing to detach! Window hasn't been attached!n"));
  1242. return FALSE;
  1243. }
  1245. if (m_pDropTarget) m_pDropTarget->Revoke();
  1247. if (m_pTabWorkspace)
  1248. {
  1249. m_pTabWorkspace->m_pTabClientWnd = NULL;
  1250. m_pTabWorkspace->DeleteAllItems();
  1251. }
  1252. else
  1253. {
  1254. for (int i = 0; i < GetWorkspaceCount(); i++)
  1255. {
  1256. delete GetWorkspace(i);
  1257. }
  1258. }
  1260. m_arrWorkspace.RemoveAll();
  1262. m_pActiveWorkspace = NULL;
  1264. HWND hWnd = m_hWnd;
  1265. // unsubclass MDIClient window
  1266. UnsubclassWindow();
  1268. // update the size and position of the MDIClient window
  1269. if (::IsWindow(m_pParentFrame->GetSafeHwnd()))
  1270. m_pParentFrame->RecalcLayout();
  1272. m_pParentFrame = NULL;
  1273. ::SendMessage(hWnd, m_nMsgUpdateSkinState, 0, 0);
  1275. return TRUE;
  1276. }
  1280. INT_PTR CXTPTabClientWnd::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1281. {
  1282. if (XTPMouseManager()->IsTrackedLock())
  1283. return -1;
  1285. if (!m_bShowWorkspace)
  1286. return -1;
  1288. for (int i = 0; i < GetWorkspaceCount(); i++)
  1289. {
  1290. if (GetWorkspace(i)->GetControlRect().PtInRect(point))
  1291. {
  1292. return GetWorkspace(i)->PerformToolHitTest(m_hWnd, point, pTI);
  1293. }
  1294. }
  1295. return -1;
  1296. }
  1299. void CXTPTabClientWnd::CheckCommandBarsTheme()
  1300. {
  1301. if (!m_bAutoTheme)
  1302. return;
  1304. CXTPCommandBars* pCommandBars = GetCommandBars();
  1305. if (!pCommandBars)
  1306. return;
  1308. XTPPaintTheme themeCommandBars = pCommandBars->GetPaintManager()->BaseTheme();
  1310. if (m_themeCommandBars != themeCommandBars)
  1311. {
  1313. m_pPaintManager->m_bStaticFrame = FALSE;
  1314. m_pPaintManager->m_clientFrame = xtpTabFrameBorder;
  1315. m_pPaintManager->m_bOneNoteColors = FALSE;
  1316. m_pPaintManager->m_bHotTracking = FALSE;
  1317. m_pPaintManager->m_rcButtonMargin.SetRect(0, 0, 0, 0);
  1318. m_pPaintManager->m_bClearTypeTextQuality = pCommandBars->GetPaintManager()->m_bClearTypeTextQuality;
  1320. switch (themeCommandBars)
  1321. {
  1322. case xtpThemeOfficeXP:
  1323. m_pPaintManager->SetAppearance(xtpTabAppearanceVisualStudio);
  1324. m_pPaintManager->m_bStaticFrame = TRUE;
  1325. m_pPaintManager->m_clientFrame = xtpTabFrameSingleLine;
  1326. break;
  1328. case xtpThemeOffice2007:
  1329. m_pPaintManager->m_bDisableLunaColors = FALSE;
  1330. m_pPaintManager->m_bOneNoteColors = TRUE;
  1331. m_pPaintManager->m_bHotTracking = TRUE;
  1332. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPage2003);
  1333. m_pPaintManager->SetColor(xtpTabColorOffice2007);
  1334. break;
  1336. case xtpThemeRibbon:
  1337. m_pPaintManager->m_bDisableLunaColors = FALSE;
  1338. m_pPaintManager->m_bOneNoteColors = FALSE;
  1339. m_pPaintManager->m_bHotTracking = TRUE;
  1341. if (pCommandBars->GetMenuBar() && pCommandBars->GetMenuBar()->GetType() == xtpBarTypeRibbon)
  1342. {
  1343. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPageAccess2007);
  1344. m_pPaintManager->m_rcButtonMargin.SetRect(3, 0, 3, 0);
  1345. }
  1346. else
  1347. {
  1348. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPage2007);
  1349. m_pPaintManager->m_rcButtonMargin.SetRect(2, 2, 2, 2);
  1350. }
  1351. break;
  1353. case xtpThemeOffice2003:
  1354. m_pPaintManager->m_bDisableLunaColors = FALSE;
  1355. m_pPaintManager->m_bOneNoteColors = TRUE;
  1356. m_pPaintManager->m_bHotTracking = TRUE;
  1357. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPage2003);
  1358. break;
  1360. case xtpThemeNativeWinXP:
  1361. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPage);
  1362. m_pPaintManager->SetColor(xtpTabColorWinXP);
  1363. m_pPaintManager->m_bHotTracking = TRUE;
  1364. break;
  1366. case xtpThemeWhidbey:
  1367. m_pPaintManager->m_bStaticFrame = TRUE;
  1368. m_pPaintManager->m_clientFrame = xtpTabFrameSingleLine;
  1369. m_pPaintManager->m_bDisableLunaColors = TRUE;
  1370. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPage2003);
  1371. m_pPaintManager->SetColor(xtpTabColorWhidbey);
  1372. break;
  1374. case xtpThemeVisualStudio2008:
  1375. m_pPaintManager->m_bStaticFrame = FALSE;
  1376. m_pPaintManager->m_clientFrame = xtpTabFrameBorder;
  1377. m_pPaintManager->m_bDisableLunaColors = TRUE;
  1378. m_pPaintManager->m_bHotTracking = TRUE;
  1379. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPage2003);
  1380. m_pPaintManager->SetColor(xtpTabColorVisualStudio2008);
  1381. break;
  1383. default:
  1384. m_pPaintManager->SetAppearance(xtpTabAppearancePropertyPage);
  1385. break;
  1386. }
  1388. m_pPaintManager->RefreshMetrics();
  1390. m_themeCommandBars = themeCommandBars;
  1392. Refresh();
  1394. }
  1395. }
  1397. int CXTPTabClientWnd::GetWorkspaceCount() const
  1398. {
  1399. return (int)m_arrWorkspace.GetSize();
  1400. }
  1402. CXTPTabClientWnd::CWorkspace* CXTPTabClientWnd::GetWorkspace(int nIndex) const
  1403. {
  1404. return m_arrWorkspace[nIndex];
  1405. }
  1408. void CXTPTabClientWnd::OnIdleUpdateCmdUI()
  1409. {
  1410. if (m_bDelayLock)
  1411. {
  1412. m_bDelayLock = FALSE;
  1413. m_bLockUpdate = FALSE;
  1414. }
  1416. UpdateContents();
  1417. }
  1419. CXTPTabManagerItem* CXTPTabClientWnd::AddItem(CWnd* pChildWnd)
  1420. {
  1421. #ifdef _DEBUG
  1422. if (m_bEnableGroups)
  1423. {
  1424. ASSERT((pChildWnd->GetStyle() & WS_MAXIMIZE) == 0);
  1425. }
  1426. #endif
  1428. if (GetWorkspaceCount() == 0)
  1429. AddWorkspace();
  1431. if (GetWorkspaceCount() == 0)
  1432. return NULL;
  1434. CWorkspace* pActiveWorkspace = m_pActiveWorkspace ? m_pActiveWorkspace : m_arrWorkspace[GetWorkspaceCount() - 1];
  1436. return pActiveWorkspace->AddItem(pChildWnd);
  1437. }
  1440. void CXTPTabClientWnd::SetActiveWorkspace(CWorkspace* pWorkspace)
  1441. {
  1442. if (m_pActiveWorkspace != pWorkspace)
  1443. {
  1444. if (m_pActiveWorkspace)
  1445. m_pActiveWorkspace->SetActive(FALSE);
  1447. m_pActiveWorkspace = pWorkspace;
  1448. m_pActiveWorkspace->SetActive(TRUE);
  1449. }
  1450. }
  1452. void CXTPTabClientWnd::WorkspaceToScreen(LPPOINT lpPoint) const
  1453. {
  1454. if (m_bEnableGroups)
  1455. {
  1456. ClientToScreen(lpPoint);
  1457. }
  1458. else if (GetWorkspaceCount() != 0)
  1459. {
  1460. CWorkspace* pWorkspace = GetWorkspace(0);
  1461. pWorkspace->GetWindow()->ClientToScreen(lpPoint);
  1462. }
  1464. }
  1465. void CXTPTabClientWnd::ScreenToWorkspace(LPPOINT lpPoint) const
  1466. {
  1467. if (m_bEnableGroups)
  1468. {
  1469. ScreenToClient(lpPoint);
  1470. }
  1471. else if (GetWorkspaceCount() != 0)
  1472. {
  1473. CWorkspace* pWorkspace = GetWorkspace(0);
  1474. pWorkspace->GetWindow()->ScreenToClient(lpPoint);
  1475. }
  1476. }
  1479. void CXTPTabClientWnd::Refresh(BOOL bRecalcLayout)
  1480. {
  1481. if (!IsAttached())
  1482. return;
  1484. if (m_bRefreshed)
  1485. return;
  1487. m_bRefreshed = TRUE;
  1489. UpdateContents();
  1491. if (GetWorkspaceCount() != 0)
  1492. {
  1493. CPoint pt;
  1494. GetCursorPos(&pt);
  1495. ScreenToWorkspace(&pt);
  1497. if (m_bEnableGroups)
  1498. {
  1499. OnMouseMove(0, pt);
  1500. }
  1501. else if (!m_bUserWorkspace)
  1502. {
  1503. ((CSingleWorkspace*)GetWorkspace(0))->OnMouseMove(0, pt);
  1504. }
  1505. }
  1507. Invalidate(FALSE);
  1509. if (bRecalcLayout)
  1510. {
  1511. if (m_bEnableGroups)
  1512. SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
  1514. CXTPCommandBars* pCommandBars = GetCommandBars();
  1515. if (pCommandBars)
  1516. pCommandBars->RecalcFrameLayout();
  1517. }
  1519. m_bRefreshed = FALSE;
  1520. }
  1523. void CXTPTabClientWnd::UpdateContents()
  1524. {
  1525. if (m_hWnd == 0)
  1526. return;
  1528. if (!m_bShowWorkspace)
  1529. return;
  1531. if (m_bLockUpdate)
  1532. return;
  1534. // check MDI windows
  1535. CFrameWnd* pFrameWnd = GetParentFrame();
  1536. if (pFrameWnd == NULL)
  1537. return;
  1539. if (m_bUpdateContents)
  1540. return;
  1542. m_bUpdateContents = TRUE;
  1544. CheckCommandBarsTheme();
  1546. m_bLockReposition = TRUE;
  1548. // get pointer to currently active MDIChild
  1549. CWnd* pActiveChildWnd = MDIGetActive();
  1551. CXTPTabManagerItem* pActiveItem = NULL, *pNewItem = NULL;
  1553. int i;
  1554. for (i = 0; i < GetWorkspaceCount(); i++)
  1555. {
  1556. for (int nIndex = 0; nIndex < GetWorkspace(i)->GetItemCount(); nIndex++)
  1557. GetWorkspace(i)->GetItem(nIndex)->m_bFound = FALSE;
  1558. }
  1561. // start enumerating from currently active MDIChild
  1562. CWnd* pChildWnd = GetWindow(GW_CHILD);
  1564. // enumerate all child windows
  1565. while (pChildWnd)
  1566. {
  1567. // see if can find
  1568. CXTPTabManagerItem* pFoundItem = FindItem(pChildWnd->GetSafeHwnd());
  1570. if (pFoundItem != NULL)
  1571. {
  1572. if ((pChildWnd->GetStyle() & WS_VISIBLE) == WS_VISIBLE)
  1573. {
  1574. // update text if necessary
  1575. pFoundItem->SetCaption(GetItemText(pChildWnd));
  1577. }
  1578. else
  1579. {
  1580. pFoundItem->Remove();
  1581. pFoundItem = NULL;
  1582. }
  1583. }
  1584. else
  1585. {
  1586. if ((pChildWnd->GetStyle() & WS_VISIBLE) == WS_VISIBLE)
  1587. {
  1588. // add item
  1589. pNewItem = pFoundItem = AddItem(pChildWnd);
  1590. if (pNewItem)
  1591. {
  1593. pFoundItem->m_hWnd = pChildWnd->GetSafeHwnd();
  1595. pFrameWnd->SendMessage(WM_XTP_NEWTABITEM, (WPARAM)pNewItem);
  1596. pNewItem->GetTabManager()->SetSelectedItem(pNewItem);
  1597. }
  1599. }
  1600. }
  1601. if (pFoundItem)
  1602. {
  1603. pFoundItem->m_bFound = TRUE;
  1605. if (pChildWnd == pActiveChildWnd)
  1606. pActiveItem = pFoundItem;
  1607. }
  1609. // get next MDIChild
  1610. pChildWnd = pChildWnd->GetWindow(GW_HWNDNEXT);
  1611. }
  1613. for (i = GetWorkspaceCount() - 1; i >= 0; i--)
  1614. {
  1615. CWorkspace* pWorkspace = GetWorkspace(i);
  1616. for (int nIndex = pWorkspace->GetItemCount() - 1; nIndex >= 0; nIndex--)
  1617. {
  1618. CXTPTabManagerItem* pItem = pWorkspace->GetItem(nIndex);
  1619. if (!pItem->m_bFound)
  1620. {
  1621. pItem->Remove();
  1622. }
  1623. }
  1625. if (pWorkspace->GetItemCount() == 0)
  1626. {
  1627. if (pWorkspace == m_pActiveWorkspace)
  1628. m_pActiveWorkspace = NULL;
  1630. CWorkspace* pWorkcpaceGrow = i == 0 ? (GetWorkspaceCount() > 1 ? GetWorkspace(i + 1): NULL) : GetWorkspace(i - 1);
  1631. if (pWorkcpaceGrow)
  1632. {
  1633. pWorkcpaceGrow->m_dHeight += pWorkspace->m_dHeight + m_nSplitterSize;
  1634. }
  1636. if (pWorkspace != m_pTabWorkspace) delete pWorkspace;
  1637. m_arrWorkspace.RemoveAt(i);
  1639. m_bForceToRecalc = TRUE;
  1641. if (m_bEnableGroups)
  1642. {
  1643. Invalidate(FALSE);
  1644. }
  1645. }
  1646. }
  1648. // set the active item
  1649. if (pActiveItem != NULL)
  1650. {
  1651. if (pActiveItem->GetTabManager()->GetSelectedItem() != pActiveItem)
  1652. {
  1653. pActiveItem->GetTabManager()->SetSelectedItem(pActiveItem);
  1654. }
  1656. SetActiveWorkspace((CWorkspace*)pActiveItem->GetTabManager());
  1658. }
  1660. m_bLockReposition = FALSE;
  1662. if (m_bForceToRecalc)
  1663. {
  1664. // update the size and position of the tab control and MDIClient window
  1665. if (::IsWindow(GetParentFrame()->GetSafeHwnd()))
  1666. {
  1667. Reposition();
  1668. }
  1670. if (pNewItem)
  1671. pNewItem->GetTabManager()->EnsureVisible(pNewItem);
  1674. m_bForceToRecalc = FALSE;
  1675. }
  1677. m_bUpdateContents = FALSE;
  1678. }
  1680. /////////////////////////////////////////////////////////////////////////////
  1681. // CXTPTabClientWnd message handlers
  1684. // handler for WM_MDIACTIVATE message. Will select corresponding
  1685. // tab control item
  1686. LRESULT CXTPTabClientWnd::OnMDIActivate(WPARAM /*wParam*/, LPARAM /*lParam*/)
  1687. {
  1688. LRESULT lResult = 0;
  1690. if (m_bEnableGroups || m_bIgnoreFlickersOnActivate || !m_bShowWorkspace)
  1691. {
  1692. lResult = Default();
  1693. }
  1694. else
  1695. {
  1696. SetRedraw(FALSE);
  1698. lResult = Default();
  1700. SetRedraw(TRUE);
  1701. RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);
  1702. }
  1704. UpdateContents();
  1705. return lResult;
  1706. }
  1709. // handler for WM_MDICREATE message. Will add new item into the
  1710. // tab control
  1711. LRESULT CXTPTabClientWnd::OnMDICreate(WPARAM /*wParam*/, LPARAM /*lParam*/)
  1712. {
  1713. LRESULT lResult = Default();
  1715. if (lResult && m_bEnableGroups)
  1716. {
  1717. CWnd* pWnd = CWnd::FromHandle((HWND)lResult);
  1718. if (pWnd)
  1719. {
  1720. pWnd->ModifyStyle(WS_BORDER | WS_DLGFRAME | WS_THICKFRAME | WS_MAXIMIZEBOX | WS_MINIMIZEBOX, 0);
  1721. pWnd->ModifyStyleEx(WS_EX_CLIENTEDGE, 0);
  1722. pWnd->MoveWindow(0, 0, 0, 0);
  1723. }
  1724. }
  1726. UpdateContents();
  1727. return lResult;
  1728. }
  1730. void CXTPTabClientWnd::ActivateNextItem(CXTPTabManagerItem* pItem)
  1731. {
  1732. if (!pItem)
  1733. return;
  1735. CXTPTabManagerItem* pItemActivate = pItem->GetTabManager()->GetItem(pItem->GetIndex() + 1);
  1737. if (!pItemActivate)
  1738. {
  1739. pItemActivate = pItem->GetTabManager()->GetItem(pItem->GetIndex() - 1);
  1740. }
  1742. if (!pItemActivate)
  1743. return;
  1745. HWND hWndActivate = pItemActivate->GetHandle();
  1746. if (!hWndActivate)
  1747. return;
  1749. ::BringWindowToTop(hWndActivate);
  1750. }
  1752. // handler for WM_MDIDESTROY message. Will remove the correspondent item
  1753. // from the tab control
  1754. LRESULT CXTPTabClientWnd::OnMDIDestroy(WPARAM wParam, LPARAM /*lParam*/)
  1755. {
  1756. if (m_afterCloseTabPosition == xtpWorkspaceActivateNextToClosed)
  1757. ActivateNextItem(FindItem((HWND)wParam));
  1759. LRESULT lResult = Default();
  1760. UpdateContents();
  1761. return lResult;
  1762. }
  1764. LRESULT CXTPTabClientWnd::OnMDINext(WPARAM /*wParam*/, LPARAM /*lParam*/)
  1765. {
  1766. LRESULT lResult = Default();
  1767. UpdateContents();
  1768. return lResult;
  1769. }
  1771. BOOL CXTPTabClientWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1772. {
  1773. if (nHitTest == HTCLIENT && m_bEnableGroups)
  1774. {
  1775. CPoint point;
  1777. GetCursorPos(&point);
  1778. ScreenToClient(&point);
  1780. for (int nIndex = 0; nIndex < GetWorkspaceCount(); nIndex++)
  1781. {
  1782. CWorkspace* pWorkspace = GetWorkspace(nIndex);
  1783. if (pWorkspace->m_rcSplitter.PtInRect(point))
  1784. {
  1785. SetCursor(!m_bHorizSplitting ? m_hCursorHoriz : m_hCursorVert);
  1786. return TRUE;
  1787. }
  1788. }
  1789. }
  1791. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1792. }
  1794. void CXTPTabClientWnd::CalcWindowRect(LPRECT lpClientRect, UINT nAdjustType)
  1795. {
  1796. if (GetWorkspaceCount() == 0 || !m_bShowWorkspace || m_bUserWorkspace)
  1797. {
  1798. CWnd::CalcWindowRect(lpClientRect, nAdjustType);
  1799. return;
  1800. }
  1802. if (!m_bEnableGroups)
  1803. {
  1804. CSingleWorkspace* pWorkspace = (CSingleWorkspace*)GetWorkspace(0);
  1806. // now do the laying out
  1807. HDWP dwh = BeginDeferWindowPos(2);
  1809. // move tab window
  1810. if (::IsWindow(pWorkspace->m_hWnd) && (pWorkspace->GetStyle() & WS_VISIBLE) == WS_VISIBLE)
  1811. {
  1812. {
  1814. // move tab control
  1815. dwh = ::DeferWindowPos(dwh, pWorkspace->m_hWnd, NULL, lpClientRect->left,
  1816. lpClientRect->top,
  1817. lpClientRect->right-lpClientRect->left,
  1818. lpClientRect->bottom-lpClientRect->top, SWP_NOZORDER);
  1821. CClientDC dc(pWorkspace);
  1823. CRect rectTab(lpClientRect);
  1824. rectTab.OffsetRect(-rectTab.TopLeft());
  1826. GetPaintManager()->RepositionTabControl(pWorkspace, &dc, rectTab);
  1828. CRect rectTabAdjust(lpClientRect);
  1829. GetPaintManager()->AdjustClientRect(pWorkspace, rectTabAdjust);
  1830. *lpClientRect = rectTabAdjust;
  1833. pWorkspace->Invalidate(FALSE);
  1834. }
  1836. if (lpClientRect->bottom < lpClientRect->top ||
  1837. lpClientRect->right < lpClientRect->left)
  1838. ::memset(lpClientRect, 0, sizeof(RECT));
  1840. ::ShowWindow(pWorkspace->m_hWnd, SW_SHOWNA);
  1841. }
  1843. // move MDIClient window
  1844. dwh = ::DeferWindowPos(dwh, m_hWnd, NULL, lpClientRect->left, lpClientRect->top,
  1845. lpClientRect->right - lpClientRect->left,
  1846. lpClientRect->bottom - lpClientRect->top,
  1847. SWP_NOZORDER);
  1849. EndDeferWindowPos(dwh);
  1850. }
  1851. else
  1852. {
  1854. CClientDC dc(this);
  1856. CRect rcBorders(2, 2, -2, -2);
  1857. m_pPaintManager->GetAppearanceSet()->DrawWorkspacePart(NULL, rcBorders, xtpTabWorkspacePartWidth);
  1859. CRect rcClient(0, 0, lpClientRect->right-lpClientRect->left + rcBorders.Width(), lpClientRect->bottom-lpClientRect->top + rcBorders.Height());
  1861. int nIndex;
  1862. double dTotalHeight = 0;
  1863. int nWorkspaceCount = GetWorkspaceCount();
  1865. for (nIndex = 0; nIndex < nWorkspaceCount; nIndex++)
  1866. {
  1867. dTotalHeight += GetWorkspace(nIndex)->m_dHeight;
  1868. }
  1869. int nTotalHeight = (m_bHorizSplitting ? rcClient.Height() : rcClient.Width()) - m_nSplitterSize * (nWorkspaceCount - 1);
  1870. double dHeight = 0;
  1871. if ((int)dTotalHeight == 0) dTotalHeight = 1.0;
  1873. CRect rcWorkspace(rcClient);
  1875. for (nIndex = 0; nIndex < nWorkspaceCount; nIndex++)
  1876. {
  1877. CWorkspace* pWorkspace = GetWorkspace(nIndex);
  1879. CRect rc(rcClient);
  1880. if (nIndex != nWorkspaceCount - 1)
  1881. {
  1882. dHeight = dHeight += pWorkspace->m_dHeight;
  1884. int nHeight = int(dHeight * nTotalHeight / dTotalHeight) + m_nSplitterSize * nIndex;
  1886. if (m_bHorizSplitting)
  1887. {
  1888. pWorkspace->m_rcSplitter.SetRect(rc.left, rcWorkspace.top + nHeight, rc.right, rcWorkspace.top + nHeight + m_nSplitterSize);
  1890. rc.bottom = rcWorkspace.top + nHeight;
  1891. rcClient.top = rc.bottom + m_nSplitterSize;
  1892. }
  1893. else
  1894. {
  1895. pWorkspace->m_rcSplitter.SetRect(rcWorkspace.left + nHeight, rc.top, rcWorkspace.left + nHeight + m_nSplitterSize, rc.bottom);
  1897. rc.right = rcWorkspace.left + nHeight;
  1898. rcClient.left = rc.right + m_nSplitterSize;
  1899. }
  1900. }
  1901. else
  1902. {
  1903. pWorkspace->m_rcSplitter.SetRectEmpty();
  1905. }
  1908. GetPaintManager()->RepositionTabControl(pWorkspace, &dc, rc);
  1909. rc = pWorkspace->GetClientRect();
  1911. for (int i = 0; i < pWorkspace->GetItemCount(); i++)
  1912. {
  1913. HWND hWndChild = pWorkspace->GetItem(i)->m_hWnd;
  1914. ::MoveWindow(hWndChild, rc.left, rc.top, rc.Width(), rc.Height(), TRUE);
  1915. }
  1916. }
  1918. Invalidate(FALSE);
  1919. //UpdateWindow();
  1920. }
  1922. CWnd::CalcWindowRect(lpClientRect, nAdjustType);
  1923. }
  1925. // update the size of the tab control and the MDIClient window
  1926. void CXTPTabClientWnd::OnSize(UINT nType, int cx, int cy)
  1927. {
  1928. CWnd::OnSize(nType, cx, cy);
  1929. }
  1931. BOOL CXTPTabClientWnd::OnEraseBkgnd(CDC*)
  1932. {
  1933. if (!m_bThemedBackColor && !m_bEnableGroups)
  1934. {
  1935. return (BOOL)Default();
  1936. }
  1937. return TRUE;
  1938. }
  1940. LRESULT CXTPTabClientWnd::OnPrintClient(WPARAM wParam, LPARAM)
  1941. {
  1942. if (!m_bThemedBackColor && !m_bEnableGroups)
  1943. {
  1944. return (LRESULT)Default();
  1945. }
  1947. CDC* pDC = CDC::FromHandle((HDC)wParam);
  1948. if (pDC)
  1949. {
  1950. CXTPClientRect rc(this);
  1951. OnDraw(pDC, rc);
  1952. }
  1953. return TRUE;
  1954. }
  1956. void CXTPTabClientWnd::OnFillBackground(CDC* pDC, CRect rc)
  1957. {
  1958. CXTPCommandBars* pCommandBars = GetCommandBars();
  1959. if (pCommandBars)
  1960. {
  1961. if (!m_bThemedBackColor)
  1962. DefWindowProc(WM_PAINT, (WPARAM)pDC->m_hDC, 0);
  1963. else
  1964. pDC->FillSolidRect(rc, pCommandBars->GetPaintManager()->GetXtremeColor(COLOR_APPWORKSPACE));
  1965. }
  1966. else
  1967. {
  1968. pDC->FillSolidRect(rc, GetSysColor(COLOR_APPWORKSPACE));
  1969. }
  1971. }
  1973. void CXTPTabClientWnd::OnDraw(CDC* pDC, CRect rc)
  1974. {
  1975. if (GetWorkspaceCount() == 0 || !m_bEnableGroups)
  1976. {
  1977. OnFillBackground(pDC, rc);
  1978. }
  1979. else
  1980. {
  1981. CRect rcClipBox;
  1982. pDC->GetClipBox(&rcClipBox);
  1984. for (int i = GetWorkspaceCount() - 1; i >= 0; i--)
  1985. {
  1986. CWorkspace* pWorkspace = GetWorkspace(i);
  1988. if (CRect().IntersectRect(rcClipBox, pWorkspace->m_rcControl))
  1989. {
  1990. GetPaintManager()->DrawTabControl(GetWorkspace(i), pDC, pWorkspace->m_rcControl);
  1991. }
  1993. if (!pWorkspace->m_rcSplitter.IsRectEmpty())
  1994. {
  1995. m_pPaintManager->GetAppearanceSet()->DrawWorkspacePart(pDC, pWorkspace->m_rcSplitter, m_bHorizSplitting ? xtpTabWorkspacePartHSplitter : xtpTabWorkspacePartVSplitter);
  1996. }
  1997. }
  1998. }
  1999. }
  2001. void CXTPTabClientWnd::OnPaint()
  2002. {
  2003. if (!m_bThemedBackColor && !m_bEnableGroups)
  2004. {
  2005. Default();
  2006. return;
  2007. }
  2008. CPaintDC dcPaint(this);
  2009. CXTPClientRect rc(this);
  2010. CXTPBufferDC dc(dcPaint);
  2012. OnDraw(&dc, rc);
  2013. }
  2015. void CXTPTabClientWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp)
  2016. {
  2017. if (m_bEnableGroups)
  2018. {
  2019. m_pPaintManager->GetAppearanceSet()->DrawWorkspacePart(NULL, &lpncsp->rgrc[0], xtpTabWorkspacePartWidth);
  2020. }
  2022. CWnd::OnNcCalcSize(bCalcValidRects, lpncsp);
  2023. }
  2026. BOOL CXTPTabClientWnd::OnNcActivate(BOOL bActive)
  2027. {
  2028. if (m_bEnableGroups)
  2029. return TRUE;
  2031. return CWnd::OnNcActivate(bActive);
  2032. }
  2034. void CXTPTabClientWnd::OnNcPaint()
  2035. {
  2036. if (!m_bEnableGroups)
  2037. {
  2038. Default();
  2039. return;
  2040. }
  2042. CWindowDC dcPaint(this);
  2043. CXTPWindowRect rc(this);
  2044. rc.OffsetRect(rc.TopLeft());
  2046. m_pPaintManager->GetAppearanceSet()->DrawWorkspacePart(&dcPaint, rc, xtpTabWorkspacePartBorder);
  2047. }
  2049. void CXTPTabClientWnd::OnRButtonDown(UINT nFlags, CPoint point)
  2050. {
  2051. CWnd::OnRButtonDown(nFlags, point);
  2053. }
  2055. void CXTPTabClientWnd::RepositionWorkspaces(CRect rc, CRect rcAvail, CWorkspace* pWorkspaceFirst, CWorkspace* pWorkspaceSecond)
  2056. {
  2057. double dTotal = pWorkspaceFirst->m_dHeight + pWorkspaceSecond->m_dHeight + m_nSplitterSize;
  2059. if (!m_bHorizSplitting)
  2060. {
  2061. double dDelta = double(rc.left - rcAvail.left) / rcAvail.Width();
  2062. pWorkspaceFirst->m_dHeight = GetExStyle() & WS_EX_LAYOUTRTL ? dTotal - dDelta * dTotal - m_nSplitterSize : dDelta * dTotal;
  2063. }
  2064. else
  2065. {
  2066. double dDelta = double(rc.top - rcAvail.top) / rcAvail.Height();
  2067. pWorkspaceFirst->m_dHeight = dDelta * dTotal;
  2068. }
  2070. pWorkspaceSecond->m_dHeight = dTotal - pWorkspaceFirst->m_dHeight - m_nSplitterSize;
  2071. }
  2073. void CXTPTabClientWnd::NormalizeWorkspaceSize()
  2074. {
  2075. for (int i = 0; i < GetWorkspaceCount(); i++)
  2076. {
  2077. CWorkspace* pWorkspace = GetWorkspace (i);
  2078. pWorkspace->m_dHeight = !m_bHorizSplitting ? pWorkspace->GetControlRect().Width() : pWorkspace->GetControlRect().Height();
  2079. }
  2080. }
  2082. void CXTPTabClientWnd::TrackSplitter(int nWorkspace, CPoint point)
  2083. {
  2084. ASSERT(nWorkspace >= 0 && nWorkspace < GetWorkspaceCount() - 1);
  2086. if (nWorkspace < 0 || nWorkspace >= GetWorkspaceCount() - 1)
  2087. return;
  2089. NormalizeWorkspaceSize();
  2091. CXTPSplitterTracker tracker;
  2093. CWorkspace* pWorkspaceFirst = m_arrWorkspace[nWorkspace];
  2094. CWorkspace* pWorkspaceSecond = m_arrWorkspace[nWorkspace + 1];
  2096. CRect rcFirst = pWorkspaceFirst->GetControlRect();
  2097. CRect rcSecond = pWorkspaceSecond->GetControlRect();
  2099. CRect rcAvail;
  2100. rcAvail.UnionRect(rcFirst, rcSecond);
  2102. CRect rc = pWorkspaceFirst->m_rcSplitter;
  2104. ClientToScreen(&rc);
  2105. ClientToScreen(&rcAvail);
  2106. ClientToScreen(&point);
  2108. if (m_bUseSplitterTracker)
  2109. {
  2110. if (tracker.Track(this, rcAvail, rc, point, !m_bHorizSplitting))
  2111. {
  2112. RepositionWorkspaces(rc, rcAvail, pWorkspaceFirst, pWorkspaceSecond);
  2113. GetParentFrame()->RecalcLayout();
  2114. }
  2115. }
  2116. else
  2117. {
  2118. CPoint ptOffset = !m_bHorizSplitting ? CPoint(rc.left - point.x, 0) :
  2119. CPoint(0, rc.top - point.y);
  2121. SetCapture();
  2123. while (CWnd::GetCapture() == this)
  2124. {
  2125. MSG msg;
  2127. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  2128. {
  2129. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  2130. return;
  2131. DispatchMessage(&msg);
  2132. }
  2134. if (!GetMessage(&msg, NULL, 0, 0))
  2135. break;
  2137. if (msg.message == WM_MOUSEMOVE)
  2138. {
  2140. point = CPoint(msg.lParam);
  2141. ClientToScreen(&point);
  2142. point += ptOffset;
  2144. point.x = max(min(point.x, rcAvail.right), rcAvail.left);
  2145. point.y = max(min(point.y, rcAvail.bottom), rcAvail.top);
  2147. if (!m_bHorizSplitting)
  2148. {
  2149. if (rc.left == point.x)
  2150. continue;
  2151. rc.OffsetRect(point.x - rc.left, 0);
  2152. }
  2153. else
  2154. {
  2155. if (rc.top == point.y)
  2156. continue;
  2157. rc.OffsetRect(0, point.y - rc.top);
  2158. }
  2160. RepositionWorkspaces(rc, rcAvail, pWorkspaceFirst, pWorkspaceSecond);
  2162. GetParentFrame()->RecalcLayout();
  2163. }
  2164. else if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) break;
  2165. else if (msg.message == WM_LBUTTONUP) break;
  2166. else ::DispatchMessage(&msg);
  2167. }
  2169. if (CWnd::GetCapture() == this) ReleaseCapture();
  2171. }
  2173. }
  2175. void CXTPTabClientWnd::OnLButtonDown(UINT nFlags, CPoint point)
  2176. {
  2177. if (!m_bEnableGroups)
  2178. {
  2179. CWnd::OnLButtonDown(nFlags, point);
  2180. return;
  2181. }
  2183. m_bLockUpdate = TRUE;
  2185. m_bDelayLock = TRUE;
  2187. for (int i = 0; i < GetWorkspaceCount(); i++)
  2188. {
  2189. CWorkspace* pWorkspace = GetWorkspace(i);
  2190. if (pWorkspace->m_rcSplitter.PtInRect(point) && i < GetWorkspaceCount() - 1)
  2191. {
  2192. TrackSplitter(i, point);
  2193. break;
  2194. }
  2196. if (pWorkspace->GetControlRect().PtInRect(point))
  2197. {
  2198. if (!pWorkspace->IsActive())
  2199. {
  2200. CXTPTabManagerItem* pSelectedItem = pWorkspace->GetSelectedItem();
  2201. if (pSelectedItem) pWorkspace->OnItemClick(pSelectedItem);
  2202. }
  2204. pWorkspace->PerformClick(m_hWnd, point);
  2205. break;
  2206. }
  2207. }
  2209. }
  2212. void CXTPTabClientWnd::InitLoop()
  2213. {
  2214. // handle pending WM_PAINT messages
  2215. MSG msg;
  2216. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  2217. {
  2218. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  2219. return;
  2220. DispatchMessage(&msg);
  2221. }
  2223. // initialize state
  2224. m_rectLast.SetRectEmpty();
  2225. m_sizeLast.cx = m_sizeLast.cy = 0;
  2226. m_rcGroup.SetRectEmpty();
  2227. m_pFocusWorkspace = NULL;
  2229. // lock window update while dragging
  2230. ASSERT(m_pDC == NULL);
  2231. CWnd* pWnd = CWnd::GetDesktopWindow();
  2232. if (pWnd->LockWindowUpdate())
  2233. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE | DCX_LOCKWINDOWUPDATE);
  2234. else
  2235. m_pDC = pWnd->GetDCEx(NULL, DCX_WINDOW | DCX_CACHE);
  2236. ASSERT(m_pDC != NULL);
  2237. }
  2239. void CXTPTabClientWnd::CancelLoop()
  2240. {
  2241. DrawFocusRect(TRUE);    // gets rid of focus rect
  2243. CWnd* pWnd = CWnd::GetDesktopWindow();
  2244. pWnd->UnlockWindowUpdate();
  2245. if (m_pDC != NULL)
  2246. {
  2247. pWnd->ReleaseDC(m_pDC);
  2248. m_pDC = NULL;
  2249. }
  2250. }
  2252. void CXTPTabClientWnd::DrawFocusRect(BOOL bRemoveRect)
  2253. {
  2254. ASSERT(m_pDC != NULL);
  2255. if (!m_pDC)
  2256. return;
  2258. // determine new rect and size
  2259. CBrush* pDitherBrush = CDC::GetHalftoneBrush();
  2260. CRect rect = m_rcGroup;
  2261. ClientToScreen(rect);
  2263. CSize size(GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME));
  2265. if (bRemoveRect)
  2266. size.cx = size.cy = 0;
  2268. // draw it and remember last size
  2269. m_pDC->DrawDragRect(&rect, size, &m_rectLast, m_sizeLast,
  2270. pDitherBrush, pDitherBrush);
  2272. m_rectLast = rect;
  2273. m_sizeLast = size;
  2274. }
  2277. void CXTPTabClientWnd::ReorderWorkspace(CPoint pt, CXTPTabManagerItem* pItem)
  2278. {
  2279. CXTPClientRect rc(this);
  2281. CRect rcGroup(0, 0, 0, 0);
  2282. m_pFocusWorkspace = NULL;
  2283. m_nFocusedAction = ACTION_CANCEL;
  2285. if (rc.PtInRect(pt))
  2286. {
  2287. m_nFocusedAction = ACTION_POPUP;
  2288. ::SetCursor(m_hCursorNew);
  2290. for (int i = 0; i < GetWorkspaceCount(); i++)
  2291. {
  2292. CWorkspace* pWorkspace = GetWorkspace(i);
  2294. BOOL bSelfAvail = pItem->GetTabManager() != pWorkspace || pWorkspace->GetItemCount() > 1;
  2296. if (pWorkspace->GetHeaderRect().PtInRect(pt))
  2297. {
  2298. rcGroup = pWorkspace->GetClientRect();
  2300. m_pFocusWorkspace = pWorkspace;
  2301. m_nFocusedAction = ACTION_ATTACH;
  2302. break;
  2303. }
  2305. if ((GetWorkspaceCount() == 1 || m_bHorizSplitting) && bSelfAvail)
  2306. {
  2307. int nOffset = pWorkspace->GetControlRect().bottom - pt.y;
  2308. if (nOffset > 0 && nOffset < 30)
  2309. {
  2310. rcGroup = pWorkspace->GetControlRect();
  2311. rcGroup.top = rcGroup.CenterPoint().y;
  2313. m_pFocusWorkspace = pWorkspace;
  2314. m_nFocusedAction = ACTION_INSERTHORIZ;
  2315. break;
  2316. }
  2318. }
  2320. if ((GetWorkspaceCount() == 1 || !m_bHorizSplitting) && bSelfAvail)
  2321. {
  2322. int nOffset = pWorkspace->GetControlRect().right - pt.x;
  2323. if (nOffset > 0 && nOffset < 30)
  2324. {
  2325. rcGroup = pWorkspace->GetControlRect();
  2326. rcGroup.left = rcGroup.CenterPoint().x;
  2328. m_pFocusWorkspace = pWorkspace;
  2329. m_nFocusedAction = ACTION_INSERTVERT;
  2330. break;
  2331. }
  2332. }
  2333. }
  2334. }
  2335. else
  2336. {
  2337. ::SetCursor(m_hCursorDelete);
  2338. }
  2340. if (m_rcGroup != rcGroup)
  2341. {
  2342. m_rcGroup = rcGroup;
  2343. DrawFocusRect();
  2344. }
  2345. }
  2347. int CXTPTabClientWnd::FindIndex(CXTPTabManager* pWorkspace) const
  2348. {
  2349. for (int i = 0; i < GetWorkspaceCount(); i++)
  2350. {
  2351. if (GetWorkspace(i) == pWorkspace)
  2352. return i;
  2353. }
  2354. return -1;
  2355. }
  2357. CXTPTabManagerItem* CXTPTabClientWnd::HitTest(CPoint pt) const
  2358. {
  2359. if (!m_bShowWorkspace)
  2360. return NULL;
  2362. for (int i = 0; i < GetWorkspaceCount(); i++)
  2363. {
  2364. CXTPTabManagerItem* pItem = GetWorkspace(i)->HitTest(pt);
  2365. if (pItem)
  2366. return pItem;
  2367. }
  2368. return NULL;
  2369. }
  2371. CXTPCommandBars* CXTPTabClientWnd::GetCommandBars() const
  2372. {
  2373. if (!m_pParentFrame)
  2374. return NULL;
  2375. return ((CXTPMDIFrameWnd*)m_pParentFrame)->GetCommandBars();
  2376. }
  2378. void CXTPTabClientWnd::ContextMenu(CPoint pt)
  2379. {
  2380. CXTPPopupBar* pPopupBar = CXTPPopupBar::CreatePopupBar(GetCommandBars());
  2382. ClientToScreen(&pt);
  2384. pPopupBar->GetControls()->Add(new CXTPControlWorkspaceActions, 0);
  2386. CXTPControl* pControl = pPopupBar->GetControls()->Add(xtpControlButton, XTP_ID_WORKSPACE_CANCEL);
  2387. pControl->SetBeginGroup(TRUE);
  2388. pControl->SetFlags(xtpFlagManualUpdate);
  2390. CXTPCommandBars::TrackPopupMenu(pPopupBar, 0, pt.x, pt.y, GetParentFrame());
  2392. pPopupBar->InternalRelease();
  2394. }
  2396. void CXTPTabClientWnd::OnWorkspaceCommand(UINT nID)
  2397. {
  2398. CXTPTabManagerItem* pItem = NULL;
  2400. if (!IsWorkspaceCommandEnabled(nID, &pItem))
  2401. return;
  2403. ASSERT(pItem);
  2404. if (!pItem)
  2405. return;
  2407. switch (nID)
  2408. {
  2409. case XTP_ID_WORKSPACE_NEWVERTICAL:
  2410. DoWorkspaceCommand(pItem, (CWorkspace*)pItem->GetTabManager(), ACTION_INSERTVERT);
  2411. break;
  2413. case XTP_ID_WORKSPACE_NEWHORIZONTAL:
  2414. DoWorkspaceCommand(pItem, (CWorkspace*)pItem->GetTabManager(), ACTION_INSERTHORIZ);
  2415. break;
  2417. case XTP_ID_WORKSPACE_MOVEPREVIOUS:
  2418. {
  2419. int nIndex = FindIndex(pItem->GetTabManager());
  2420. DoWorkspaceCommand(pItem, GetWorkspace(nIndex - 1), ACTION_ATTACH);
  2421. }
  2422. break;
  2423. case XTP_ID_WORKSPACE_MOVENEXT:
  2424. {
  2425. int nIndex = FindIndex(pItem->GetTabManager());
  2426. DoWorkspaceCommand(pItem, GetWorkspace(nIndex + 1), ACTION_ATTACH);
  2427. }
  2428. break;
  2429. }
  2430. }
  2432. void CXTPTabClientWnd::OnUpdateWorkspaceCommand(CCmdUI* pCmdUI)
  2433. {
  2434. pCmdUI->Enable(IsWorkspaceCommandEnabled(pCmdUI->m_nID));
  2435. }
  2437. BOOL CXTPTabClientWnd::IsWorkspaceCommandEnabled(UINT nID, CXTPTabManagerItem** ppItem)
  2438. {
  2439. if (!m_bEnableGroups)
  2440. return FALSE;
  2442. CWnd* pWnd = MDIGetActive();
  2443. if (!pWnd)
  2444. return FALSE;
  2446. CXTPTabManagerItem* pItem = FindItem(pWnd->GetSafeHwnd());
  2447. if (!pItem)
  2448. return FALSE;
  2450. if (ppItem)
  2451. *ppItem = pItem;
  2453. switch (nID)
  2454. {
  2455. case XTP_ID_WORKSPACE_NEWVERTICAL:
  2456. return (GetWorkspaceCount() == 1 || !m_bHorizSplitting) && pItem->GetTabManager()->GetItemCount() > 1;
  2458. case XTP_ID_WORKSPACE_NEWHORIZONTAL:
  2459. return (GetWorkspaceCount() == 1 || m_bHorizSplitting) && pItem->GetTabManager()->GetItemCount() > 1;
  2461. case XTP_ID_WORKSPACE_MOVEPREVIOUS:
  2462. return FindIndex(pItem->GetTabManager()) != 0;
  2464. case XTP_ID_WORKSPACE_MOVENEXT:
  2465. return FindIndex(pItem->GetTabManager()) != GetWorkspaceCount() - 1;
  2467. }
  2468. return TRUE;
  2469. }
  2472. void CXTPTabClientWnd::MDITile(BOOL bHorizontal)
  2473. {
  2474. if (!m_bEnableGroups || m_bUserWorkspace)
  2475. return;
  2477. if (GetItemCount() < 2)
  2478. return;
  2480. m_bLockUpdate = m_bLockReposition = TRUE;
  2482. CArray<CXTPTabManagerItem*, CXTPTabManagerItem*> arrItems;
  2484. while (GetWorkspaceCount() > 0)
  2485. {
  2486. CWorkspace* pWorkspace = GetWorkspace(0);
  2488. for (int j = 0; j < pWorkspace->GetItemCount(); j++)
  2489. {
  2490. CXTPTabManagerItem* pItem = pWorkspace->GetItem(j);
  2491. arrItems.Add(pItem);
  2492. pItem->InternalAddRef();
  2493. }
  2495. m_arrWorkspace.RemoveAt(0);
  2496. delete pWorkspace;
  2497. }
  2499. for (int i = 0; i < (int)arrItems.GetSize(); i++)
  2500. {
  2501. CXTPTabManagerItem* pItem = arrItems[i];
  2502. COLORREF clr = pItem->m_clrItem;
  2504. CWorkspace* pWorkspace = AddWorkspace(i);
  2506. pWorkspace->CXTPTabManager::AddItem(-1, pItem);
  2508. pItem->m_clrItem = clr;
  2509. pWorkspace->SetSelectedItem(pItem);
  2511. pWorkspace->m_dHeight = 100;
  2512. }
  2514. m_pActiveWorkspace = NULL;
  2515. m_bHorizSplitting = bHorizontal;
  2517. m_bLockUpdate = m_bLockReposition = FALSE;
  2518. m_bForceToRecalc = TRUE;
  2519. UpdateContents();
  2521. NormalizeWorkspaceSize();
  2522. }
  2524. void CXTPTabClientWnd::DoWorkspaceCommand(CXTPTabManagerItem* pItem, CWorkspace* pFocusWorkspace, int nAction)
  2525. {
  2526. m_bLockUpdate = m_bLockReposition = TRUE;
  2527. CWorkspace* pOldWorkspace = NULL;
  2529. switch (nAction)
  2530. {
  2531. case ACTION_ATTACH:
  2532. {
  2533. ASSERT(pFocusWorkspace);
  2534. if (!pFocusWorkspace)
  2535. return;
  2537. if (pFocusWorkspace != pItem->GetTabManager())
  2538. {
  2539. pOldWorkspace = (CWorkspace*)pItem->GetTabManager();
  2540. pItem->InternalAddRef();
  2541. pItem->Remove();
  2543. COLORREF clr = pItem->m_clrItem;
  2544. pFocusWorkspace->CXTPTabManager::AddItem(-1, pItem);
  2545. pItem->m_clrItem = clr;
  2546. }
  2548. pFocusWorkspace->SetSelectedItem(pItem);
  2550. break;
  2551. }
  2552. case ACTION_INSERTHORIZ:
  2553. case ACTION_INSERTVERT:
  2554. {
  2555. NormalizeWorkspaceSize();
  2557. ASSERT(pFocusWorkspace);
  2558. if (!pFocusWorkspace)
  2559. return;
  2561. pOldWorkspace = (CWorkspace*)pItem->GetTabManager();
  2563. pItem->InternalAddRef();
  2564. pItem->Remove();
  2566. COLORREF clr = pItem->m_clrItem;
  2568. int nIndex = FindIndex(pFocusWorkspace) + 1;
  2569. CWorkspace* pWorkspace = AddWorkspace(nIndex);
  2571. pWorkspace->CXTPTabManager::AddItem(-1, pItem);
  2573. pItem->m_clrItem = clr;
  2574. pWorkspace->SetSelectedItem(pItem);
  2576. pWorkspace->m_dHeight = (pFocusWorkspace->m_dHeight - m_nSplitterSize) / 2;
  2577. pFocusWorkspace->m_dHeight = pFocusWorkspace->m_dHeight - pWorkspace->m_dHeight - m_nSplitterSize;
  2579. m_bHorizSplitting = (nAction == ACTION_INSERTHORIZ);
  2580. break;
  2581. }
  2583. }
  2585. if (pOldWorkspace && pOldWorkspace->GetItemCount() > 1)
  2586. {
  2587. HWND hWndChild = ::GetWindow(m_hWnd, GW_CHILD);
  2588. while (hWndChild)
  2589. {
  2590. CXTPTabManagerItem* pItemOld = FindItem(hWndChild);
  2591. if (pItemOld && pItemOld->GetTabManager() == pOldWorkspace)
  2592. {
  2593. pOldWorkspace->SetSelectedItem(pItemOld);
  2594. break;
  2595. }
  2596. hWndChild = ::GetWindow(hWndChild, GW_HWNDNEXT);
  2597. }
  2598. }
  2600. m_bLockUpdate = m_bLockReposition = FALSE;
  2601. m_bForceToRecalc = TRUE;
  2602. UpdateContents();
  2603. }
  2605. void CXTPTabClientWnd::OnMouseMove(UINT nFlags, CPoint point)
  2606. {
  2607. if (m_bEnableGroups)
  2608. {
  2609. for (int i = 0; i < GetWorkspaceCount(); i++)
  2610. {
  2611. GetWorkspace(i)->PerformMouseMove(m_hWnd, point);
  2612. }
  2613. }
  2615. CWnd::OnMouseMove(nFlags, point);
  2616. }
  2619. void CXTPTabClientWnd::OnMouseLeave()
  2620. {
  2621. if (m_bEnableGroups)
  2622. {
  2623. for (int i = 0; i < GetWorkspaceCount(); i++)
  2624. {
  2625. GetWorkspace(i)->PerformMouseMove(m_hWnd, CPoint(-1, -1));
  2626. }
  2627. }
  2628. }
  2632. void CXTPTabClientWnd::OnLButtonDblClk(UINT nFlags, CPoint point)
  2633. {
  2634. OnLButtonDown(nFlags, point);
  2635. }
  2637. void CXTPTabClientWnd::OnSysColorChange()
  2638. {
  2639. CWnd::OnSysColorChange();
  2641. GetPaintManager()->RefreshMetrics();
  2643. Refresh();
  2644. }
  2646. BOOL CXTPTabClientWnd::PreTranslateMessage(MSG* pMsg)
  2647. {
  2648. if (m_bEnableGroups)
  2649. {
  2651. if (pMsg->message == WM_LBUTTONDOWN ||
  2652. pMsg->message == WM_RBUTTONDOWN ||
  2653. pMsg->message == WM_MBUTTONDOWN ||
  2654. pMsg->message == WM_LBUTTONDBLCLK ||
  2655. pMsg->message == WM_RBUTTONDBLCLK)
  2656. {
  2657. if (pMsg->hwnd != m_hWnd)
  2658. return CWnd::PreTranslateMessage(pMsg);
  2660. if (GetParentFrame()->SendMessage(WM_XTP_PRETRANSLATEMOUSEMSG, (WPARAM)pMsg->message, pMsg->lParam))
  2661. return TRUE;
  2662. }
  2663. }
  2665. return CWnd::PreTranslateMessage(pMsg);
  2666. }
  2668. CXTPTabPaintManager* CXTPTabClientWnd::GetPaintManager() const
  2669. {
  2670. return m_pPaintManager;
  2671. }
  2673. void CXTPTabClientWnd::SetPaintManager(CXTPTabPaintManager* pPaintManager)
  2674. {
  2675. m_pPaintManager->InternalRelease();
  2676. m_pPaintManager = pPaintManager;
  2677. m_pPaintManager->RefreshMetrics();
  2679. m_themeCommandBars = xtpThemeCustom;
  2680. m_bAutoTheme = FALSE;
  2682. Refresh();
  2683. }
  2685. void CXTPTabClientWnd::SetAutoTheme(BOOL bAutoTheme /*= FALSE*/)
  2686. {
  2687. m_bAutoTheme = bAutoTheme;
  2688. }
  2690. BOOL CXTPTabClientWnd::GetAutoTheme() const
  2691. {
  2692. return m_bAutoTheme;
  2693. }
  2695. void CXTPTabClientWnd::UpdateFlags(CWorkspace* pWorkspace)
  2696. {
  2697. pWorkspace->FindNavigateButton(xtpTabNavigateButtonClose)->SetFlags(
  2698. m_dwFlags & xtpWorkspaceHideClose ? xtpTabNavigateButtonNone : xtpTabNavigateButtonAutomatic);
  2700. pWorkspace->FindNavigateButton(xtpTabNavigateButtonActiveFiles)->SetFlags(
  2701. m_dwFlags & xtpWorkspaceShowActiveFiles ? xtpTabNavigateButtonAlways : xtpTabNavigateButtonNone);
  2703. pWorkspace->FindNavigateButton(xtpTabNavigateButtonLeft)->SetFlags((m_dwFlags & xtpWorkspaceHideArrowsAlways) == xtpWorkspaceHideArrowsAlways ? xtpTabNavigateButtonNone :
  2704. m_dwFlags & xtpWorkspaceHideArrows ? xtpTabNavigateButtonAutomatic : xtpTabNavigateButtonAlways);
  2705. pWorkspace->FindNavigateButton(xtpTabNavigateButtonRight)->SetFlags((m_dwFlags & xtpWorkspaceHideArrowsAlways) == xtpWorkspaceHideArrowsAlways ? xtpTabNavigateButtonNone :
  2706. m_dwFlags & xtpWorkspaceHideArrows ? xtpTabNavigateButtonAutomatic : xtpTabNavigateButtonAlways);
  2709. if (m_dwFlags & xtpWorkspaceShowCloseTab || m_dwFlags & xtpWorkspaceShowCloseSelectedTab)
  2710. {
  2711. pWorkspace->ShowCloseItemButton(m_dwFlags & xtpWorkspaceShowCloseSelectedTab ?
  2712. xtpTabNavigateButtonAutomatic : xtpTabNavigateButtonAlways);
  2713. }
  2714. }
  2717. void CXTPTabClientWnd::SetFlags(DWORD dwFlags)
  2718. {
  2719. m_dwFlags = dwFlags;
  2721. for (int i = 0; i < GetWorkspaceCount(); i++)
  2722. UpdateFlags(GetWorkspace(i));
  2724. Reposition();
  2725. }
  2727. void CXTPTabClientWnd::Reposition()
  2728. {
  2729. m_bForceToRecalc = FALSE;
  2731. if (m_pTabWorkspace)
  2732. {
  2733. m_pTabWorkspace->OnRecalcLayout();
  2734. }
  2735. else if (!m_bUserWorkspace)
  2736. {
  2737. GetParentFrame()->RecalcLayout();
  2738. }
  2739. }
  2741. BOOL CXTPTabClientWnd::IsAllowReorder() const
  2742. {
  2743. return m_bAllowReorder;
  2744. }
  2746. void CXTPTabClientWnd::SetAllowReorder(BOOL bAllowReorder)
  2747. {
  2748. m_bAllowReorder = bAllowReorder;
  2749. }
  2751. CXTPTabManagerItem* CXTPTabClientWnd::GetSelectedItem () const
  2752. {
  2753. if (m_pActiveWorkspace)
  2754. return m_pActiveWorkspace->GetSelectedItem();
  2755. return NULL;
  2756. }
  2758. CXTPTabManagerItem* CXTPTabClientWnd::GetItem(int nIndex) const
  2759. {
  2760. for (int i = 0; i < GetWorkspaceCount(); i++)
  2761. {
  2762. CWorkspace* pWorkspace = GetWorkspace(i);
  2763. int nCount = pWorkspace->GetItemCount();
  2765. if (nIndex < nCount)
  2766. return pWorkspace->GetItem(nIndex);
  2768. nIndex -= nCount;
  2769. }
  2770. return NULL;
  2771. }
  2773. int CXTPTabClientWnd::GetItemCount() const
  2774. {
  2775. int nCount = 0;
  2777. for (int i = 0; i < GetWorkspaceCount(); i++)
  2778. nCount += GetWorkspace(i)->GetItemCount();
  2780. return nCount;
  2781. }
  2783. LRESULT CXTPTabClientWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  2784. {
  2785. if (m_bEnableGroups && IsAttached())
  2786. {
  2787. m_pToolTipContext->FilterToolTipMessage(this, message, wParam, lParam);
  2788. }
  2790. if (message == m_nMsgQuerySkinState && m_bEnableGroups && IsAttached())
  2791. {
  2792. return TRUE;
  2793. }
  2795. if (!m_bEnableGroups && (message == WM_MDIICONARRANGE || message == WM_MDICASCADE
  2796. || message == WM_MDITILE) && GetCommandBars())
  2797. {
  2798. XTPPaintTheme theme = GetCommandBars()->GetPaintManager()->BaseTheme();
  2800. if (theme == xtpThemeOffice2007 || theme == xtpThemeRibbon)
  2801. {
  2802. CArray<HWND, HWND&> arrChildren;
  2804. HWND hWnd = ::GetWindow(m_hWnd, GW_CHILD);
  2805. while (hWnd)
  2806. {
  2807. if ((GetWindowLong(hWnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
  2808. && ((GetWindowLong(hWnd, GWL_STYLE) & WS_CAPTION) != WS_CAPTION))
  2809. {
  2810. CWnd::ModifyStyle(hWnd, 0, WS_CAPTION, 0);
  2811. arrChildren.Add(hWnd);
  2812. }
  2813. hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
  2814. }
  2816. LRESULT lResult = CWnd::WindowProc(message, wParam, lParam);
  2818. for (int i = 0; i < (int)arrChildren.GetSize(); i++)
  2819. {
  2820. CWnd::ModifyStyle(arrChildren[i], WS_CAPTION, 0, 0);
  2821. }
  2823. return lResult;
  2824. }
  2825. }
  2827. return CWnd::WindowProc(message, wParam, lParam);
  2828. }
  2830. void CXTPTabClientWnd::SetTabWorkspace(CWorkspace* pWorkspace)
  2831. {
  2832. ASSERT(!m_bEnableGroups);
  2834. m_pTabWorkspace = pWorkspace;
  2835. m_bUserWorkspace = pWorkspace != NULL;
  2837. if (pWorkspace) pWorkspace->m_pTabClientWnd = this;
  2838. }