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

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

对话框与窗口

开发平台：

Visual C++

XTTabBase.cpp：源码内容
  1. // XTTabBase.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME CONTROLS 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"
  23. #include "Common/XTPVC80Helpers.h"  // Visual Studio 2005 helper functions
  24. #include "Common/XTPSystemHelpers.h"
  26. #include "XTDefines.h"
  27. #include "XTGlobal.h"
  28. #include "XTVC50Helpers.h"
  29. #include "XTTabCtrlButtons.h"
  30. #include "XTTabBase.h"
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  38. const int TABVIEW_BORDER = 4;
  40. IMPLEMENT_THEME_HOST(CXTTabBase)
  42. /////////////////////////////////////////////////////////////////////////////
  43. // CXTTabBase
  45. CXTTabBase::CXTTabBase()
  46. : CXTThemeManagerStyleHost(GetThemeFactoryClass())
  47. , m_pTabCtrl(NULL)
  48. , m_bPreSubclassInit(true)
  49. , m_bAutoCondensing(FALSE)
  50. , m_bXPBorder(false)
  51. , m_bBoldFont(true)
  52. {
  53. }
  55. CXTTabBase::~CXTTabBase()
  56. {
  57. SAFE_DELETE(m_pNavBtns);
  58. }
  60. void CXTTabBase::OnPaint()
  61. {
  62. CPaintDC dc(m_pTabCtrl); // device context for painting
  64. CXTPClientRect rcClient(m_pTabCtrl);
  65. CXTPBufferDC memDC(dc, rcClient);
  67. GetPaintManager()->DrawTabCtrl(&memDC, this);
  68. }
  70. BOOL CXTTabBase::OnEraseBkgnd(CDC* /*pDC*/)
  71. {
  72. return TRUE;
  73. }
  75. void CXTTabBase::OnSettingChange(UINT /*uFlags*/, LPCTSTR /*lpszSection*/)
  76. {
  77. GetPaintManager()->RefreshMetrics();
  78. }
  80. void CXTTabBase::OnSysColorChange()
  81. {
  82. GetPaintManager()->RefreshMetrics();
  83. }
  85. bool CXTTabBase::Init()
  86. {
  87. if (!::IsWindow(m_pTabCtrl->GetSafeHwnd()))
  88. return false;
  90. return true;
  91. }
  93. void CXTTabBase::PreSubclassWindow()
  94. {
  95. if (m_bPreSubclassInit)
  96. {
  97. // Initialize the control.
  98. Init();
  99. }
  100. }
  102. BOOL CXTTabBase::PreCreateWindow(CREATESTRUCT& /*cs*/)
  103. {
  104. // When creating controls dynamically Init() must
  105. // be called from OnCreate() and not from
  106. // PreSubclassWindow().
  108. m_bPreSubclassInit = false;
  110. return TRUE;
  111. }
  113. int CXTTabBase::OnCreate(LPCREATESTRUCT /*lpCreateStruct*/)
  114. {
  115. // Initialize the control.
  116. Init();
  118. return 0;
  119. }
  121. void CXTTabBase::ImplAttach(CTabCtrl* pTabCtrl)
  122. {
  123. ASSERT_VALID(pTabCtrl); // must be valid
  125. if (pTabCtrl != NULL)
  126. {
  127. m_pTabCtrl = pTabCtrl;
  129. m_pNavBtns = new CXTTabCtrlButtons;
  130. m_pNavBtns->Create(this);
  131. }
  132. }
  134. CXTTabBaseTheme* CXTTabBase::GetPaintManager()
  135. {
  136. return (CXTTabBaseTheme*)GetSafeTheme();
  137. }
  139. void CXTTabBase::ShowNavButtons(DWORD dwFlags)
  140. {
  141. if (!m_pNavBtns)
  142. return;
  144. m_pNavBtns->m_dwFlags = dwFlags;
  146. if (::IsWindow(m_pNavBtns->GetSafeHwnd()))
  147. {
  148. if (m_pNavBtns->ShowButtons())
  149. {
  150. m_pNavBtns->Refresh();
  151. }
  152. }
  153. }
  155. void CXTTabBase::OnAddPadding(CXTStringHelper& strLabelText)
  156. {
  157. if (!strLabelText.IsEmpty())
  158. {
  159. CClientDC dc(NULL);
  160. int iSaveDC = dc.SaveDC();
  162. CFont* pfontNormal = NULL;
  163. CFont* pfontSelect = NULL;
  165. if (m_pTabCtrl->GetStyle() & TCS_VERTICAL)
  166. {
  167. pfontNormal = &XTAuxData().fontVert;
  168. pfontSelect = &XTAuxData().fontVertBold;
  169. }
  170. else
  171. {
  172. pfontNormal = &XTAuxData().font;
  173. pfontSelect = &XTAuxData().fontBold;
  174. }
  176. dc.SelectObject(pfontSelect);
  177. CSize sizeSelect = dc.GetTextExtent(strLabelText);
  179. dc.SelectObject(pfontNormal);
  180. CSize sizeNormal = dc.GetTextExtent(strLabelText);
  182. bool bFront = true;
  184. while (sizeNormal.cx < sizeSelect.cx)
  185. {
  186. if (bFront)
  187. {
  188. strLabelText.Insert(0, _T(' '));
  189. bFront = false;
  190. }
  191. else
  192. {
  193. strLabelText += _T(' ');
  194. bFront = true;
  195. }
  196. sizeNormal = dc.GetTextExtent(strLabelText);
  197. }
  199. dc.RestoreDC(iSaveDC);
  200. }
  201. }
  203. void CXTTabBase::GetChildRect(CRect& rcChild) const
  204. {
  205. ASSERT_VALID(m_pTabCtrl);
  207. // Get the selected tab index.
  208. int nCurSel = m_pTabCtrl->GetCurSel();
  209. if (nCurSel == -1)
  210. {
  211. rcChild.SetRectEmpty();
  212. return;
  213. }
  215. DWORD dwStyle = m_pTabCtrl->GetStyle();
  217. m_pTabCtrl->GetClientRect(&rcChild);
  219. CRect rcTab;
  220. m_pTabCtrl->GetItemRect(nCurSel, &rcTab);
  221. rcTab.InflateRect(1, 1);
  223. int cy = rcTab.Height() * m_pTabCtrl->GetRowCount();
  224. int cx = rcTab.Width () * m_pTabCtrl->GetRowCount();
  226. // vertical tabs
  227. if (dwStyle & TCS_VERTICAL)
  228. {
  229. // Right
  230. if (dwStyle & TCS_RIGHT)
  231. {
  232. rcChild.top += TABVIEW_BORDER;
  233. rcChild.left += TABVIEW_BORDER;
  234. rcChild.right -= TABVIEW_BORDER + cx;
  235. rcChild.bottom -= TABVIEW_BORDER;
  236. }
  238. // Left
  239. else
  240. {
  241. rcChild.top += TABVIEW_BORDER;
  242. rcChild.left += TABVIEW_BORDER + cx;
  243. rcChild.right -= TABVIEW_BORDER;
  244. rcChild.bottom -= TABVIEW_BORDER;
  245. }
  246. }
  248. // horizontal tabs
  249. else
  250. {
  251. // Bottom
  252. if (dwStyle & TCS_BOTTOM)
  253. {
  254. rcChild.top += TABVIEW_BORDER;
  255. rcChild.left += TABVIEW_BORDER;
  256. rcChild.right -= TABVIEW_BORDER;
  257. rcChild.bottom -= TABVIEW_BORDER + cy;
  258. }
  260. // Top
  261. else
  262. {
  263. rcChild.top += TABVIEW_BORDER + cy;
  264. rcChild.left += TABVIEW_BORDER;
  265. rcChild.right -= TABVIEW_BORDER;
  266. rcChild.bottom -= TABVIEW_BORDER;
  267. }
  268. }
  269. }
  271. /////////////////////////////////////////////////////////////////////////////
  272. // CXTTabExBase
  274. CXTTabExBase::CXTTabExBase()
  275. : m_bInitialUpdate(FALSE)
  276. , m_pParentWnd(NULL)
  277. , m_pParentFrame(NULL)
  278. , m_popupMenuID(0)
  279. , m_nPos(0)
  280. , m_pLastActiveView(NULL)
  281. , m_nOldIndex(-1)
  282. {
  283. m_bBoldFont = false;
  285. // force VC++ to generate the following template functions:
  286. if (GetAutoCondense()) // should always be false!
  287. {
  288. // this block will never be executed, but the compiler can't know that
  289. SetAutoCondense(FALSE);
  290. CXTTabBase::OnPaint();
  291. CreateTabView(NULL, NULL, NULL);
  292. }
  293. }
  295. CXTTabExBase::~CXTTabExBase()
  296. {
  297. }
  299. void CXTTabExBase::OnThemeChanged()
  300. {
  301. POSITION pos;
  302. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  303. {
  304. CXTTcbItem* pMember = m_tcbItems.GetAt(pos);
  305. GetTheme()->AdjustBorders(this, pMember);
  306. }
  307. }
  309. bool CXTTabExBase::Init()
  310. {
  311. if (!CXTTabBase::Init())
  312. return false;
  314. if (m_bInitialUpdate)
  315. {
  316. // fire off initial updates
  317. // NB: this works only if WM_INITIALUPDATE has not been sent to us
  318. //     since its handler invalidates the signature
  319. m_pTabCtrl->SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);
  320. }
  322. // Set the font for the tab control.
  323. InitializeFont();
  325. // Get the pointer to the parent window.
  326. m_pParentWnd = m_pTabCtrl->GetParent();
  327. ASSERT_VALID(m_pParentWnd);
  329. // Get the pointer to the parent frame window.
  330. m_pParentFrame = m_pTabCtrl->GetParentFrame();
  331. if (::IsWindow(m_pParentFrame->GetSafeHwnd()))
  332. {
  333. // If floating, get parent frame of the floating frame window.
  334. if (m_pParentFrame->IsKindOf(RUNTIME_CLASS(CMiniDockFrameWnd)))
  335. {
  336. m_pParentFrame = m_pParentFrame->GetParentFrame();
  337. }
  338. }
  340. // Resize all views.
  341. RecalcLayout();
  343. if (m_bAutoCondensing)
  344. {
  345. Condense();
  346. }
  348. // make sure children are clipped.
  349. m_pTabCtrl->ModifyStyle(NULL, WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
  351. return true;
  352. }
  354. BOOL CXTTabExBase::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
  355. {
  356. if (nCode < 1)
  357. {
  358. CWnd* pView = GetActiveView();
  359. if (pView && ::IsWindow(pView->m_hWnd))
  360. {
  361. if (pView->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
  362. return TRUE;
  363. }
  364. }
  366. return FALSE;
  367. }
  369. BOOL CXTTabExBase::PreTranslateMessage(MSG* pMsg)
  370. {
  371. if (pMsg->message == WM_KEYDOWN)
  372. {
  373. bool bShift = (::GetKeyState(VK_SHIFT) < 0);
  374. bool bCtrl = (::GetKeyState(VK_CONTROL) < 0);
  376. if (bCtrl && (pMsg->wParam == VK_TAB) || (pMsg->wParam == VK_F6))
  377. {
  378. if (bShift)
  379. {
  380. PrevView();
  381. m_pTabCtrl->SetFocus();
  382. }
  383. else
  384. {
  385. NextView();
  386. m_pTabCtrl->SetFocus();
  387. }
  389. return TRUE;
  390. }
  391. }
  393. return FALSE; // Allow messages to be passed to base class
  394. }
  396. void CXTTabExBase::OnRButtonDown(UINT /*nFlags*/, CPoint point)
  397. {
  398. if (m_popupMenuID)
  399. {
  400. CPoint pt = point;
  401. m_pTabCtrl->ClientToScreen(&pt);
  403. CMenu menu;
  404. VERIFY(menu.LoadMenu(m_popupMenuID));
  406. CMenu* pPopup = menu.GetSubMenu(m_nPos);
  407. ASSERT(pPopup != NULL);
  408. if (!pPopup)
  409. return;
  411. pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y,
  412. m_pParentFrame);
  413. }
  414. }
  416. void CXTTabExBase::OnDestroy()
  417. {
  418. // Cleanup
  419. RemoveAllTabs();
  420. }
  422. void CXTTabExBase::EnableRedraw(BOOL bRedraw)
  423. {
  424. m_pTabCtrl->SetRedraw(bRedraw);
  426. if (bRedraw)
  427. {
  428. m_pTabCtrl->Invalidate();
  429. m_pTabCtrl->UpdateWindow();
  430. }
  431. }
  433. BOOL CXTTabExBase::OnSelchange(NMHDR* pNMHDR, LRESULT* pResult)
  434. {
  435. *pResult = 0;
  437. // This is here for backward compatibility, TCN_XT_SELCHANGE
  438. // message has been deprecated, please use TCN_SELCHANGE instead.
  439. CWnd* pOwner = m_pTabCtrl->GetOwner();
  440. if (::IsWindow(pOwner->GetSafeHwnd()))
  441. {
  442. *pResult = pOwner->SendMessage(TCN_XT_SELCHANGE,
  443. pNMHDR->idFrom, (LPARAM)m_pTabCtrl);
  444. }
  446. if (*pResult == 0)
  447. {
  448. OnSelChange();
  449. }
  451. return FALSE;
  452. }
  454. void CXTTabExBase::OnSelChange()
  455. {
  456. // Get the index to the newly selected tab.
  457. int nIndex = m_pTabCtrl->GetCurSel();
  458. if (nIndex == -1)
  459. return;
  461. // Get a pointer to the selected view.
  462. if (m_nOldIndex != -1)
  463. {
  464. CWnd* pOldView = GetView(m_nOldIndex);
  465. if (pOldView != NULL)
  466. {
  467. pOldView->ShowWindow(SW_HIDE);
  468. pOldView->EnableWindow(FALSE);
  470. if (m_pParentFrame && pOldView == m_pParentFrame->GetActiveView())
  471. {
  472. if (m_pLastActiveView && ::IsWindow(m_pLastActiveView->m_hWnd))
  473. {
  474. m_pParentFrame->SetActiveView(m_pLastActiveView);
  475. }
  476. else
  477. {
  478. m_pParentFrame->SetActiveView(NULL, FALSE);
  479. m_pLastActiveView = NULL;
  480. }
  481. }
  482. }
  483. }
  485. // Get a pointer to the selected view.
  486. CWnd* pView = GetView(nIndex);
  487. if (pView != NULL)
  488. {
  489. // If this is a CView object then set the active view
  490. // the parent frame.
  491. if (pView->IsKindOf(RUNTIME_CLASS(CView)))
  492. {
  493. if (m_pParentFrame && m_pParentFrame->IsChild(pView))
  494. {
  495. // Save a pointer to the view if it is not a child of the
  496. // tab control, we will use this rather than setting the view
  497. // to NULL for the frame window.
  498. CView* pActiveView = m_pParentFrame->GetActiveView();
  499. if (pActiveView && pActiveView->GetParent() != m_pTabCtrl)
  500. {
  501. m_pLastActiveView = pActiveView;
  502. }
  503. m_pParentFrame->SetActiveView((CView*)pView);
  504. }
  505. }
  507. ActivateView(pView);
  508. }
  509. }
  511. BOOL CXTTabExBase::OnSelchanging(NMHDR* pNMHDR, LRESULT* pResult)
  512. {
  513. *pResult = 0;
  515. // This is here for backward compatibility, TCN_XT_SELCHANGING
  516. // message has been deprecated, please use TCN_SELCHANGING instead.
  517. CWnd* pOwner = m_pTabCtrl->GetOwner();
  518. if (::IsWindow(pOwner->GetSafeHwnd()))
  519. {
  520. *pResult = pOwner->SendMessage(TCN_XT_SELCHANGING,
  521. pNMHDR->idFrom, (LPARAM)m_pTabCtrl);
  522. }
  524. if (*pResult == 0)
  525. {
  526. OnSelChanging();
  527. }
  529. return FALSE;
  530. }
  532. void CXTTabExBase::OnSelChanging()
  533. {
  534. // Get the index to the selected tab, we will
  535. // need this later to hide old view.
  536. m_nOldIndex = m_pTabCtrl->GetCurSel();
  537. }
  539. void CXTTabExBase::OnPreWindowPosChanged(WINDOWPOS FAR* lpwndpos)
  540. {
  541. if (lpwndpos->flags & SWP_HIDEWINDOW)
  542. {
  543. POSITION pos;
  544. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  545. {
  546. CWnd* pView = m_tcbItems.GetAt(pos)->pWnd;
  547. ASSERT_VALID(pView);
  549. if (m_pParentFrame && m_pParentFrame->GetActiveView() == pView)
  550. {
  551. // To avoid main window freezing, we must deactivate the view,
  552. // because it's not visible now.
  554. if (m_pLastActiveView && ::IsWindow(m_pLastActiveView->m_hWnd))
  555. {
  556. m_pParentFrame->SetActiveView(m_pLastActiveView);
  557. }
  558. else
  559. {
  560. m_pParentFrame->SetActiveView(NULL, FALSE);
  561. m_pLastActiveView = NULL;
  562. }
  563. }
  564. }
  565. }
  566. else
  567. {
  568. // resize all child views.
  569. RecalcLayout();
  570. }
  571. }
  573. void CXTTabExBase::OnPostWindowPosChanged()
  574. {
  575. if (m_bAutoCondensing)
  576. {
  577. Condense();
  578. }
  579. }
  581. BOOL CXTTabExBase::ModifyTabStyle(DWORD dwRemove, DWORD dwAdd, UINT nFlags)
  582. {
  583. if (!m_pTabCtrl->ModifyStyle(dwRemove, dwAdd, nFlags))
  584. return FALSE;
  586. // Set the font for the tab control.
  587. InitializeFont();
  589. return TRUE;
  590. }
  592. /////////////////////////////////////////////////////////////////////////////
  593. // CXTTabExBase tooltip related functions
  595. #if (_MSC_VER <= 1100) // Using Visual C++ 5.0
  597. CToolTipCtrl* CXTTabExBase::GetTips()
  598. {
  599. return m_pTabCtrl->GetTooltips();
  600. }
  602. void CXTTabExBase::SetTips(CToolTipCtrl* pWndTip)
  603. {
  604. m_pTabCtrl->SetTooltips(pWndTip);
  605. }
  607. #else
  609. CToolTipCtrl* CXTTabExBase::GetTips()
  610. {
  611. return m_pTabCtrl->GetToolTips();
  612. }
  614. void CXTTabExBase::SetTips(CToolTipCtrl* pWndTip)
  615. {
  616. m_pTabCtrl->SetToolTips(pWndTip);
  617. }
  619. #endif//#if (_MSC_VER <= 1100)
  621. void CXTTabExBase::AddToolTip(UINT nIDTab, LPCTSTR lpszText)
  622. {
  623. // Get the tool tips for the tab control.
  624. CToolTipCtrl* pToolTips = GetTips();
  626. if (pToolTips != NULL)
  627. {
  628. // Add the tool tip.
  629. if (nIDTab == 0)
  630. {
  631. pToolTips->AddTool(m_pTabCtrl, lpszText, NULL, nIDTab);
  632. }
  633. else
  634. {
  635. pToolTips->AddTool(m_pTabCtrl, lpszText, CRect(0, 0, 0, 0), nIDTab);
  636. }
  637. }
  638. }
  640. void CXTTabExBase::UpdateToolTip(int nIDTab, LPCTSTR lpszText)
  641. {
  642. ASSERT_VALID(m_pTabCtrl);
  643. ASSERT((nIDTab >= 0) && (m_pTabCtrl->GetItemCount() > nIDTab));
  645. // Find the view we want to change the tooltip for and
  646. // reset its tooltip text
  647. POSITION pos = m_tcbItems.FindIndex(nIDTab);
  648. if (pos != NULL)
  649. {
  650. // Get the private data for the view
  651. CXTTcbItem *pMember = m_tcbItems.GetAt(pos);
  652. ASSERT(pMember);
  653. if (!pMember)
  654. return;
  656. // Reset the tooltip text to the new value
  657. pMember->szToolTipLabel = lpszText;
  659. // Get the tool tips for the tab control.
  660. CToolTipCtrl* pToolTips = GetTips();
  662. if (pToolTips != NULL)
  663. {
  664. // Update the tooltip for the view
  665. pToolTips->UpdateTipText(pMember->szToolTipLabel,
  666. m_pTabCtrl, pMember->uiToolTipId);
  667. }
  668. }
  669. }
  671. void CXTTabExBase::UpdateToolTip(CRuntimeClass* pViewClass, LPCTSTR lpszText)
  672. {
  673. ASSERT_VALID(m_pTabCtrl);
  674. ASSERT(pViewClass != NULL);
  675. if (!pViewClass)
  676. return;
  677. ASSERT(pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  678. ASSERT(AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  680. int nIndex = 0;
  681. POSITION pos;
  682. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  683. {
  684. // Get the private data for the view
  685. CXTTcbItem *pMember = m_tcbItems.GetAt(pos);
  686. ASSERT(pMember);
  687. if (!pMember)
  688. continue;
  690. if (pMember->pWnd->IsKindOf(pViewClass))
  691. {
  692. UpdateToolTip(nIndex, lpszText);
  693. return;
  694. }
  695. nIndex++;
  696. }
  697. }
  699. void CXTTabExBase::ResetToolTips()
  700. {
  701. // Get the tool tips for the tab control.
  702. CToolTipCtrl* pToolTips = GetTips();
  704. if (pToolTips != NULL)
  705. {
  706. int nIndex = 0;
  708. POSITION pos;
  709. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  710. {
  711. // Get the next item in the list.
  712. CXTTcbItem* pMember = m_tcbItems.GetAt(pos);
  714. // Update the tooltip for the view
  715. pMember->uiToolTipId = nIndex;
  717. pToolTips->UpdateTipText(pMember->szToolTipLabel,
  718. m_pTabCtrl, nIndex);
  720. ++nIndex;
  721. }
  722. }
  723. }
  725. BOOL CXTTabExBase::EnableToolTipsEx(BOOL bEnable)
  726. {
  727. // Get the tool tips for the tab control.
  728. CToolTipCtrl* pToolTips = GetTips();
  730. if (pToolTips != NULL)
  731. {
  732. pToolTips->Activate(bEnable);
  733. return TRUE;
  734. }
  736. return FALSE;
  737. }
  739. /////////////////////////////////////////////////////////////////////////////
  740. // CXTTabExBase tab view methods.
  742. CWnd* CXTTabExBase::CreateTabView(CRuntimeClass* pViewClass, CDocument* pDocument, CCreateContext* pContext)
  743. {
  744. if (!pContext && !pViewClass)
  745. return NULL;
  747. ASSERT_VALID(m_pTabCtrl);
  748. ASSERT(pContext || pViewClass != NULL);
  749. ASSERT(pContext || pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  750. ASSERT(pContext || AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  753. CCreateContext contextT;
  754. if (pContext == NULL)
  755. {
  756. // if no context specified, generate one from the currently selected
  757. // client if possible.
  758. contextT.m_pCurrentDoc = pDocument;
  759. contextT.m_pNewViewClass = pViewClass;
  760. contextT.m_pLastView = NULL;
  761. contextT.m_pCurrentFrame = NULL;
  762. contextT.m_pNewDocTemplate = NULL;
  764. if (pDocument)
  765. {
  766. contextT.m_pNewDocTemplate = pDocument->GetDocTemplate();
  767. }
  769. pContext = &contextT;
  770. }
  772. if (!pContext->m_pNewViewClass)
  773. return NULL;
  775. CWnd* pWnd = NULL;
  776. TRY
  777. {
  778. pWnd = (CWnd*)pContext->m_pNewViewClass->CreateObject();
  779. if (pWnd == NULL)
  780. {
  781. AfxThrowMemoryException();
  782. }
  783. }
  784. CATCH_ALL(e)
  785. {
  786. TRACE0("Out of memory creating a view.n");
  787. // Note: DELETE_EXCEPTION(e) not required
  788. return NULL;
  789. }
  790. END_CATCH_ALL
  792. ASSERT_KINDOF(CWnd, pWnd);
  793. if (!pWnd)
  794. return NULL;
  795. ASSERT(pWnd->m_hWnd == NULL); // not yet created.
  797. DWORD dwStyle = AFX_WS_DEFAULT_VIEW;
  799. if (GetSafeTheme()->GetTheme() != xtThemeDefault)
  800. {
  801. dwStyle &= ~WS_BORDER;
  802. }
  804. int nTab = (int)m_tcbItems.GetCount();
  806. // Create with the right size (wrong position)
  807. CRect rect(0, 0, 0, 0);
  808. if (!pWnd->Create(NULL, NULL, dwStyle,
  809. rect, m_pTabCtrl, (AFX_IDW_PANE_FIRST + nTab), pContext))
  810. {
  811. TRACE0("Warning: couldn't create client tab for view.n");
  812. // pWnd will be cleaned up by PostNcDestroy
  813. return NULL;
  814. }
  815. if (pWnd->m_hWnd == NULL)
  816. return NULL;
  818. ASSERT((int)_AfxGetDlgCtrlID(pWnd->m_hWnd) == (AFX_IDW_PANE_FIRST + nTab));
  820. // send initial notification message for the window just created
  821. // only if our initialization has been completed
  822. if (m_bInitialUpdate)
  823. {
  824. pWnd->SendMessage(WM_INITIALUPDATE);
  825. }
  827. pWnd->SetOwner(m_pParentWnd);
  828. return pWnd;
  829. }
  831. BOOL CXTTabExBase::AddView(LPCTSTR lpszLabel, CRuntimeClass* pViewClass, CDocument* pDoc/*= NULL*/,
  832. CCreateContext *pContext/*= NULL*/, int iIndex/*= -1*/, int iIconIndex/*= -1*/)
  833. {
  834. if (!pContext && !pViewClass)
  835. return NULL;
  837. ASSERT_VALID(m_pTabCtrl);
  838. ASSERT(pContext || pViewClass);
  839. ASSERT(pContext || pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  840. ASSERT(pContext || AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  842. // Create the view to be associate with tab.
  843. CWnd* pWnd = CreateTabView(pViewClass, pDoc, pContext);
  844. if (pWnd == NULL) // tabs can be a CWnd, but are usually CViews
  845. return FALSE;
  847. return AddControl(lpszLabel, (CView *)pWnd, iIndex, iIconIndex);
  848. }
  850. BOOL CXTTabExBase::AddView(LPCTSTR lpszLabel, CView* pView, int iIndex/*= -1*/, int iIconIndex/*= -1*/)
  851. {
  852. ASSERT(pView != NULL);
  853. if (!pView)
  854. return FALSE;
  856. ASSERT(pView->GetRuntimeClass()->IsDerivedFrom(RUNTIME_CLASS(CView)));
  857. return AddControl(lpszLabel, pView, iIndex, iIconIndex);
  858. }
  860. BOOL CXTTabExBase::AddControl(LPCTSTR lpszLabel, CWnd* pWnd, int iIndex/*= -1*/, int iIconIndex/*= -1*/)
  861. {
  862. ASSERT_VALID(m_pTabCtrl);
  863. ASSERT_VALID(pWnd);
  864. ASSERT(pWnd != NULL);
  865. ASSERT(lpszLabel != NULL);
  866. ASSERT(iIndex >= -1);
  867. ASSERT(iIndex <= m_pTabCtrl->GetItemCount());
  869. if (!pWnd)
  870. return FALSE;
  872. pWnd->SetParent(m_pTabCtrl);
  874. // Allocate a new CXTTcbItem object.
  875. CXTTcbItem* pMember = new CXTTcbItem;
  877. if (pMember == NULL)
  878. return FALSE;
  880. pMember->pWnd = pWnd;
  881. pMember->szTabLabel = lpszLabel;
  882. pMember->szToolTipLabel = lpszLabel;
  883. pMember->uiToolTipId = m_pTabCtrl->GetItemCount();
  884. pMember->dwStyle = ::GetWindowLong(pWnd->GetSafeHwnd(), GWL_STYLE);
  885. pMember->dwExStyle = ::GetWindowLong(pWnd->GetSafeHwnd(), GWL_EXSTYLE);
  887. // If no index was specified add the view tab
  888. // to the end.
  889. if (iIndex == -1)
  890. {
  891. iIndex = (int)m_tcbItems.GetCount();
  892. }
  894. // Add the new CXTTcbItem to the tab item list.
  895. const POSITION pos = m_tcbItems.FindIndex(iIndex);
  896. if (pos != NULL)
  897. {
  898. m_tcbItems.InsertBefore(pos, pMember);
  899. }
  900. else
  901. {
  902. ASSERT(iIndex == m_pTabCtrl->GetItemCount());
  903. m_tcbItems.AddTail(pMember);
  904. }
  906. // Insert the new tab item.
  907. TC_ITEM tci;
  908. tci.mask = TCIF_TEXT | TCIF_IMAGE;
  909. tci.pszText = (LPTSTR)lpszLabel;
  911. if (iIconIndex != -1)
  912. {
  913. tci.iImage = iIconIndex;
  914. }
  915. else
  916. {
  917. tci.iImage = iIndex;
  918. }
  920. // set window borders based on current theme.
  921. GetTheme()->AdjustBorders(this, pMember);
  922. m_pTabCtrl->InsertItem(iIndex, &tci);
  924. // Create the ToolTip for the tab.
  925. AddToolTip(pMember->uiToolTipId, lpszLabel);
  927. // Since the tool tip count has changed,
  928. // re-initialize the tooltips.
  929. ResetToolTips();
  931. // hide/show views after insertion
  932. SetActiveView(iIndex);
  934. return TRUE;
  935. }
  937. BOOL CXTTabExBase::UpdateTabLabel(int iTab, CXTTcbItem* pMember, LPCTSTR lpszLabel)
  938. {
  939. // Text length cannot be longer than 255 characters.
  940. ASSERT(_tcslen(lpszLabel) < 255);
  942. CString strLabel = lpszLabel;
  943. if (strLabel.GetLength() > 255)
  944. {
  945. strLabel = strLabel.Left(255);
  946. }
  948. // if the string is empty return FALSE.
  949. else if (strLabel.IsEmpty())
  950. {
  951. return FALSE;
  952. }
  954. // if CXTTcbItem pointer is NULL, return FALSE.
  955. if (pMember == NULL)
  956. return FALSE;
  958. TCHAR szText[256];
  960. TC_ITEM tci;
  961. tci.mask = TCIF_TEXT;
  962. tci.cchTextMax = _countof(szText);
  963. tci.pszText = szText;
  965. // get the tab control item and update the text.
  966. m_pTabCtrl->GetItem(iTab, &tci);
  967. STRCPY_S(szText, 256, strLabel);
  968. m_pTabCtrl->SetItem(iTab, &tci);
  970. // Get the tool tips for the tab control and update
  971. // the tip text.
  972. CToolTipCtrl* pToolTips = GetTips();
  973. if (pToolTips == NULL)
  974. return FALSE;
  976. pToolTips->UpdateTipText(strLabel, m_pTabCtrl, iTab);
  978. // update the CXTTcbItem item label and tip text.
  979. pMember->szTabLabel = strLabel;
  980. pMember->szToolTipLabel = strLabel;
  982. // update other information
  983. pMember->szCondensedLabel = strLabel;
  985. return TRUE;
  986. }
  988. BOOL CXTTabExBase::SetTabText(int iTab, LPCTSTR lpszLabel)
  989. {
  990. // Get the item at the specified index.
  991. POSITION pos = m_tcbItems.FindIndex (iTab);
  992. if (pos == NULL)
  993. return FALSE;
  995. return UpdateTabLabel (iTab, m_tcbItems.GetAt(pos), lpszLabel);
  996. }
  998. BOOL CXTTabExBase::SetTabText(CWnd* pView, LPCTSTR lpszLabel)
  999. {
  1000. int iTab = 0;
  1002. POSITION pos;
  1003. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  1004. {
  1005. // Get the next item in the list.
  1006. CXTTcbItem* pMember = m_tcbItems.GetAt(pos);
  1008. if (pView == pMember->pWnd)
  1009. return UpdateTabLabel (iTab, m_tcbItems.GetAt(pos), lpszLabel);
  1011. ++iTab;
  1012. }
  1014. return FALSE;
  1015. }
  1017. BOOL CXTTabExBase::SetTabText(CRuntimeClass* pViewClass, LPCTSTR lpszLabel)
  1018. {
  1019. int iTab = 0;
  1021. POSITION pos;
  1022. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  1023. {
  1024. // Get the next item in the list.
  1025. CXTTcbItem* pMember = m_tcbItems.GetAt(pos);
  1027. if (pMember->pWnd->IsKindOf(pViewClass))
  1028. return UpdateTabLabel (iTab, m_tcbItems.GetAt(pos), lpszLabel);
  1030. ++iTab;
  1031. }
  1033. return FALSE;
  1034. }
  1036. CWnd* CXTTabExBase::NextView()
  1037. {
  1038. ASSERT_VALID(m_pTabCtrl);
  1039. ASSERT(m_tcbItems.GetCount() > 0);
  1041. // get the current selection and increment by 1.
  1042. int iIndex = m_pTabCtrl->GetCurSel();
  1043. iIndex++;
  1045. // if the new index is greater than or equal to
  1046. // the tab count, set the index to 0.
  1047. if (iIndex > m_pTabCtrl->GetItemCount()-1)
  1048. iIndex = 0;
  1050. // set the active view and return a pointer to
  1051. // the newly activated view.
  1052. SetActiveView(iIndex);
  1054. return GetActiveView();
  1055. }
  1057. CWnd* CXTTabExBase::PrevView()
  1058. {
  1059. ASSERT_VALID(m_pTabCtrl);
  1060. ASSERT(m_tcbItems.GetCount() > 0);
  1062. // get the current selection and increment by 1.
  1063. int iIndex = m_pTabCtrl->GetCurSel();
  1064. iIndex--;
  1066. // if the new index is greater than or equal to
  1067. // the tab count, set the index to 0.
  1068. if (iIndex < 0)
  1069. iIndex = m_pTabCtrl->GetItemCount()-1;
  1071. // set the active view and return a pointer to
  1072. // the newly activated view.
  1073. SetActiveView(iIndex);
  1076. return GetActiveView();
  1077. }
  1079. CWnd* CXTTabExBase::GetView(int nView)
  1080. {
  1081. ASSERT_VALID(m_pTabCtrl);
  1083. if (nView > -1 && nView < m_pTabCtrl->GetItemCount())
  1084. {
  1085. POSITION pos = m_tcbItems.FindIndex(nView);
  1086. if (pos != NULL)
  1087. {
  1088. CWnd* pWnd = m_tcbItems.GetAt(pos)->pWnd;
  1089. ASSERT_VALID(pWnd);
  1091. if (pWnd && ::IsWindow(pWnd->m_hWnd))
  1092. {
  1093. return pWnd;
  1094. }
  1095. }
  1096. }
  1098. return NULL;
  1099. }
  1101. CWnd* CXTTabExBase::GetView(CRuntimeClass* pViewClass)
  1102. {
  1103. ASSERT_VALID(m_pTabCtrl);
  1104. ASSERT(pViewClass != NULL);
  1105. if (!pViewClass)
  1106. return 0;
  1108. ASSERT(pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  1109. ASSERT(AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  1111. POSITION pos;
  1112. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  1113. {
  1114. CWnd* pWnd = m_tcbItems.GetAt(pos)->pWnd;
  1115. ASSERT_VALID(pWnd);
  1117. if (pWnd && ::IsWindow(pWnd->m_hWnd) && pWnd->IsKindOf(pViewClass))
  1118. {
  1119. return pWnd;
  1120. }
  1121. }
  1123. return NULL;
  1124. }
  1126. void CXTTabExBase::ActivateView(CWnd* pNewView)
  1127. {
  1128. ASSERT_VALID(pNewView); // must be valid
  1130. // Hide all views.
  1131. int iIndex;
  1132. for (iIndex = 0; iIndex < m_tcbItems.GetCount(); ++iIndex)
  1133. {
  1134. POSITION pos = m_tcbItems.FindIndex(iIndex);
  1135. if (pos != NULL)
  1136. {
  1137. CXTTcbItem* pTCBItem = m_tcbItems.GetAt(pos);
  1138. ASSERT(pTCBItem != NULL);
  1140. if (pTCBItem && pTCBItem->pWnd)
  1141. {
  1142. pTCBItem->pWnd->ShowWindow(SW_HIDE);
  1143. pTCBItem->pWnd->EnableWindow(FALSE);
  1144. }
  1145. }
  1146. }
  1148. ////////// ULF 2003-08-07
  1149. if (m_pParentFrame && m_pParentFrame->IsChild(pNewView))
  1150. {
  1151. CView* pActiveView = m_pParentFrame->GetActiveView();
  1152. if (pActiveView && pActiveView->GetParent() == m_pTabCtrl)
  1153. {
  1154. if (pActiveView != pNewView)
  1155. {
  1156. // Make the frame window aware of the active view (for message routing)
  1157. m_pParentFrame->SetActiveView(DYNAMIC_DOWNCAST(CView, pNewView));
  1158. }
  1159. }
  1160. }
  1161. /////////
  1163. // Show and enable the window.
  1164. pNewView->ShowWindow(SW_SHOW);
  1165. pNewView->EnableWindow(TRUE);
  1166. pNewView->SetFocus();
  1168. // Resize the window.
  1169. ResizeTabView(pNewView);
  1170. }
  1172. void CXTTabExBase::SetActiveView(CRuntimeClass* pViewClass)
  1173. {
  1174. ASSERT_VALID(m_pTabCtrl);
  1175. ASSERT(pViewClass != NULL);
  1176. if (!pViewClass)
  1177. return;
  1178. ASSERT(pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  1179. ASSERT(AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  1181. // Walk through the tabs
  1182. int iIndex;
  1183. for (iIndex = 0; iIndex < m_tcbItems.GetCount(); ++iIndex)
  1184. {
  1185. POSITION pos = m_tcbItems.FindIndex(iIndex);
  1186. if (pos != NULL)
  1187. {
  1188. CXTTcbItem* pTCBItem = m_tcbItems.GetAt(pos);
  1189. ASSERT(pTCBItem != NULL);
  1191. if (pTCBItem && pTCBItem->pWnd->IsKindOf(pViewClass))
  1192. {
  1193. // Select new the tab
  1194. m_pTabCtrl->SetCurSel(iIndex);
  1196. // now active the view and give it focus.
  1197. ActivateView(pTCBItem->pWnd);
  1198. break;
  1199. }
  1200. }
  1201. }
  1202. }
  1204. void CXTTabExBase::SetActiveView(CWnd* pTabView)
  1205. {
  1206. ASSERT_VALID(m_pTabCtrl);
  1207. ASSERT(pTabView != NULL);
  1209. // Walk through the tabs
  1210. int iIndex;
  1211. for (iIndex = 0; iIndex < m_tcbItems.GetCount(); ++iIndex)
  1212. {
  1213. POSITION pos = m_tcbItems.FindIndex(iIndex);
  1214. if (pos != NULL)
  1215. {
  1216. CXTTcbItem* pTCBItem = m_tcbItems.GetAt(pos);
  1217. ASSERT(pTCBItem != NULL);
  1219. // Does the tab view match the requested view ?
  1220. if (pTCBItem && pTCBItem->pWnd == pTabView)
  1221. {
  1222. // Select new the tab
  1223. m_pTabCtrl->SetCurSel(iIndex);
  1225. // now active the view and give it focus.
  1226. ActivateView(pTCBItem->pWnd);
  1227. break;
  1228. }
  1229. }
  1230. }
  1231. }
  1233. void CXTTabExBase::SetActiveView(int nActiveTab)
  1234. {
  1235. ASSERT_VALID(m_pTabCtrl);
  1236. ASSERT(nActiveTab >= 0);
  1238. // Find the item at the specified index.
  1239. POSITION pos = m_tcbItems.FindIndex(nActiveTab);
  1240. if (pos != NULL)
  1241. {
  1242. CXTTcbItem* pTCBItem = m_tcbItems.GetAt(pos);
  1243. ASSERT(pTCBItem != NULL);
  1245. if (pTCBItem && pTCBItem->pWnd != NULL)
  1246. {
  1247. ASSERT_VALID(pTCBItem->pWnd);
  1249. // Select new the tab
  1250. m_pTabCtrl->SetCurSel(nActiveTab);
  1252. // now active the view and give it focus.
  1253. ActivateView(pTCBItem->pWnd);
  1254. }
  1255. }
  1256. }
  1258. void CXTTabExBase::RemoveListItem(POSITION pos, BOOL bDestroyWnd/*= TRUE*/)
  1259. {
  1260. // invalid position
  1261. if (pos == NULL)
  1262. return;
  1264. // remove the page from internal list
  1265. CXTTcbItem *pMember = m_tcbItems.GetAt(pos);
  1267. // if this item is invalid, return.
  1268. if (!pMember)
  1269. return;
  1271. if (pMember->pWnd && ::IsWindow(pMember->pWnd->m_hWnd))
  1272. {
  1273. // And delete the member window, freeing our stored
  1274. // values relating to it
  1275. if (bDestroyWnd)
  1276. {
  1277. pMember->pWnd->DestroyWindow();
  1278. pMember->pWnd = NULL;
  1279. }
  1280. else
  1281. {
  1282. pMember->pWnd->ShowWindow(SW_HIDE);
  1283. }
  1284. }
  1286. // Remove from list and free memory.
  1287. m_tcbItems.RemoveAt(pos);
  1288. SAFE_DELETE(pMember);
  1289. }
  1291. void CXTTabExBase::DeleteView(int nView, BOOL bDestroyWnd/*= TRUE*/)
  1292. {
  1293. ASSERT_VALID(m_pTabCtrl);
  1294. ASSERT((nView >= 0) && (m_pTabCtrl->GetItemCount() > nView));
  1296. // Now find the view we want to delete and remove it
  1297. POSITION pos = m_tcbItems.FindIndex(nView);
  1298. if (pos != NULL)
  1299. {
  1300. CWnd* pView = m_tcbItems.GetAt(pos)->pWnd;
  1302. // Ensure that we get no dangling pointers
  1303. if (m_pParentFrame && m_pParentFrame->GetActiveView() == pView)
  1304. {
  1305. if (m_pLastActiveView && ::IsWindow(m_pLastActiveView->m_hWnd))
  1306. {
  1307. m_pParentFrame->SetActiveView(m_pLastActiveView);
  1308. }
  1309. else
  1310. {
  1311. m_pParentFrame->SetActiveView(NULL, FALSE);
  1312. m_pLastActiveView = NULL;
  1313. }
  1314. }
  1316. // Remove item from list, and free memory.
  1317. RemoveListItem(pos, bDestroyWnd);
  1319. // Remove it from the tab control
  1320. m_pTabCtrl->DeleteItem(nView);
  1322. int nCount = m_pTabCtrl->GetItemCount();
  1324. if (nCount > 0)
  1325. {
  1326. // Finally, if we have just deleted the active view, reset the
  1327. // active tab to be the first view in the list
  1328. if (nView == 0)
  1329. {
  1330. SetActiveView(nView);
  1331. }
  1332. else if (nView >= nCount)
  1333. {
  1334. SetActiveView(nCount-1);
  1335. }
  1336. else
  1337. {
  1338. SetActiveView(nView-1);
  1339. }
  1341. // Reset the tooltips for the views we have left...
  1342. ResetToolTips();
  1343. }
  1344. }
  1345. }
  1347. void CXTTabExBase::DeleteView(CRuntimeClass* pViewClass, BOOL bDestroyWnd/*= TRUE*/)
  1348. {
  1349. ASSERT_VALID(m_pTabCtrl);
  1350. ASSERT(pViewClass != NULL);
  1351. if (!pViewClass)
  1352. return;
  1353. ASSERT(pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  1354. ASSERT(AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  1356. int nView = 0;
  1357. POSITION pos;
  1358. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  1359. {
  1360. CWnd* pView = m_tcbItems.GetAt(pos)->pWnd;
  1361. ASSERT_VALID(pView);
  1363. if (pView->IsKindOf(pViewClass))
  1364. {
  1365. DeleteView(nView, bDestroyWnd);
  1366. return;
  1367. }
  1368. nView++;
  1369. }
  1370. }
  1372. void CXTTabExBase::DeleteView(CWnd* pView, BOOL bDestroyWnd/*= TRUE*/)
  1373. {
  1374. ASSERT_VALID(m_pTabCtrl);
  1375. ASSERT(pView != NULL);
  1376. ASSERT(AfxIsValidAddress(pView, sizeof(CWnd), FALSE));
  1378. int nView = 0;
  1379. POSITION pos;
  1380. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  1381. {
  1382. if (m_tcbItems.GetAt(pos)->pWnd == pView)
  1383. {
  1384. DeleteView(nView, bDestroyWnd);
  1385. return;
  1386. }
  1387. nView++;
  1388. }
  1389. }
  1391. LPCTSTR CXTTabExBase::GetViewName(int nView)
  1392. {
  1393. ASSERT_VALID(m_pTabCtrl);
  1394. ASSERT((nView >= 0) && (m_pTabCtrl->GetItemCount() > nView));
  1396. if (nView != -1)
  1397. {
  1398. POSITION pos = m_tcbItems.FindIndex(nView);
  1399. if (pos != NULL)
  1400. {
  1401. return m_tcbItems.GetAt(pos)->szTabLabel;
  1402. }
  1403. }
  1405. return NULL;
  1406. }
  1408. LPCTSTR CXTTabExBase::GetViewName(CRuntimeClass* pViewClass)
  1409. {
  1410. ASSERT_VALID(m_pTabCtrl);
  1411. ASSERT(pViewClass != NULL);
  1412. if (!pViewClass)
  1413. return NULL;
  1414. ASSERT(pViewClass->IsDerivedFrom(RUNTIME_CLASS(CWnd)));
  1415. ASSERT(AfxIsValidAddress(pViewClass, sizeof(CRuntimeClass), FALSE));
  1417. POSITION pos;
  1418. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  1419. {
  1420. CXTTcbItem *pMember = m_tcbItems.GetAt(pos);
  1421. ASSERT(pMember);
  1423. if (pMember && pMember->pWnd->IsKindOf(pViewClass))
  1424. {
  1425. return (LPCTSTR)pMember->szTabLabel;
  1426. }
  1427. }
  1428. return NULL;
  1429. }
  1431. BOOL CXTTabExBase::IsChildView(CWnd* pWnd)
  1432. {
  1433. POSITION pos = m_tcbItems.GetHeadPosition();
  1434. while (pos)
  1435. {
  1436. CXTTcbItem *pItem = m_tcbItems.GetNext(pos);
  1437. if (pItem && pItem->pWnd == pWnd)
  1438. {
  1439. return TRUE;
  1440. }
  1441. }
  1443. return FALSE;
  1444. }
  1446. BOOL CXTTabExBase::RemoveAllTabs(BOOL bDestroyWnd/*= TRUE*/)
  1447. {
  1448. if (m_pParentFrame)
  1449. {
  1450. // If the parent frames active view belongs to
  1451. // us set the active view to NULL.
  1452. CView * pActiveView = m_pParentFrame->GetActiveView();
  1453. if (IsChildView(pActiveView))
  1454. {
  1455. if (m_pLastActiveView && ::IsWindow(m_pLastActiveView->m_hWnd) && !IsChildView(m_pLastActiveView))
  1456. {
  1457. m_pParentFrame->SetActiveView(m_pLastActiveView);
  1458. }
  1459. else
  1460. {
  1461. m_pParentFrame->SetActiveView(NULL, FALSE);
  1462. }
  1463. }
  1464. }
  1466. m_pLastActiveView = NULL;
  1467. m_nOldIndex = -1;
  1469. // Free memory and clear tab view list.
  1470. while (!m_tcbItems.IsEmpty())
  1471. {
  1472. POSITION pos = m_tcbItems.FindIndex(0);
  1473. if (pos != NULL)
  1474. {
  1475. RemoveListItem(pos, bDestroyWnd);
  1476. }
  1477. }
  1479. // Remove all tabs from control.
  1480. m_pTabCtrl->DeleteAllItems();
  1482. return TRUE;
  1483. }
  1485. int CXTTabExBase::GetTabFromPoint(CPoint point)
  1486. {
  1487. TCHITTESTINFO tch;
  1488. memset(&tch, 0, sizeof(TCHITTESTINFO));
  1490. if (point == CPoint(0, 0))
  1491. {
  1492. CPoint pt;
  1493. GetCursorPos(&pt);
  1494. m_pTabCtrl->ScreenToClient(&pt);
  1495. tch.pt = pt;
  1496. }
  1497. else
  1498. {
  1499. tch.pt = point;
  1500. }
  1502. return m_pTabCtrl->HitTest(&tch);
  1503. }
  1505. BOOL CXTTabExBase::Defer(HDWP& hDWP, CWnd* pView)
  1506. {
  1507. if (pView && ::IsWindow(pView->m_hWnd))
  1508. {
  1509. HWND hWnd = pView->m_hWnd;
  1511. CRect rcNewSize;
  1512. GetChildRect(rcNewSize);
  1514. CRect rcOldSize;
  1515. pView->GetWindowRect(&rcOldSize);
  1516. m_pTabCtrl->ScreenToClient(&rcOldSize);
  1518. if (rcNewSize != rcOldSize)
  1519. {
  1520. int x = (int) rcNewSize.left;
  1521. int y = (int) rcNewSize.top;
  1522. int cx = (int) rcNewSize.Width();
  1523. int cy = (int) rcNewSize.Height();
  1525. // Set positioning flags
  1526. UINT uFlags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER;
  1528. // if the x-y coordinates have not changed, there is no reason
  1529. // to move the dialog item.
  1530. if (rcNewSize.TopLeft() == rcOldSize.TopLeft())
  1531. uFlags |= SWP_NOMOVE;
  1533. // if the cx-cy size has not changed, there is no reason to
  1534. // size the dialog item.  If size has changed, don't
  1535. // copy bits of the client area (i.e. have them invalidated/redrawn)
  1536. if (rcNewSize.Size() == rcOldSize.Size())
  1537. uFlags |= SWP_NOSIZE;
  1538. else
  1539. uFlags |= SWP_NOCOPYBITS;
  1541. hDWP = ::DeferWindowPos(hDWP, hWnd, 0, x, y, cx, cy, uFlags);
  1542. if (hDWP == NULL)
  1543. {
  1544. TRACE(_T("DeferWindowPos failed for ID %in"), GetDlgCtrlID(hWnd));
  1545. return FALSE;
  1546. }
  1548. return TRUE;
  1549. }
  1550. }
  1552. return FALSE;
  1553. }
  1555. void CXTTabExBase::RecalcLayout()
  1556. {
  1557. HDWP hDWP = ::BeginDeferWindowPos((int)m_tcbItems.GetCount());
  1559. // Resize all views.
  1560. POSITION pos;
  1561. for (pos = m_tcbItems.GetHeadPosition(); pos; m_tcbItems.GetNext(pos))
  1562. {
  1563. CXTTcbItem* pTCBItem = m_tcbItems.GetAt(pos);
  1564. ASSERT(pTCBItem != NULL);
  1565. if (!pTCBItem)
  1566. continue;
  1568. CWnd* pWnd = pTCBItem->pWnd;
  1569. ASSERT_VALID(pWnd);
  1571. Defer(hDWP, pWnd);
  1572. }
  1574. ::EndDeferWindowPos(hDWP);
  1575. }
  1577. void CXTTabExBase::ResizeTabView(CWnd* pView)
  1578. {
  1579. if (pView && ::IsWindow(pView->m_hWnd))
  1580. {
  1581. CRect rcChild;
  1582. GetChildRect(rcChild);
  1583. pView->MoveWindow(rcChild);
  1584. }
  1585. }
  1587. void CXTTabExBase::InitializeFont()
  1588. {
  1589. HGDIOBJ hFont = XTAuxData().font.GetSafeHandle();
  1591. // if the tabs are vertical, use the vertical menu font.
  1592. if ((m_pTabCtrl->GetStyle() & TCS_VERTICAL) == TCS_VERTICAL)
  1593. hFont = XTAuxData().fontVert.GetSafeHandle();
  1595. if (hFont != NULL)
  1596. {
  1597. if (XTOSVersionInfo()->IsWin95())
  1598. m_pTabCtrl->PostMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
  1599. else
  1600. m_pTabCtrl->SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
  1601. }
  1602. }
  1604. void CXTTabExBase::SetAutoCondense(BOOL bEnable)
  1605. {
  1606. m_bAutoCondensing = bEnable;
  1607. Condense();
  1608. }
  1610. BOOL CXTTabExBase::GetAutoCondense()
  1611. {
  1612. return m_bAutoCondensing;
  1613. }
  1615. int CXTTabExBase::CalculateTabWidth(CDC* pDC, CString& sLabel, bool bHasIcon)
  1616. {
  1617. int len = pDC->GetTextExtent(sLabel).cx + 6 + 6;
  1618. if (sLabel.GetLength() == 1) ++len;
  1619. if (bHasIcon)
  1620. {
  1621. len += 16 + 6;
  1622. }
  1623. return len;
  1624. }
  1626. // used by tab condensation code
  1627. struct CXTTabExBase::ITEMANDWIDTH
  1628. {
  1629. CXTTcbItem*    pItem;
  1630. int             iWidth;
  1631. bool            bHasIcon;
  1632. bool            bAtMinLength;
  1633. int             iItemIndex;
  1634. CXTStringHelper sNewLabel;
  1635. };
  1637. void CXTTabExBase::Condense()
  1638. {
  1639. if (!m_pTabCtrl->m_hWnd || m_pTabCtrl->GetItemCount() == 0)
  1640. {
  1641. return;
  1642. }
  1644. // create a device context with the tab control's font (used for label
  1645. // widths calculations)
  1646. CFont *pFont = m_pTabCtrl->GetFont();
  1647. VERIFY(pFont != NULL);
  1648. CDC *pDC = m_pTabCtrl->GetDC();
  1649. CFont *pOldFont = pDC->SelectObject(pFont);
  1651. int iTotalWidth = 0;
  1652. CList <ITEMANDWIDTH, ITEMANDWIDTH&> lstItemsByWidth;
  1654. // the formula for iMinTabWidth is based on empirical data
  1655. TEXTMETRIC tm;
  1656. pDC->GetTextMetrics(&tm);
  1657. const int iMinTabWidth = tm.tmAveCharWidth * 6 + 12;
  1659. // calculate length of tab labels and fill our tracking list
  1660. POSITION p = m_tcbItems.GetHeadPosition();
  1661. ASSERT(p != NULL);  // there should be items
  1662. int idx = 0;
  1663. TCITEM tci;
  1664. tci.mask = TCIF_IMAGE;
  1665. while (p)
  1666. {
  1667. m_pTabCtrl->GetItem(idx, &tci);
  1668. ITEMANDWIDTH iaw;
  1669. iaw.bHasIcon = (tci.iImage >= 0);
  1670. iaw.pItem = m_tcbItems.GetNext(p);
  1671. iaw.iWidth = CalculateTabWidth(pDC, iaw.pItem->szTabLabel, iaw.bHasIcon);
  1672. iaw.sNewLabel = iaw.pItem->szTabLabel;
  1673. iaw.iItemIndex = idx;
  1674. iaw.bAtMinLength = FALSE;
  1675. ++idx;
  1676. lstItemsByWidth.AddTail(iaw);
  1677. iTotalWidth += iaw.iWidth;
  1678. }
  1680. const bool bVertical = (m_pTabCtrl->GetStyle() & TCS_VERTICAL) == TCS_VERTICAL;
  1681. const bool bMultiLine =
  1682. bVertical || ((m_pTabCtrl->GetStyle() & TCS_MULTILINE) == TCS_MULTILINE);
  1684. CRect rc;
  1685. m_pTabCtrl->GetClientRect(&rc);
  1686. const int client_width = bVertical ? rc.Height() : rc.Width();
  1687. POSITION p2;
  1689. if (client_width == 0)
  1690. {
  1691. pDC->SelectObject(pOldFont);
  1692. m_pTabCtrl->ReleaseDC(pDC);
  1693. return;
  1694. }
  1696. if (m_bAutoCondensing)
  1697. {
  1698. iTotalWidth += 4; // 4 pixels extra for the selected tab
  1699. if (bMultiLine) ++iTotalWidth;
  1701. // start condensing labels until the total width fits the client area,
  1702. // or until we can't condense any more
  1703. while (iTotalWidth > client_width)
  1704. {
  1705. // look for widest item
  1706. p = lstItemsByWidth.GetHeadPosition();
  1707. int iWidest = -1;
  1708. while (p)
  1709. {
  1710. const POSITION p3 = p;
  1711. ITEMANDWIDTH& iaw = lstItemsByWidth.GetNext(p);
  1712. if (iaw.iWidth > iWidest && !iaw.bAtMinLength)
  1713. {
  1714. iWidest = iaw.iWidth;
  1715. p2 = p3;
  1716. }
  1717. }
  1718. if (iWidest == -1)
  1719. {
  1720. break;
  1721. }
  1722. ITEMANDWIDTH& iaw = lstItemsByWidth.GetNext(p2);
  1723. const int iOldWidth = iaw.iWidth;
  1724. CXTStringHelper& label = iaw.sNewLabel;
  1726. // shorten name
  1727. if (label.Right(3) != _T("..."))
  1728. {
  1729. label += _T("...");
  1730. }
  1731. do
  1732. {
  1733. if (label.GetLength() == 3 || (iaw.iWidth <= iMinTabWidth))
  1734. {
  1735. iaw.bAtMinLength = true;
  1736. }
  1737. else
  1738. {
  1739. int iLen = label.GetLength();
  1740. if ((iLen > 0) && ((iLen-4) >= 0))
  1741. {
  1742. label.Delete((iLen-4), 1);
  1743. }
  1744. }
  1745. iaw.iWidth = CalculateTabWidth(pDC, label, iaw.bHasIcon);
  1746. }
  1747. while (!iaw.bAtMinLength && iaw.iWidth >= iOldWidth);
  1749. iTotalWidth -= (iOldWidth - iaw.iWidth);
  1750. }
  1751. }
  1753. // update actual tab labels based on new condensed labels
  1754. tci.mask = TCIF_TEXT;
  1755. p = lstItemsByWidth.GetHeadPosition();
  1756. while (p)
  1757. {
  1758. ITEMANDWIDTH& iaw = lstItemsByWidth.GetNext(p);
  1759. // only change if actually different
  1760. if (iaw.pItem->szCondensedLabel != iaw.sNewLabel)
  1761. {
  1762. iaw.pItem->szCondensedLabel = iaw.sNewLabel;
  1763. tci.pszText = (TCHAR*)(LPCTSTR)iaw.sNewLabel;
  1764. m_pTabCtrl->SetItem(iaw.iItemIndex, &tci);
  1765. }
  1766. }
  1768. pDC->SelectObject(pOldFont);
  1769. m_pTabCtrl->ReleaseDC(pDC);
  1770. }