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

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

对话框与窗口

开发平台：

Visual C++

XTExcelTabCtrl.cpp：源码内容
  1. // XTExcelTabCtrl.cpp : implementation of the CXTExcelTabCtrl class.
  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"
  22. #include "Resource.h"
  24. #include "Common/XTPResourceManager.h"
  25. #include "Common/XTPColorManager.h"
  26. #include "Common/XTPDrawHelpers.h"
  28. #include "XTGlobal.h"
  29. #include "XTExcelTabCtrl.h"
  31. #ifdef _DEBUG
  32. #define new DEBUG_NEW
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #endif
  37. static const int GRIPPER_WIDTH = 6;
  39. static const int BUTTON_COUNT = 4;
  41. #define XT_IDC_BTN_LEFT                 100
  42. #define XT_IDC_BTN_RIGHT                101
  43. #define XT_IDC_BTN_HOME                 102
  44. #define XT_IDC_BTN_END                  103
  46. /////////////////////////////////////////////////////////////////////////////
  47. // CXTExcelTabCtrlButtonState
  49. CXTExcelTabCtrlButtonState::CXTExcelTabCtrlButtonState()
  50. : m_rect(0, 0, 0, 0)
  51. , m_bPressed(false)
  52. , m_bEnabled(true)
  53. , m_bHilight(false)
  54. {
  55. m_iCommand = 0;
  56. }
  58. void CXTExcelTabCtrlButtonState::SetInfo(CRect rect, int iCommand, XTArrowIcon iconType)
  59. {
  60. m_rect = rect;
  61. m_iCommand = iCommand;
  62. m_IconType = iconType;
  63. }
  65. IMPLEMENT_THEME_HOST(CXTExcelTabCtrl)
  66. IMPLEMENT_THEME_REFRESH(CXTExcelTabCtrl, CWnd)
  68. /////////////////////////////////////////////////////////////////////////////
  69. // CXTExcelTabCtrl
  71. CXTExcelTabCtrl::CXTExcelTabCtrl()
  72. : CXTThemeManagerStyleHost(GetThemeFactoryClass())
  73. , m_iBtnLeft(-1)
  74. , m_iBtnRight(-1)
  75. , m_iBtnHome(-1)
  76. , m_iBtnEnd(-1)
  77. , m_bPainted(false)
  78. , m_iBtnHilight(-1)
  79. {
  80. m_dwStyle = NULL;
  81. m_nCurSel = -1;
  82. m_nOffset = 0;
  83. m_nClientWidth = 0;
  84. m_nClientHeight = 0;
  85. m_pNormFont = &XTAuxData().font;
  86. m_pBoldFont = &XTAuxData().fontBold;
  87. m_bManagingViews = false;
  88. m_rectGripper = CRect(0, 0, 0, 0);
  89. m_bTracking = false;
  90. m_bUserColors = false;
  91. m_pWndLastFocus = NULL;
  92. m_iGripperPosPerCent = 0;
  93. m_xGripperPos = -1;
  95. // Initialize the width and height for the left, right, home
  96. // and end buttons.
  97. m_cy = ::GetSystemMetrics(SM_CYHSCROLL);
  98. m_cx = ::GetSystemMetrics(SM_CXHSCROLL)-1;
  100. UpdateDefaultColors();
  102. // Create the icons used by the left, right, home and end buttons.
  103. CreateButtonIcons();
  104. }
  106. CXTExcelTabCtrl::~CXTExcelTabCtrl()
  107. {
  108. // Cleanup
  109. ClearAllItems();
  110. FreeButtonIcons();
  111. }
  113. IMPLEMENT_DYNAMIC(CXTExcelTabCtrl, CWnd)
  115. BEGIN_MESSAGE_MAP(CXTExcelTabCtrl, CWnd)
  116. //{{AFX_MSG_MAP(CXTExcelTabCtrl)
  117. ON_WM_CREATE()
  118. ON_WM_PAINT()
  119. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  120. ON_WM_ERASEBKGND()
  121. ON_BN_CLICKED(XT_IDC_BTN_LEFT, OnLeftArrow)
  122. ON_BN_CLICKED(XT_IDC_BTN_RIGHT, OnRightArrow)
  123. ON_BN_CLICKED(XT_IDC_BTN_HOME, OnHomeArrow)
  124. ON_BN_CLICKED(XT_IDC_BTN_END, OnEndArrow)
  125. ON_WM_SIZE()
  126. ON_WM_LBUTTONDOWN()
  127. ON_WM_MOUSEMOVE()
  128. ON_WM_SETCURSOR()
  129. ON_WM_LBUTTONUP()
  130. ON_WM_LBUTTONDBLCLK()
  131. ON_WM_HSCROLL()
  132. ON_WM_TIMER()
  133. //}}AFX_MSG_MAP
  134. END_MESSAGE_MAP()
  136. BOOL CXTExcelTabCtrl::Create(DWORD dwStyle, const CRect& rect, CWnd* pParentWnd, UINT nID)
  137. {
  138. ASSERT(pParentWnd != NULL); // must be valid.
  140. // Call the base class for creation.
  141. if (!CWnd::Create(NULL, NULL, dwStyle, rect, pParentWnd, nID))
  142. {
  143. TRACE0("Failed to create flat tab control.n");
  144. return FALSE;
  145. }
  147. return TRUE;
  148. }
  150. int CXTExcelTabCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct)
  151. {
  152. if (CWnd::OnCreate(lpCreateStruct) == -1)
  153. return -1;
  155. // Save the window style.
  156. m_dwStyle = lpCreateStruct->style;
  158. m_nClientWidth = lpCreateStruct->cx;
  159. m_nClientHeight = lpCreateStruct->cy;
  161. SetTabStyle(m_dwStyle);
  163. return 0;
  164. }
  166. void CXTExcelTabCtrl::SetGripperPosition(int x, bool bPercent)
  167. {
  168. // only valid for tabs with horizontal scroll bars
  169. if (!(m_dwStyle & FTS_XT_HSCROLL)) return;
  171. int x_percent;
  172. if (bPercent)
  173. {
  174. x_percent = x;
  175. x = m_nClientWidth * x / 100;
  176. }
  177. else
  178. {
  179. x_percent = x * 100 / m_nClientWidth;
  180. }
  182. // too far to the left ?
  183. const int arrowWidth = 0; //GetTotalArrowWidth();
  184. if (x < arrowWidth) x = arrowWidth;
  186. // too far to the right ?
  187. const int sbExtreme = (m_nClientWidth - 4 * m_cx - m_cy);
  188. if (x > sbExtreme) x = sbExtreme;
  190. m_xGripperPos = x;
  191. m_iGripperPosPerCent = x_percent;
  193. m_rectGripper = m_rectTabs;
  194. m_rectGripper.left += x;
  195. m_rectGripper.right = m_rectGripper.left + GRIPPER_WIDTH;
  197. const int isbottom = ((m_dwStyle & FTS_XT_BOTTOM) == FTS_XT_BOTTOM);
  198. m_rectSB_H = CRect(
  199. m_rectGripper.right,
  200. m_rectTabs.top - !isbottom,
  201. m_rectTabs.right - m_cy,
  202. m_rectTabs.bottom + isbottom);
  203. m_wndHScrollBar.MoveWindow(m_rectSB_H);
  205. EnableButtons();
  206. InvalidateRect(m_rectTabs);
  207. }
  209. void CXTExcelTabCtrl::SetTabStyle(DWORD dwStyle)
  210. {
  211. m_dwStyle = dwStyle;
  213. if (!GetSafeHwnd())
  214. return;
  216. if (m_dwStyle & FTS_XT_HASHOMEEND) m_dwStyle |= FTS_XT_HASARROWS;
  218. // If we use tooltips, create the control.
  219. if (m_dwStyle & FTS_XT_TOOLTIPS)
  220. {
  221. if (m_ToolTip.GetSafeHwnd() == 0)
  222. {
  223. CString strTipText;
  224. XTPResourceManager()->LoadString(&strTipText, XT_IDS_TIPTEXT);
  226. m_ToolTip.Create(this);
  227. m_ToolTip.Activate(TRUE);
  228. m_ToolTip.AddTool(this, strTipText);
  229. m_ToolTip.SendMessage(TTM_SETMAXTIPWIDTH, 0, SHRT_MAX); // Allow multi line tooltips
  230. }
  231. }
  232. else
  233. {
  234. m_ToolTip.DestroyWindow();
  235. }
  237. CRect rectDummy(0, 0, 0, 0);
  239. // If we use arrow buttons, create the buttons.
  240. if (m_dwStyle & FTS_XT_HASARROWS)
  241. {
  242. int nIndex = 0;
  244. // Create the home button.
  245. if (m_dwStyle & FTS_XT_HASHOMEEND)
  246. {
  247. m_buttons[nIndex].SetInfo(rectDummy, XT_IDC_BTN_HOME,
  248. xtArrowIconLeftHome);
  249. m_iBtnHome = nIndex;
  250. ++nIndex;
  251. }
  252. else
  253. {
  254. m_iBtnHome = 3;
  255. }
  257. // Create the left button.
  258. m_buttons[nIndex].SetInfo(rectDummy, XT_IDC_BTN_LEFT, xtArrowIconLeft);
  259. m_iBtnLeft = nIndex;
  260. ++nIndex;
  262. // Create the right button.
  263. m_buttons[nIndex].SetInfo(rectDummy, XT_IDC_BTN_RIGHT, xtArrowIconRight);
  264. m_iBtnRight = nIndex;
  265. ++nIndex;
  267. // Create the end button.
  268. if (m_dwStyle & FTS_XT_HASHOMEEND)
  269. {
  270. m_buttons[nIndex].SetInfo(rectDummy, XT_IDC_BTN_END,
  271. xtArrowIconRightHome);
  272. m_iBtnEnd = nIndex;
  273. ++nIndex;
  274. }
  275. else
  276. {
  277. m_iBtnEnd = 3;
  278. }
  280. }
  282. if (m_dwStyle & FTS_XT_HSCROLL)
  283. {
  284. if (m_wndHScrollBar.GetSafeHwnd() == 0)
  285. {
  286. CRect rc(0, 0, 0, 0);
  287. VERIFY(m_wndHScrollBar.Create(WS_VISIBLE | WS_CHILD | SBS_HORZ,
  288. rc, this, AFX_IDW_HSCROLL_FIRST));
  289. SetGripperPosition(60, true);
  290. }
  291. }
  292. else
  293. {
  294. m_wndHScrollBar.DestroyWindow();
  295. m_rectSB_H = CRect(0, 0, 0, 0);
  296. }
  298. RecalcLayout();
  299. SetGripperPosition(m_iGripperPosPerCent, true);
  301. RedrawWindow();
  303. }
  306. int CXTExcelTabCtrl::GetGripperPosition() const
  307. {
  308. return m_xGripperPos;
  309. }
  312. BOOL CXTExcelTabCtrl::OnEraseBkgnd(CDC* pDC)
  313. {
  314. if (GetItemCount() == 0)
  315. {
  316. pDC->FillSolidRect(m_rectViews, GetXtremeColor(COLOR_3DFACE));
  317. }
  318. return TRUE;
  319. }
  321. void CXTExcelTabCtrl::CreateButtonIcons()
  322. {
  323. // obsolete
  324. }
  326. void CXTExcelTabCtrl::FreeButtonIcons()
  327. {
  328. // obsolete
  329. }
  331. int CXTExcelTabCtrl::GetTabWidth(int nItem) const
  332. {
  333. CDC *pDC = CDC::FromHandle(::GetDC(m_hWnd));
  335. CFont* pOldFont = pDC->SelectObject((m_nCurSel == nItem) ?
  336. m_pBoldFont : m_pNormFont);
  338. CSize size = pDC->GetTextExtent(m_tcbItems[nItem]->szTabLabel);
  339. pDC->SelectObject(pOldFont);
  341. ::ReleaseDC(m_hWnd, pDC->m_hDC);
  343. return size.cx + m_cy + (m_cy / 2);
  344. }
  346. int CXTExcelTabCtrl::GetTotalTabWidth() const
  347. {
  348. int iWidth = 0;
  349. const int cItems = GetItemCount();
  350. const int iOverlap = GetOverlap();
  351. int i;
  352. for (i = 0; i < cItems; i++)
  353. {
  354. iWidth += GetTabWidth(i);
  355. if (i != 0)
  356. {
  357. iWidth -= iOverlap;
  358. }
  359. }
  360. return iWidth;
  361. }
  363. int CXTExcelTabCtrl::GetTotalArrowWidth() const
  364. {
  365. int iWidth = 0;
  367. if (m_dwStyle & FTS_XT_HASARROWS)
  368. iWidth += (m_cx * 2);
  370. if (m_dwStyle & FTS_XT_HASHOMEEND)
  371. iWidth += (m_cx * 2);
  373. return iWidth;
  374. }
  376. int CXTExcelTabCtrl::GetTotalTabAreaWidth() const
  377. {
  378. int iWidth;
  379. if (m_dwStyle & FTS_XT_HSCROLL)
  380. {
  381. iWidth = m_xGripperPos;
  382. }
  383. else
  384. {
  385. iWidth = m_nClientWidth;
  386. }
  387. iWidth -= GetTotalArrowWidth();
  388. return iWidth;
  389. }
  391. void CXTExcelTabCtrl::InvalidateTabs()
  392. {
  393. if (GetSafeHwnd())
  394. {
  395. // invalidate the visible tab area
  396. // to minimize flicker - don't erase the background
  397. CRect rcTabs;
  399. rcTabs.left = GetTotalArrowWidth();
  400. rcTabs.top = m_rectTabs.top;
  401. rcTabs.right = rcTabs.left + (GetTotalTabWidth() - m_nOffset);
  402. rcTabs.bottom = m_rectTabs.bottom;
  403. InvalidateRect(&rcTabs, FALSE);
  405. // invalidate the blank area to the right of the tabs
  406. if (rcTabs.right < m_nClientWidth)
  407. {
  408. rcTabs.left = rcTabs.right;
  409. rcTabs.right = m_nClientWidth;
  410. InvalidateRect(&rcTabs, TRUE);
  411. }
  412. }
  413. }
  415. void CXTExcelTabCtrl::EnableButtons()
  416. {
  417. if (m_dwStyle & FTS_XT_HASARROWS)
  418. {
  419. m_buttons[m_iBtnLeft].m_bEnabled = (m_nOffset > 0);
  420. m_buttons[m_iBtnRight].m_bEnabled =
  421. (GetTotalTabWidth() - m_nOffset > GetTotalTabAreaWidth() - 1);
  423. if (m_dwStyle & FTS_XT_HASHOMEEND)
  424. {
  425. m_buttons[m_iBtnHome].m_bEnabled = m_buttons[m_iBtnLeft].m_bEnabled;
  426. m_buttons[m_iBtnEnd].m_bEnabled = m_buttons[m_iBtnRight].m_bEnabled;
  427. }
  429. CRect rc = m_buttons[m_iBtnLeft].m_rect;
  430. rc.left = 0;
  431. rc.right = GetTotalArrowWidth();
  432. InvalidateRect(rc);
  433. }
  434. else
  435. {
  436. InvalidateRect(CRect(0, 0, GetTotalArrowWidth(), m_nClientHeight));
  437. }
  438. }
  440. BOOL CXTExcelTabCtrl::GetItemRect(int nItem, LPRECT lpRect)
  441. {
  442. const int cItems = GetItemCount();
  443. if (nItem < 0 || nItem >= cItems)
  444. return FALSE;
  446. const int iOverlap = GetOverlap();
  447. int x = GetTotalArrowWidth();
  448. int i;
  449. for (i = 0; i < nItem; i++)
  450. {
  451. x += GetTabWidth(i) - iOverlap;
  452. }
  453. lpRect->left = x - m_nOffset;
  454. lpRect->top = m_rectTabs.top;
  455. lpRect->right = lpRect->left + GetTabWidth(nItem);
  456. lpRect->bottom = m_rectTabs.bottom;
  457. return TRUE;
  458. }
  460. void CXTExcelTabCtrl::ResetMouseOver()
  461. {
  462. for (int i = 0; i < BUTTON_COUNT; ++i)
  463. {
  464. m_buttons[i].m_bHilight = false;
  465. }
  466. }
  468. int CXTExcelTabCtrl::ButtonHitTest(CPoint& pt)
  469. {
  470. ResetMouseOver();
  472. int i;
  473. for (i = 0; i < BUTTON_COUNT; ++i)
  474. {
  475. if (m_buttons[i].m_rect.PtInRect(pt))
  476. {
  477. m_buttons[i].m_bHilight = true;
  478. return i;
  479. }
  480. }
  482. return -1;
  483. }
  485. int CXTExcelTabCtrl::HitTest(TCHITTESTINFO* pHitTestInfo) const
  486. {
  487. // ignore hits on the buttons
  488. int iHitX = pHitTestInfo->pt.x;
  489. if (iHitX < GetTotalArrowWidth())
  490. return -1;
  492. // on or to the right of the the scroll bar/gripper ?
  493. if ((m_dwStyle & FTS_XT_HSCROLL) && iHitX > m_rectGripper.left)
  494. {
  495. return -1;
  496. }
  498. const int iOverlap = GetOverlap();
  500. // check if any tabs were hit
  501. int x = GetTotalArrowWidth() - m_nOffset;
  502. const int cItems = GetItemCount();
  503. int i;
  504. for (i = 0; i < cItems; i++)
  505. {
  506. int iTabWidth = GetTabWidth(i);
  507. if (i != cItems - 1)
  508. {
  509. iTabWidth -= iOverlap;
  510. }
  511. if ((x <= iHitX) && (iHitX <= x + iTabWidth))
  512. {
  513. return i;
  514. }
  515. x += iTabWidth;
  516. }
  518. // hit point is right of rightmost tab
  519. return -1;
  520. }
  522. void CXTExcelTabCtrl::OnLeftArrow()
  523. {
  524. // Move the tabs right, ensuring that we move right by one
  525. // whole tab each time ala Microsoft Access
  527. CPoint Point(GetTotalArrowWidth() + 1 + GetOverlap(), 1);
  529. TCHITTESTINFO htInfo;
  530. htInfo.pt = Point;
  531. int iTab = HitTest(&htInfo);
  533. if (iTab != -1)
  534. {
  535. m_nOffset = 0;
  536. RECT rect;
  537. if (GetItemRect(iTab - 1, &rect))
  538. {
  539. m_nOffset += rect.left;
  540. m_nOffset -= GetTotalArrowWidth();
  541. EnableButtons();
  542. InvalidateTabs();
  543. }
  544. }
  545. }
  547. void CXTExcelTabCtrl::OnRightArrow()
  548. {
  549. // Move the tabs left, ensuring that we move left by one
  550. // whole tab each time ala Microsoft Access
  552. CPoint Point(GetTotalArrowWidth()+ 1 + GetOverlap(), 1);
  554. TCHITTESTINFO htInfo;
  555. htInfo.pt = Point;
  556. int iTab = HitTest(&htInfo);
  558. if (iTab != -1)
  559. {
  560. RECT rect;
  561. if (GetItemRect(iTab + 1, &rect))
  562. {
  563. m_nOffset += rect.left - GetTotalArrowWidth();
  564. EnableButtons();
  565. InvalidateTabs();
  566. }
  567. }
  568. }
  570. void CXTExcelTabCtrl::OnHomeArrow()
  571. {
  572. m_nOffset = 0;
  573. EnableButtons();
  574. InvalidateTabs();
  575. }
  577. void CXTExcelTabCtrl::OnEndArrow()
  578. {
  579. m_nOffset = GetTotalTabWidth() - GetTotalTabAreaWidth() + 1;
  580. EnableButtons();
  581. InvalidateTabs();
  582. }
  584. void CXTExcelTabCtrl::OnSize(UINT nType, int cx, int cy)
  585. {
  586. CWnd::OnSize(nType, cx, cy);
  588. m_nClientWidth = cx;
  589. m_nClientHeight = cy;
  591. RecalcLayout();
  592. SetGripperPosition(m_iGripperPosPerCent, true);
  593. SyncScrollBar();
  594. }
  596. int CXTExcelTabCtrl::InsertItem(int nItem, LPCTSTR lpszItem, CWnd* pWndControl)
  597. {
  598. const int cItems = GetItemCount();
  599. if (nItem < 0 || nItem > cItems)
  600. return -1;
  602. if (pWndControl)
  603. {
  604. ASSERT(::IsWindow(pWndControl->m_hWnd));
  606. // managed view should be a hidden child
  607. ASSERT((::GetWindowLong(pWndControl->m_hWnd, GWL_STYLE) & (WS_VISIBLE | WS_CHILD)) == WS_CHILD);
  609. // can't have both managed and non-managed tabs
  610. ASSERT(m_bManagingViews || cItems == 0);
  612. m_bManagingViews = true;
  614. pWndControl->SetParent(this);
  615. pWndControl->SetWindowPos(NULL, m_rectViews.left, m_rectViews.top,
  616. m_rectViews.Width(), m_rectViews.Height(),
  617. SWP_NOZORDER | SWP_NOREDRAW);
  618. }
  620. // Allocate a new CXTTcbItem object.
  621. CXTTcbItem* pMember = new CXTTcbItem;
  622. if (pMember == NULL)
  623. return -1;
  625. pMember->pWnd = pWndControl;
  626. pMember->szTabLabel = lpszItem;
  627. pMember->szToolTipLabel = lpszItem;
  628. pMember->uiToolTipId = GetItemCount();
  630. if (nItem <= m_nCurSel) ++m_nCurSel;
  632. // Add the new CXTTcbItem to the tab item list.
  633. m_tcbItems.InsertAt(nItem, pMember);
  635. if (m_nCurSel < 0) m_nCurSel = 0;
  636. EnableButtons();
  637. InvalidateTabs();
  638. SetCurSel(nItem);
  640. return nItem;
  641. }
  643. BOOL CXTExcelTabCtrl::_DeleteItem(int nItem)
  644. {
  645. const int cItems = (int)m_tcbItems.GetSize();
  646. if (nItem < 0 || nItem >= cItems)
  647. return FALSE;
  649. // Remove the item from the string arrays.
  650. CWnd *pWndControl = m_tcbItems[nItem]->pWnd;
  651. if (::IsWindow(pWndControl->GetSafeHwnd()))
  652. {
  653. pWndControl->ShowWindow(SW_HIDE);
  654. pWndControl->SetParent(NULL);
  655. }
  656. SAFE_DELETE(m_tcbItems[nItem]);
  657. m_tcbItems.RemoveAt(nItem);
  658. if (m_tcbItems.GetSize() == 0)
  659. {
  660. m_bManagingViews = false;
  661. }
  662. return TRUE;
  663. }
  665. BOOL CXTExcelTabCtrl::DeleteItem(int nItem)
  666. {
  667. if (!_DeleteItem(nItem))
  668. {
  669. return FALSE;
  670. }
  672. const int cItems = GetItemCount();
  673. ASSERT(cItems >= 0);
  675. if (cItems == 0)
  676. {
  677. m_nCurSel = -1;
  678. }
  679. else
  680. {
  681. if (nItem == m_nCurSel)
  682. {
  683. m_nCurSel = 0;
  684. SetCurSel(0);
  685. }
  686. else if (m_nCurSel > nItem)
  687. {
  688. --m_nCurSel;
  689. }
  690. }
  692. EnableButtons();
  693. InvalidateTabs();
  695. return TRUE;
  696. }
  698. void CXTExcelTabCtrl::ClearAllItems()
  699. {
  700. while (_DeleteItem(0))
  701. {
  702. };
  703. }
  705. BOOL CXTExcelTabCtrl::DeleteAllItems()
  706. {
  707. ClearAllItems();
  709. // Reset the currently selected tab to -1 as we have no tabs in our list now.
  710. m_nCurSel = -1;
  712. EnableButtons();
  713. InvalidateTabs();
  715. return TRUE;
  716. }
  718. int CXTExcelTabCtrl::SetCurSel(int nItem)
  719. {
  720. const int cItems = GetItemCount();
  721. if (nItem < 0 || nItem >= cItems)
  722. return -1;
  724. int iPrevSel = m_nCurSel;
  725. m_nCurSel = nItem;
  727. // test if we need to center on the selected tab
  728. CRect rcItem;
  729. if (GetItemRect(nItem, &rcItem))
  730. {
  731. // test if the tab is off on the left
  732. int iTotalArrowWidth = GetTotalArrowWidth();
  733. rcItem.left -= iTotalArrowWidth;
  734. if (rcItem.left <= 0)
  735. m_nOffset += rcItem.left;
  736. else
  737. {
  738. // test if the tab is off on the right
  739. rcItem.right -= iTotalArrowWidth;
  740. int iTabAreaWidth = GetTotalTabAreaWidth();
  741. if (rcItem.right > iTabAreaWidth)
  742. m_nOffset += (rcItem.right - iTabAreaWidth);
  743. }
  744. }
  746. // hide/show managed controls
  747. ASSERT(iPrevSel >= 0);
  748. if (iPrevSel < cItems && m_tcbItems[iPrevSel]->pWnd->GetSafeHwnd())
  749. {
  750. m_tcbItems[iPrevSel]->pWnd->ShowWindow(SW_HIDE);
  751. }
  752. if (m_tcbItems[m_nCurSel]->pWnd->GetSafeHwnd())
  753. {
  754. m_tcbItems[m_nCurSel]->pWnd->ShowWindow(SW_SHOW);
  755. }
  757. // reset scroll bar position
  758. SyncScrollBar();
  760. EnableButtons();
  761. InvalidateTabs();
  763. return iPrevSel;
  764. }
  766. void CXTExcelTabCtrl::OnLButtonDown(UINT nFlags, CPoint point)
  767. {
  768. TCHITTESTINFO tchtinfo;
  769. tchtinfo.pt = point;
  771. // sizing grip ?
  772. if (m_rectGripper.PtInRect(point))
  773. {
  774. ASSERT(m_bTracking == false);
  775. SetTracking(true);
  776. return;
  777. }
  779. // on a button ?
  780. int iButton = ButtonHitTest(point);
  781. if (iButton >= 0)
  782. {
  783. CXTExcelTabCtrlButtonState& b = m_buttons[iButton];
  784. if (b.m_bEnabled)
  785. {
  786. b.m_bPressed = true;
  787. RedrawWindow(b.m_rect);
  788. SetCapture();
  789. }
  790. return;
  791. }
  793. int iTab = HitTest(&tchtinfo);
  794. if ((iTab != -1) && (iTab != m_nCurSel))
  795. {
  796. // warn parent that the selection is about to change
  797. int id = GetDlgCtrlID();
  798. NMHDR hdr;
  799. hdr.hwndFrom = m_hWnd;
  800. hdr.idFrom = id;
  801. hdr.code = TCN_SELCHANGING;
  802. if (GetOwner()->SendMessage(WM_NOTIFY, id, (LPARAM)&hdr) == 0)
  803. {
  804. // parent has given permission for the selection to change
  805. SetCurSel(iTab);
  806. InvalidateTabs();
  808. // notify parent that the selection has changed
  809. hdr.hwndFrom = m_hWnd;
  810. hdr.idFrom = id;
  811. hdr.code = TCN_SELCHANGE;
  812. GetOwner()->SendMessage(WM_NOTIFY, id, (LPARAM)&hdr);
  813. }
  814. }
  816. CWnd::OnLButtonDown(nFlags, point);
  817. }
  819. void CXTExcelTabCtrl::OnLButtonUp(UINT nFlags, CPoint point)
  820. {
  821. if (m_bTracking)
  822. {
  823. SetTracking(false);
  824. }
  826. // on a button ?
  827. int i;
  828. for (i = 0; i < BUTTON_COUNT; ++i)
  829. {
  830. CXTExcelTabCtrlButtonState& b = m_buttons[i];
  831. if (b.m_bEnabled & b.m_bPressed)
  832. {
  833. PostMessage(WM_COMMAND, b.m_iCommand, NULL);
  834. b.m_bPressed = false;
  835. RedrawWindow(b.m_rect);
  836. ReleaseCapture();
  837. return;
  838. }
  839. }
  841. CWnd::OnLButtonUp(nFlags, point);
  842. }
  844. void CXTExcelTabCtrl::OnPaint()
  845. {
  846. CPaintDC dc(this);
  848. if (m_dwStyle & FTS_XT_HSCROLL)
  849. {
  850. dc.ExcludeClipRect(&m_rectSB_H);
  851. }
  853. CXTPBufferDC memDC(dc, m_rectTabs);
  854. OnDraw(&memDC);
  855. }
  857. LRESULT CXTExcelTabCtrl::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  858. {
  859. CDC* pDC = CDC::FromHandle((HDC)wParam);
  860. if (pDC)
  861. {
  862. OnDraw(pDC);
  863. }
  865. return TRUE;
  866. }
  868. void CXTExcelTabCtrl::OnDraw(CDC* pDC)
  869. {
  870. CRect rectPaint(m_rectTabs);  // this the only part we care about
  872. pDC->FillSolidRect(rectPaint, GetXtremeColor(COLOR_3DFACE));
  874. // Exclude the arrow buttons from being repainted.
  875. const int iTotalArrowWidth = GetTotalArrowWidth();
  876. CRect rcArrows(rectPaint);
  877. rcArrows.top += 1;
  878. rcArrows.right = rcArrows.left + iTotalArrowWidth-1;
  880. pDC->FillSolidRect(0, (m_dwStyle & FTS_XT_BOTTOM) ? rectPaint.top : rectPaint.bottom - 1,
  881. rectPaint.Width(), 1, GetTheme()->m_clr3DShadow);
  883. int i;
  884. for (i = 0; i < BUTTON_COUNT; ++i)
  885. {
  886. if (CRect().IntersectRect(rectPaint, m_buttons[i].m_rect))
  887. {
  888. GetTheme()->DrawButton(pDC, this, m_buttons[i]);
  889. }
  890. }
  892. if (rectPaint.right >= rcArrows.right)
  893. {
  894. const int nTotalTabWidth = GetTotalTabWidth();
  896. // Draw the tabs to an offscreen device context, this is done
  897. // so that we can "scroll" the entire tab group left or right whenever
  898. // any of the arrow buttons are pressed.
  899. CDC tabDC;
  900. tabDC.CreateCompatibleDC(pDC);
  901. CBitmap bitmap;
  902. bitmap.CreateCompatibleBitmap(pDC, nTotalTabWidth, m_cy);
  903. CBitmap* pOldBitmap = tabDC.SelectObject(&bitmap);
  905. // Fill the background color.
  906. CRect rcTabs(0, 0, nTotalTabWidth, m_cy);
  907. tabDC.FillSolidRect(rcTabs, GetXtremeColor(COLOR_3DFACE));
  909. // Define xy coordinates to draw each tab.
  910. const int iOverlap = GetOverlap();
  911. int x = 0;
  912. int iSelX = 0;
  913. int y = 0;
  915. // Draw all of the non-selected tabs first...
  916. const int cItems = GetItemCount();
  917. for (i = 0; i < cItems; i++)
  918. {
  919. if (i != m_nCurSel)
  920. {
  921. const int cx = GetTheme()->DrawTab(&tabDC, this,
  922. CPoint(x, y), false, m_tcbItems[i]);
  923. x += cx;
  924. }
  925. else
  926. {
  927. iSelX = x;
  928. x += GetTabWidth(i);
  929. }
  930. x -= iOverlap;
  931. }
  933. // then draw the selected tab. Make sure that m_TabList is not empty.
  934. if (m_nCurSel >= 0 && cItems > 0)
  935. {
  936. GetTheme()->DrawTab(&tabDC, this,
  937. CPoint(iSelX, y), true, m_tcbItems[m_nCurSel]);
  938. }
  940. // blit the bitmap onto the pDC->
  941. pDC->BitBlt(iTotalArrowWidth, rectPaint.top, GetTotalTabAreaWidth(),
  942. m_cy, &tabDC, m_nOffset, 0, SRCCOPY);
  943. // cleanup.
  944. tabDC.SelectObject(pOldBitmap);
  945. }
  947. if (m_dwStyle & FTS_XT_HSCROLL)
  948. {
  949. DrawGripper(pDC, m_rectGripper);
  950. }
  951. }
  953. void CXTExcelTabCtrl::DrawGripper(CDC* pDC, CRect rect) const
  954. {
  955. pDC->Draw3dRect(rect, GetXtremeColor(COLOR_3DHILIGHT), GetXtremeColor(COLOR_3DSHADOW));
  956. rect.InflateRect(-CX_BORDER, -CY_BORDER);
  958. // fill the middle
  959. pDC->FillSolidRect(rect, GetXtremeColor(COLOR_3DFACE));
  960. }
  962. BOOL CXTExcelTabCtrl::PreTranslateMessage(MSG* pMsg)
  963. {
  964. ASSERT_VALID(this);
  965. if (pMsg->message == WM_KEYDOWN)
  966. {
  967. if (pMsg->wParam == VK_ESCAPE)
  968. {
  969. if (m_bTracking)
  970. {
  971. SetTracking(false);
  972. }
  974. return TRUE; // eat ESC keyboard press...
  975. }
  976. }
  978. if (::IsWindow(m_ToolTip.m_hWnd))
  979. {
  980. if (pMsg->message == WM_MOUSEMOVE && pMsg->hwnd == m_hWnd)
  981. {
  982. CPoint Point(LOWORD(pMsg->lParam), HIWORD(pMsg->lParam));
  984. TCHITTESTINFO htInfo;
  985. htInfo.pt = Point;
  986. int iTab = HitTest(&htInfo);
  988. if (iTab >= 0)
  989. {
  990. CString strOldTipText;
  991. CString strNewTipText = m_tcbItems[iTab]->szToolTipLabel;
  993. m_ToolTip.GetText(strOldTipText, this);
  995. // If the tip text differs, update the tooltip control.
  996. if (strNewTipText != strOldTipText)
  997. {
  998. m_ToolTip.DelTool(this);
  999. m_ToolTip.AddTool(this, strNewTipText);
  1000. }
  1002. // Pass on to tooltip.
  1003. m_ToolTip.RelayEvent(pMsg);
  1004. }
  1005. else
  1006. {
  1007. m_ToolTip.SendMessage(TTM_POP, 0, 0L);
  1008. }
  1009. }
  1010. else
  1011. {
  1012. m_ToolTip.SendMessage(TTM_POP, 0, 0L);
  1013. }
  1014. }
  1016. return CWnd::PreTranslateMessage(pMsg);
  1017. }
  1019. void CXTExcelTabCtrl::SetTipText(int nItem, LPCTSTR lpszTabTip)
  1020. {
  1021. const int cItems = GetItemCount();
  1022. if (nItem < 0 || nItem >= cItems)
  1023. {
  1024. ASSERT(0);
  1025. return;
  1026. }
  1027. m_tcbItems[nItem]->szToolTipLabel = lpszTabTip;
  1028. }
  1030. CString CXTExcelTabCtrl::GetTipText(int nItem)
  1031. {
  1032. const int cItems = GetItemCount();
  1033. if (nItem < 0 || nItem >= cItems)
  1034. {
  1035. ASSERT(0);
  1036. return _T("");
  1037. }
  1038. return m_tcbItems[nItem]->szToolTipLabel;
  1039. }
  1041. void CXTExcelTabCtrl::Home()
  1042. {
  1043. OnHomeArrow();
  1044. }
  1046. void CXTExcelTabCtrl::OnMouseMove(UINT nFlags, CPoint point)
  1047. {
  1048. if (m_bTracking)
  1049. {
  1050. // resize
  1051. SetGripperPosition(point.x + m_xTrackingDelta, false);
  1052. }
  1053. else
  1054. {
  1055. if (ButtonHitTest(point) != m_iBtnHilight)
  1056. {
  1057. SetTimer(1, 10, NULL);
  1058. OnTimer(1);
  1059. }
  1060. }
  1062. CWnd::OnMouseMove(nFlags, point);
  1063. }
  1065. BOOL CXTExcelTabCtrl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
  1066. {
  1067. if (m_bTracking && GetCapture() != this)
  1068. {
  1069. m_bTracking = FALSE;
  1070. }
  1072. POINT pt;
  1073. GetCursorPos(&pt);
  1074. ScreenToClient(&pt);
  1075. if (m_bTracking || m_rectGripper.PtInRect(pt))
  1076. {
  1077. ::SetCursor(XTAuxData().hcurHSplitBar);
  1078. return TRUE;
  1079. }
  1081. return CWnd::OnSetCursor(pWnd, nHitTest, message);
  1082. }
  1084. void CXTExcelTabCtrl::SetTracking(bool bTracking)
  1085. {
  1086. if (m_bTracking == bTracking)
  1087. {
  1088. return;
  1089. }
  1091. m_bTracking = bTracking;
  1092. if (bTracking)
  1093. {
  1094. SetCapture();
  1095. POINT pt;
  1096. GetCursorPos(&pt);
  1097. ScreenToClient(&pt);
  1098. m_xTrackingDelta = GetGripperPosition() - pt.x;
  1099. m_pWndLastFocus = SetFocus();
  1100. }
  1101. else
  1102. {
  1103. ReleaseCapture();
  1104. if (::IsWindow(m_pWndLastFocus->GetSafeHwnd()))
  1105. {
  1106. m_pWndLastFocus->SetFocus();
  1107. }
  1108. else
  1109. {
  1110. m_pWndLastFocus = NULL;
  1111. }
  1112. }
  1113. }
  1115. void CXTExcelTabCtrl::OnLButtonDblClk(UINT nFlags, CPoint point)
  1116. {
  1117. // on a button ?
  1118. int iButton = ButtonHitTest(point);
  1119. if (iButton >= 0)
  1120. {
  1121. CXTExcelTabCtrlButtonState& b = m_buttons[iButton];
  1122. if (b.m_bEnabled)
  1123. {
  1124. SetCapture();
  1125. b.m_bPressed = true;
  1126. RedrawWindow(b.m_rect);
  1127. }
  1128. return;
  1129. }
  1131. CWnd::OnLButtonDblClk(nFlags, point);
  1132. }
  1134. void CXTExcelTabCtrl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* /*pScrollBar*/)
  1135. {
  1136. CWnd *pWndControl = m_tcbItems[m_nCurSel]->pWnd;
  1137. if (pWndControl->GetSafeHwnd())
  1138. {
  1139. if (nSBCode == SB_THUMBPOSITION || nSBCode == SB_THUMBTRACK)
  1140. {
  1141. int dx = nPos - pWndControl->GetScrollPos(SB_HORZ);
  1142. if (dx)
  1143. {
  1144. pWndControl->SendMessage(LVM_SCROLL, dx, 0);
  1145. }
  1146. }
  1148. // pass message to control's scroll bar
  1149. _AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
  1150. pWndControl->SendMessage(
  1151. pThreadState->m_lastSentMsg.message,
  1152. pThreadState->m_lastSentMsg.wParam,
  1153. (LPARAM)pWndControl->GetScrollBarCtrl(SB_HORZ)->GetSafeHwnd());
  1155. // reflect changes in our scroll bar
  1156. SyncScrollBar();
  1157. }
  1158. }
  1160. void CXTExcelTabCtrl::SyncScrollBar()
  1161. {
  1162. if (!m_wndHScrollBar.m_hWnd)
  1163. {
  1164. return;
  1165. }
  1167. CWnd *pWndControl = NULL;
  1168. if (m_nCurSel >= 0)
  1169. {
  1170. pWndControl = m_tcbItems[m_nCurSel]->pWnd;
  1171. }
  1172. if (pWndControl && pWndControl->GetSafeHwnd())
  1173. {
  1174. pWndControl->ShowScrollBar(SB_HORZ, FALSE);
  1175. pWndControl->ModifyStyle(WS_HSCROLL, 0, SWP_DRAWFRAME);
  1177. SCROLLINFO si;
  1178. ZeroMemory(&si, sizeof(si));
  1179. si.cbSize = sizeof(si);
  1180. si.fMask = SIF_ALL;
  1182. if (!pWndControl->GetScrollInfo (SB_HORZ, &si) ||
  1183. si.nPage == 0 ||
  1184. si.nMin + (int) si.nPage >= si.nMax)
  1185. {
  1186. m_wndHScrollBar.EnableWindow(FALSE);
  1187. }
  1188. else
  1189. {
  1190. m_wndHScrollBar.EnableWindow(TRUE);
  1191. m_wndHScrollBar.SetScrollInfo(&si);
  1192. }
  1193. }
  1194. else
  1195. {
  1196. m_wndHScrollBar.EnableWindow(FALSE);
  1197. }
  1198. }
  1200. BOOL CXTExcelTabCtrl::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1201. {
  1202. NMHDR* pNMHDR = (NMHDR*)lParam;
  1203. ASSERT (pNMHDR != NULL);
  1205. BOOL bRetVal = CWnd::OnNotify(wParam, lParam, pResult);
  1207. if (pNMHDR && pNMHDR->code == HDN_ITEMCHANGED)
  1208. {
  1209. SyncScrollBar();
  1210. }
  1212. return bRetVal;
  1213. }
  1215. void CXTExcelTabCtrl::RecalcLayout()
  1216. {
  1217. m_rectViews.left = m_rectTabs.left = 0;
  1218. m_rectViews.right = m_rectTabs.right = m_nClientWidth;
  1219. if (m_dwStyle & FTS_XT_BOTTOM)
  1220. {
  1221. m_rectTabs.top = m_nClientHeight - m_cy;
  1222. m_rectViews.top = 0;
  1223. }
  1224. else
  1225. {
  1226. m_rectTabs.top = 0;
  1227. m_rectViews.top = m_cy;
  1228. }
  1229. m_rectTabs.bottom = m_rectTabs.top + m_cy;
  1230. m_rectViews.bottom = m_rectViews.top + m_nClientHeight - m_cy;
  1232. int nIndex;
  1234. // update managed view positions
  1235. if (m_bManagingViews)
  1236. {
  1237. const int cItems = GetItemCount();
  1238. for (nIndex = 0; nIndex < cItems; ++nIndex)
  1239. {
  1240. ASSERT(m_tcbItems[nIndex]->pWnd->GetSafeHwnd());
  1241. m_tcbItems[nIndex]->pWnd->SetWindowPos(NULL,
  1242. m_rectViews.left, m_rectViews.top,
  1243. m_rectViews.Width(), m_rectViews.Height(),
  1244. SWP_NOZORDER | SWP_NOREDRAW);
  1245. }
  1246. }
  1248. // update arrow buttons if we have them
  1249. if (m_dwStyle & FTS_XT_HASARROWS)
  1250. {
  1251. CRect btnRects[] =
  1252. {
  1253. CRect(0, m_rectTabs.top + 1, m_cx, m_rectTabs.bottom),
  1254. CRect(m_cx, m_rectTabs.top + 1, m_cx * 2, m_rectTabs.bottom),
  1255. CRect(m_cx * 2, m_rectTabs.top + 1, m_cx * 3, m_rectTabs.bottom),
  1256. CRect(m_cx * 3, m_rectTabs.top + 1, m_cx * 4, m_rectTabs.bottom)
  1257. };
  1259. const int cButtons = (m_dwStyle & FTS_XT_HASHOMEEND) ? 4 : 2;
  1260. for (nIndex = 0; nIndex < cButtons; ++nIndex)
  1261. {
  1262. m_buttons[nIndex].m_rect = btnRects[nIndex];
  1263. }
  1264. }
  1266. EnableButtons();
  1267. }
  1269. LPCTSTR CXTExcelTabCtrl::GetItemText(int nIndex) const
  1270. {
  1271. if (nIndex < 0 || nIndex >= GetItemCount())
  1272. {
  1273. return NULL;
  1274. }
  1276. return m_tcbItems[nIndex]->szTabLabel;
  1277. }
  1279. bool CXTExcelTabCtrl::SetItemText(int nIndex, LPCTSTR pszText)
  1280. {
  1281. if (nIndex < 0 || nIndex >= GetItemCount())
  1282. {
  1283. return false;
  1284. }
  1286. m_tcbItems[nIndex]->szTabLabel = pszText;
  1287. RecalcLayout();
  1288. InvalidateTabs();
  1289. return true;
  1290. }
  1292. CWnd *CXTExcelTabCtrl::GetItemWindow(int nIndex) const
  1293. {
  1294. if (nIndex < 0 || nIndex >= GetItemCount())
  1295. {
  1296. return NULL;
  1297. }
  1299. return m_tcbItems[nIndex]->pWnd;
  1300. }
  1302. int CXTExcelTabCtrl::GetOverlap() const
  1303. {
  1304. return ((m_cy / 2) + 2);
  1305. }
  1307. void CXTExcelTabCtrl::UpdateDefaultColors()
  1308. {
  1309. GetTheme()->RefreshMetrics();
  1310. }
  1312. void CXTExcelTabCtrl::SetTabShadowColor(COLORREF crShadow)
  1313. {
  1314. GetTheme()->m_clr3DShadow.SetCustomValue(crShadow);
  1315. }
  1317. COLORREF CXTExcelTabCtrl::GetTabShadowColor() const
  1318. {
  1319. return GetTheme()->m_clr3DShadow;
  1320. }
  1322. void CXTExcelTabCtrl::SetTabHilightColor(COLORREF crHilight)
  1323. {
  1324. GetTheme()->m_clr3DHilight.SetCustomValue(crHilight);
  1325. }
  1327. COLORREF CXTExcelTabCtrl::GetTabHilightColor() const
  1328. {
  1329. return GetTheme()->m_clr3DHilight;
  1330. }
  1332. void CXTExcelTabCtrl::SetTabBackColor(COLORREF crBack)
  1333. {
  1334. GetTheme()->m_clr3DFace.SetCustomValue(crBack);
  1335. }
  1337. COLORREF CXTExcelTabCtrl::GetTabBackColor() const
  1338. {
  1339. return GetTheme()->m_clr3DFace;
  1340. }
  1342. void CXTExcelTabCtrl::SetTabTextColor(COLORREF crText)
  1343. {
  1344. GetTheme()->m_clrBtnText.SetCustomValue(crText);
  1345. }
  1347. COLORREF CXTExcelTabCtrl::GetTabTextColor() const
  1348. {
  1349. return GetTheme()->m_clrBtnText;
  1350. }
  1352. void CXTExcelTabCtrl::SetSelTabBackColor(COLORREF crBack)
  1353. {
  1354. GetTheme()->m_clrWindow.SetCustomValue(crBack);
  1355. }
  1357. COLORREF CXTExcelTabCtrl::GetSelTabBackColor() const
  1358. {
  1359. return GetTheme()->m_clrWindow;
  1360. }
  1362. void CXTExcelTabCtrl::SetSelTabTextColor(COLORREF crText)
  1363. {
  1364. GetTheme()->m_clrWindowText.SetCustomValue(crText);
  1365. }
  1367. COLORREF CXTExcelTabCtrl::GetSelTabTextColor() const
  1368. {
  1369. return GetTheme()->m_clrWindowText;
  1370. }
  1372. CScrollBar* CXTExcelTabCtrl::GetScrollBarCtrl(int nBar) const
  1373. {
  1374. if (nBar == SB_HORZ && ::IsWindow(m_wndHScrollBar.m_hWnd))
  1375. {
  1376. return (CScrollBar*)&m_wndHScrollBar;
  1377. }
  1378. return CWnd::GetScrollBarCtrl(nBar);
  1379. }
  1381. CRect CXTExcelTabCtrl::GetTotalButtonRect() const
  1382. {
  1383. CRect rect;
  1385. rect.CopyRect(&m_buttons[0].m_rect);
  1387. int iWidth = 0;
  1388. for (int i = 0; i < BUTTON_COUNT; ++i)
  1389. {
  1390. iWidth += m_buttons[i].m_rect.Width();
  1391. }
  1393. rect.right = rect.left + iWidth;
  1395. return rect;
  1396. }
  1398. void CXTExcelTabCtrl::OnTimer(UINT_PTR nIDEvent)
  1399. {
  1400. if (nIDEvent == 1)
  1401. {
  1402. CRect rc;
  1403. GetWindowRect(rc);
  1405. CPoint point;
  1406. GetCursorPos(&point);
  1407. ScreenToClient(&point);
  1409. int iBtnHilight = ButtonHitTest(point);
  1410. if (iBtnHilight == -1)
  1411. {
  1412. KillTimer(1);
  1414. if (m_bPainted == TRUE)
  1415. {
  1416. CRect rect = GetTotalButtonRect();
  1417. InvalidateRect(&rect);
  1418. }
  1420. m_iBtnHilight = iBtnHilight;
  1421. m_bPainted = FALSE;
  1422. }
  1424. // On mouse over, show raised button.
  1425. else if (!m_bPainted || (iBtnHilight != m_iBtnHilight))
  1426. {
  1427. CRect rect = GetTotalButtonRect();
  1428. InvalidateRect(&rect);
  1430. m_iBtnHilight = iBtnHilight;
  1431. m_bPainted = TRUE;
  1432. }
  1433. }
  1434. else
  1435. {
  1436. CWnd::OnTimer(nIDEvent);
  1437. }
  1438. }
  1440. void CXTExcelTabCtrl::SetTabBackColor(int nIndex, COLORREF crBack)
  1441. {
  1442. if (nIndex >= 0 || nIndex < GetItemCount())
  1443. {
  1444. m_tcbItems[nIndex]->crTabBack = crBack;
  1446. CRect rcItem;
  1447. GetItemRect(nIndex, &rcItem);
  1448. InvalidateRect(rcItem);
  1449. }
  1450. }
  1452. void CXTExcelTabCtrl::SetTabTextColor(int nIndex, COLORREF crText)
  1453. {
  1454. if (nIndex >= 0 || nIndex < GetItemCount())
  1455. {
  1456. m_tcbItems[nIndex]->crTabText = crText;
  1458. CRect rcItem;
  1459. GetItemRect(nIndex, &rcItem);
  1460. InvalidateRect(rcItem);
  1461. }
  1462. }
  1464. void CXTExcelTabCtrl::SetSelTabBackColor(int nIndex, COLORREF crSelBack)
  1465. {
  1466. if (nIndex >= 0 || nIndex < GetItemCount())
  1467. {
  1468. m_tcbItems[nIndex]->crTabSelBack = crSelBack;
  1470. CRect rcItem;
  1471. GetItemRect(nIndex, &rcItem);
  1472. InvalidateRect(rcItem);
  1473. }
  1474. }
  1476. void CXTExcelTabCtrl::SetSelTabTextColor(int nIndex, COLORREF crSelText)
  1477. {
  1478. if (nIndex >= 0 || nIndex < GetItemCount())
  1479. {
  1480. m_tcbItems[nIndex]->crTabSelText = crSelText;
  1482. CRect rcItem;
  1483. GetItemRect(nIndex, &rcItem);
  1484. InvalidateRect(rcItem);
  1485. }
  1486. }
  1488. COLORREF CXTExcelTabCtrl::GetTabBackColor(int nIndex) const
  1489. {
  1490. return GetTheme()->GetTabBackColor(m_tcbItems[nIndex]);
  1491. }
  1493. COLORREF CXTExcelTabCtrl::GetTabTextColor(int nIndex) const
  1494. {
  1495. return GetTheme()->GetTabTextColor(m_tcbItems[nIndex]);
  1496. }
  1498. COLORREF CXTExcelTabCtrl::GetSelTabBackColor(int nIndex) const
  1499. {
  1500. return GetTheme()->GetSelTabBackColor(m_tcbItems[nIndex]);
  1501. }
  1503. COLORREF CXTExcelTabCtrl::GetSelTabTextColor(int nIndex) const
  1504. {
  1505. return GetTheme()->GetSelTabTextColor(m_tcbItems[nIndex]);
  1506. }
  1508. //{{AFX_CODEJOCK_PRIVATE
  1509. IMPLEMENT_DYNAMIC(CXTFlatTabCtrl, CXTExcelTabCtrl) // deprecated.
  1510. //}}AFX_CODEJOCK_PRIVATE