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

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

对话框与窗口

开发平台：

Visual C++

XTPTabManager.cpp：源码内容
  1. // XTPTabManager.cpp: implementation of the CXTPTabManager class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO 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/XTPVC80Helpers.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPToolTipContext.h"
  27. #include "Common/XTPResourceManager.h"
  28. #include "Common/XTPImageManager.h"
  29. #include "Common/XTPMarkupRender.h"
  31. #include "XTPTabManager.h"
  32. #include "XTPTabPaintManager.h"
  34. #ifdef _DEBUG
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #define new DEBUG_NEW
  38. #endif
  40. IMPLEMENT_DYNAMIC(CXTPTabManagerItem, CCmdTarget)
  42. //////////////////////////////////////////////////////////////////////
  43. // CXTPTabManagerItem
  45. CXTPTabManagerItem::CXTPTabManagerItem()
  46. {
  47. EnableAutomation();
  50. m_bVisible = TRUE;
  51. m_bEnabled = TRUE;
  54. m_hIcon = 0;
  55. m_hWnd = 0;
  56. m_clrItem = 0;
  57. m_nIndex = -1;
  58. m_nImage = -1;
  59. m_dwData = 0;
  60. m_rcItem.SetRectEmpty();
  61. m_nItemRow = 0;
  62. m_nButtonLength = m_nContentLength = 0;
  63. m_bClosable = TRUE;
  64. m_pTabManager = NULL;
  65. m_bFound = FALSE;
  67. m_pMarkupUIElement = 0;
  68. }
  70. void CXTPTabManagerItem::OnRemoved()
  71. {
  72. for (int j = 0; j < m_arrNavigateButtons.GetSize(); j++)
  73. delete m_arrNavigateButtons[j];
  75. m_arrNavigateButtons.RemoveAll();
  76. }
  79. CXTPTabManagerItem::~CXTPTabManagerItem()
  80. {
  81. for (int j = 0; j < m_arrNavigateButtons.GetSize(); j++)
  82. delete m_arrNavigateButtons[j];
  84. XTPMarkupReleaseElement(m_pMarkupUIElement);
  85. }
  89. void CXTPTabManagerItem::Reposition()
  90. {
  91. if (m_pTabManager) m_pTabManager->Reposition();
  92. }
  94. void CXTPTabManagerItem::SetCaption(LPCTSTR lpszCaption)
  95. {
  96. if (m_strCaption != lpszCaption)
  97. {
  98. m_strCaption = lpszCaption;
  100. XTPMarkupReleaseElement(m_pMarkupUIElement);
  101. if (m_pTabManager && m_pTabManager->GetMarkupContext())
  102. {
  103. m_pMarkupUIElement = XTPMarkupParseText(m_pTabManager->GetMarkupContext(), lpszCaption);
  104. }
  106. Reposition();
  107. }
  108. }
  109. void CXTPTabManagerItem::SetColor(COLORREF clr)
  110. {
  111. m_clrItem = clr;
  112. m_pTabManager->RedrawControl(GetRect(), FALSE);
  113. }
  115. CString CXTPTabManagerItem::GetCaption() const
  116. {
  117. return m_pTabManager->GetItemCaption(this);
  118. }
  120. CString CXTPTabManagerItem::GetTooltip() const
  121. {
  122. return m_pTabManager->GetItemTooltip(this);
  123. }
  125. COLORREF CXTPTabManagerItem::GetColor()
  126. {
  127. return m_pTabManager->GetItemColor(this);
  128. }
  129. void CXTPTabManagerItem::SetHandle(HWND hWnd)
  130. {
  131. m_hWnd = hWnd;
  132. }
  134. void CXTPTabManagerItem::Remove()
  135. {
  136. m_pTabManager->DeleteItem(m_nIndex);
  137. }
  138. void CXTPTabManagerItem::Select()
  139. {
  140. m_pTabManager->OnItemClick(this);
  141. }
  142. HWND CXTPTabManagerItem::GetHandle() const
  143. {
  144. return m_hWnd;
  145. }
  146. BOOL CXTPTabManagerItem::IsVisible() const
  147. {
  148. return m_bVisible;
  149. }
  151. void CXTPTabManagerItem::SetVisible(BOOL bVisible)
  152. {
  153. if (m_bVisible != bVisible)
  154. {
  155. m_bVisible = bVisible;
  156. Reposition();
  157. }
  158. }
  160. BOOL CXTPTabManagerItem::IsEnabled() const
  161. {
  162. return m_bEnabled;
  163. }
  165. void CXTPTabManagerItem::SetEnabled(BOOL bEnabled)
  166. {
  167. if (m_bEnabled != bEnabled)
  168. {
  169. m_bEnabled = bEnabled;
  170. Reposition();
  171. }
  172. }
  174. void CXTPTabManagerItem::Move(int nIndex)
  175. {
  176. if (GetIndex() != nIndex)
  177. {
  178. m_pTabManager->MoveItem(this, nIndex);
  179. }
  180. }
  182. BOOL CXTPTabManagerItem::DrawRotatedImage(CDC* pDC, CRect rcItem, CXTPImageManagerIcon* pImage)
  183. {
  184. CXTPImageManagerIconHandle& imageHandle = !IsEnabled() ? pImage->GetDisabledIcon(): IsHighlighted() ? pImage->GetHotIcon() :
  185. IsSelected() ? pImage->GetCheckedIcon() : pImage->GetIcon();
  187. const int cx = rcItem.Width();
  188. const int cy = rcItem.Height();
  189. ASSERT(cx == cy);
  190. if (cx != cy)
  191. return FALSE;
  193. UINT* pSrcBits = NULL, *pDestBits = NULL;
  194. HBITMAP hbmSrc = CXTPImageManager::Create32BPPDIBSection(NULL, cx, cy, (LPBYTE*)&pSrcBits);
  195. if (!pSrcBits)
  196. return FALSE;
  198. HBITMAP hbmDest = CXTPImageManager::Create32BPPDIBSection(NULL, cx, cy, (LPBYTE*)&pDestBits);
  199. if (!pDestBits)
  200. return FALSE;
  202. CDC dc;
  203. dc.CreateCompatibleDC(NULL);
  204. HGDIOBJ hbmpOld = ::SelectObject(dc, hbmSrc);
  206. CRect rcDraw(0, 0, cx, cy);
  208. dc.BitBlt(0, 0, cx, cy, pDC, rcItem.left, rcItem.top, SRCCOPY);
  209. ::SelectObject(dc, hbmpOld);
  211. UINT* pSrcInv = pDestBits;
  212. UINT* pDestInv = pSrcBits;
  214. UINT* pDest = &pDestBits[cx];
  215. int i;
  217. for (i = 0; i < cy; i++)
  218. {
  219. pDest -= 1;
  220. pDestBits = pDest;
  221. for (int j = 0; j < cx; j++)
  222. {
  223. *pDestBits = *pSrcBits;
  224. pSrcBits += 1;
  225. pDestBits += cy;
  226. }
  227. }
  230. hbmpOld = ::SelectObject(dc, hbmDest);
  231. pImage->Draw(&dc, rcDraw.TopLeft(), imageHandle, rcDraw.Size());
  232. ::SelectObject(dc, hbmpOld);
  234. pDest = &pDestInv[cx * (cy - 1)];
  236. for (i = 0; i < cy; i++)
  237. {
  238. pDestInv = pDest;
  239. for (int j = 0; j < cx; j++)
  240. {
  241. *pDestInv = *pSrcInv;
  242. pSrcInv += 1;
  243. pDestInv -= cy;
  244. }
  245. pDest += 1;
  246. }
  248. pDC->DrawState(rcItem.TopLeft(), rcItem.Size(), hbmSrc, DST_BITMAP);
  250. DeleteObject(hbmSrc);
  251. DeleteObject(hbmDest);
  253. return TRUE;
  254. }
  256. void CXTPTabManagerItem::DrawImage(CDC* pDC, CRect rcIcon, CXTPImageManagerIcon* pImage)
  257. {
  258. if (rcIcon.Width() == rcIcon.Height() && GetTabManager()->GetPaintManager()->m_bRotateImageOnVerticalDraw
  259. && (GetTabManager()->GetPosition() == xtpTabPositionLeft || GetTabManager()->GetPosition() == xtpTabPositionRight)
  260. && DrawRotatedImage(pDC, rcIcon, pImage))
  261. {
  263. }
  264. else
  265. {
  266. CXTPImageManagerIconHandle& imageHandle = !IsEnabled() ? pImage->GetDisabledIcon(): IsHighlighted() ? pImage->GetHotIcon() :
  267. IsSelected() ? pImage->GetCheckedIcon() : pImage->GetIcon();
  269. pImage->Draw(pDC, rcIcon.TopLeft(), imageHandle, rcIcon.Size());
  270. }
  271. }
  273. void CXTPTabManagerItem::SetRect(CRect rcItem)
  274. {
  275. m_rcItem = rcItem;
  277. for (int i = (int)m_arrNavigateButtons.GetSize() - 1; i >= 0; i--)
  278. {
  279. CXTPTabManagerNavigateButton* pButton = m_arrNavigateButtons.GetAt(i);
  280. pButton->SetRect(CRect(0, 0, 0, 0));
  281. }
  282. }
  284. //////////////////////////////////////////////////////////////////////////
  285. // CXTPTabManagerNavigateButton
  287. CXTPTabManagerNavigateButton::CXTPTabManagerNavigateButton(CXTPTabManager* pManager, UINT nID, XTPTabNavigateButtonFlags dwFlags)
  288. {
  289. m_pManager = pManager;
  290. m_nID = nID;
  291. m_dwFlags = dwFlags;
  293. m_rcButton.SetRectEmpty();
  295. m_bEnabled = TRUE;
  296. m_bPressed = FALSE;
  297. m_pItem = NULL;
  298. }
  300. CXTPTabManagerNavigateButton::~CXTPTabManagerNavigateButton()
  301. {
  302. if (m_pManager->m_pHighlightedNavigateButton == this)
  303. m_pManager->m_pHighlightedNavigateButton = NULL;
  304. }
  306. CSize CXTPTabManagerNavigateButton::GetSize() const
  307. {
  308. return m_pManager->GetPaintManager()->m_szNavigateButton;
  309. }
  311. void CXTPTabManagerNavigateButton::AdjustWidth(int& nWidth)
  312. {
  313. if ((m_dwFlags == xtpTabNavigateButtonAlways) ||
  314. (m_dwFlags == xtpTabNavigateButtonAutomatic && m_pManager->IsNavigateButtonAutomaticVisible(this)))
  315. {
  316. if ((m_pManager->GetPosition() == xtpTabPositionTop) || (m_pManager->GetPosition() == xtpTabPositionBottom))
  317. {
  318. nWidth -= GetSize().cx;
  319. }
  320. else
  321. {
  322. nWidth -= GetSize().cy;
  323. }
  324. }
  325. }
  327. void CXTPTabManagerNavigateButton::SetRect(CRect rcButton)
  328. {
  329. m_rcButton = rcButton;
  330. }
  332. void CXTPTabManagerNavigateButton::Reposition(CRect& rcNavigateButtons)
  333. {
  335. if ((m_dwFlags == xtpTabNavigateButtonAlways) ||
  336. (m_dwFlags == xtpTabNavigateButtonAutomatic && m_pManager->IsNavigateButtonAutomaticVisible(this)))
  337. {
  338. CSize szButton = GetSize();
  340. if (m_pManager->IsHorizontalPosition())
  341. {
  342. m_rcButton.SetRect(rcNavigateButtons.right - szButton.cx, rcNavigateButtons.CenterPoint().y + szButton.cy / 2 - szButton.cy, rcNavigateButtons.right, rcNavigateButtons.CenterPoint().y + szButton.cy / 2);
  343. rcNavigateButtons.right -= szButton.cx;
  344. }
  345. else
  346. {
  347. m_rcButton.SetRect(rcNavigateButtons.CenterPoint().x - szButton.cx / 2, rcNavigateButtons.bottom - szButton.cy, rcNavigateButtons.CenterPoint().x - szButton.cx / 2 + szButton.cx, rcNavigateButtons.bottom);
  348. rcNavigateButtons.bottom -= szButton.cy;
  349. }
  350. }
  351. else
  352. m_rcButton.SetRectEmpty();
  354. }
  356. void CXTPTabManagerNavigateButton::Draw(CDC* pDC)
  357. {
  358. if (!m_rcButton.IsRectEmpty())
  359. {
  360. CRect rc(m_rcButton);
  361. m_pManager->GetPaintManager()->DrawNavigateButton(pDC, this, rc);
  362. }
  363. }
  365. void CXTPTabManagerNavigateButton::PerformClick(HWND hWnd, CPoint pt)
  366. {
  367. if ((::GetCapture() != NULL) || !m_bEnabled)
  368. return;
  370. ::SetCapture(hWnd);
  372. BOOL  bClick = FALSE;
  374. DWORD dwStart = GetTickCount();
  375. for (;;)
  376. {
  377. if (m_bEnabled && GetTickCount() - dwStart > 20)
  378. {
  379. dwStart = GetTickCount();
  380. OnExecute(TRUE);
  381. }
  383. BOOL bPressed = m_rcButton.PtInRect(pt);
  385. if (bPressed != m_bPressed)
  386. {
  387. m_bPressed = bPressed;
  388. m_pManager->RedrawControl(m_rcButton, TRUE);
  389. }
  390. MSG msg;
  392. if (!::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE))
  393. continue;
  395. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  397. if (::GetCapture() != hWnd)
  398. {
  399. DispatchMessage (&msg);
  400. goto ExitLoop;
  401. }
  402. switch (msg.message)
  403. {
  404. case WM_MOUSEMOVE:
  405. pt = CPoint((short signed)LOWORD(msg.lParam), (short signed)HIWORD(msg.lParam));
  406. break;
  408. case WM_LBUTTONUP:
  409. bClick = m_bPressed;
  410. goto ExitLoop;
  412. case WM_KEYDOWN:
  413. if (msg.wParam != VK_ESCAPE)
  414. break;
  416. case WM_CANCELMODE:
  417. case WM_RBUTTONDOWN:
  418. goto ExitLoop;
  420. default:
  421. DispatchMessage (&msg);
  422. break;
  423. }
  424. }
  426. ExitLoop:
  427. ReleaseCapture();
  428. m_bPressed = FALSE;
  429. m_pManager->PerformMouseMove(hWnd, pt);
  430. m_pManager->RedrawControl(NULL, FALSE);
  432. if (bClick)
  433. {
  434. OnExecute(FALSE);
  435. }
  436. }
  438. void CXTPTabManagerNavigateButton::OnExecute(BOOL bTick)
  439. {
  440. if (!bTick)
  441. {
  442. m_pManager->OnNavigateButtonClick(this);
  443. }
  444. }
  446. //////////////////////////////////////////////////////////////////////////
  447. // CXTPTabManager::CRowIndexer
  450. CXTPTabManager::CRowIndexer::CRowIndexer(CXTPTabManager* pManager)
  451. {
  452. m_nRowCount = 0;
  453. m_pRowItems = 0;
  454. m_pManager = pManager;
  456. CreateIndexer(1);
  457. }
  459. CXTPTabManager::CRowIndexer::~CRowIndexer()
  460. {
  461. SAFE_DELETE_AR(m_pRowItems);
  462. }
  464. CXTPTabManager::ROW_ITEMS* CXTPTabManager::CRowIndexer::CreateIndexer(int nRowCount)
  465. {
  466. if (m_nRowCount != nRowCount)
  467. {
  468. SAFE_DELETE_AR(m_pRowItems);
  469. m_pRowItems = new ROW_ITEMS[nRowCount];
  470. m_nRowCount = nRowCount;
  471. }
  473. if (nRowCount > 0)
  474. {
  475. m_pRowItems[0].nFirstItem = 0;
  476. m_pRowItems[0].nLastItem = m_pManager->GetItemCount() - 1;
  477. }
  478. return m_pRowItems;
  479. }
  481. //////////////////////////////////////////////////////////////////////////
  482. // CXTPTabManager::CNavigateButtonArrow
  484. class CXTPTabManager::CNavigateButtonArrow : public CXTPTabManagerNavigateButton
  485. {
  486. protected:
  487. CNavigateButtonArrow(CXTPTabManager* pManager, XTPTabNavigateButton nID, XTPTabNavigateButtonFlags dwFlags)
  488. : CXTPTabManagerNavigateButton(pManager, nID, dwFlags)
  489. {
  490. }
  491. virtual void Reposition(CRect& rcNavigateButtons);
  492. virtual void AdjustWidth(int& nWidth);
  494. };
  496. class CXTPTabManager::CNavigateButtonArrowLeft : public CNavigateButtonArrow
  497. {
  498. public:
  499. CNavigateButtonArrowLeft(CXTPTabManager* pManager, XTPTabNavigateButtonFlags dwFlags)
  500. : CNavigateButtonArrow(pManager, xtpTabNavigateButtonLeft, dwFlags)
  501. {
  502. }
  503. protected:
  504. virtual void DrawEntry(CDC* pDC, CRect rc);
  505. virtual void Reposition(CRect& rcNavigateButtons);
  506. virtual void OnExecute(BOOL bTick);
  507. };
  509. class CXTPTabManager::CNavigateButtonArrowRight : public CNavigateButtonArrow
  510. {
  511. public:
  512. CNavigateButtonArrowRight(CXTPTabManager* pManager, XTPTabNavigateButtonFlags dwFlags)
  513. : CNavigateButtonArrow(pManager, xtpTabNavigateButtonRight, dwFlags)
  514. {
  515. }
  516. protected:
  517. virtual void DrawEntry(CDC* pDC, CRect rc);
  518. virtual void Reposition(CRect& rcNavigateButtons);
  519. virtual void OnExecute(BOOL bTick);
  520. };
  522. class CXTPTabManager::CNavigateButtonClose : public CXTPTabManagerNavigateButton
  523. {
  524. public:
  525. CNavigateButtonClose(CXTPTabManager* pManager, XTPTabNavigateButtonFlags dwFlags)
  526. : CXTPTabManagerNavigateButton(pManager, xtpTabNavigateButtonClose, dwFlags)
  527. {
  528. XTPResourceManager()->LoadString(&m_strToolTip, XTP_IDS_TABNAVIGATEBUTTON_CLOSE);
  529. }
  530. protected:
  531. virtual void DrawEntry(CDC* pDC, CRect rc);
  532. };
  534. class CXTPTabManager::CNavigateButtonTabClose : public CXTPTabManager::CNavigateButtonClose
  535. {
  536. public:
  537. CNavigateButtonTabClose(CXTPTabManagerItem* pItem, XTPTabNavigateButtonFlags dwFlags)
  538. : CXTPTabManager::CNavigateButtonClose(pItem->GetTabManager(), dwFlags)
  539. {
  540. m_pItem = pItem;
  541. }
  542. };
  545. void CXTPTabManager::CNavigateButtonClose::DrawEntry(CDC* pDC, CRect rc)
  546. {
  547. CPoint pt = rc.CenterPoint();
  549. pDC->MoveTo(pt.x - 4, pt.y - 3);
  550. pDC->LineTo(pt.x + 3, pt.y + 4);
  551. pDC->MoveTo(pt.x - 3, pt.y - 3);
  552. pDC->LineTo(pt.x + 4, pt.y + 4);
  554. pDC->MoveTo(pt.x - 4, pt.y + 3);
  555. pDC->LineTo(pt.x + 3, pt.y - 4);
  556. pDC->MoveTo(pt.x - 3, pt.y + 3);
  557. pDC->LineTo(pt.x + 4, pt.y - 4);
  558. }
  560. void CXTPTabManager::CNavigateButtonArrowRight::DrawEntry(CDC* pDC, CRect rc)
  561. {
  562. CPoint pt = rc.CenterPoint();
  564. if (m_pManager->IsHorizontalPosition())
  565. CXTPDrawHelpers::Triangle(pDC, CPoint(pt.x - 2, pt.y - 5), CPoint(pt.x + 2, pt.y - 1), CPoint(pt.x - 2, pt.y + 3));
  566. else
  567. CXTPDrawHelpers::Triangle(pDC, CPoint(pt.x - 5, pt.y - 2), CPoint(pt.x - 1, pt.y + 2), CPoint(pt.x + 3, pt.y - 2));
  568. }
  570. void CXTPTabManager::CNavigateButtonArrow::AdjustWidth(int& nWidth)
  571. {
  572. if (m_dwFlags == xtpTabNavigateButtonAlways)
  573. {
  574. if ((m_pManager->GetPosition() == xtpTabPositionTop) || (m_pManager->GetPosition() == xtpTabPositionBottom))
  575. {
  576. nWidth -= GetSize().cx;
  577. }
  578. else
  579. {
  580. nWidth -= GetSize().cy;
  581. }
  582. }
  583. }
  584. void CXTPTabManager::CNavigateButtonArrow::Reposition(CRect& rcNavigateButtons)
  585. {
  586. if (m_pManager->GetLayout() == xtpTabLayoutMultiRow)
  587. {
  588. m_rcButton.SetRectEmpty();
  589. return;
  590. }
  592. if (m_dwFlags == xtpTabNavigateButtonAutomatic)
  593. {
  594. if (m_pManager->GetLayout() == xtpTabLayoutSizeToFit)
  595. {
  596. m_rcButton.SetRectEmpty();
  597. return;
  598. }
  600. CRect rc = m_pManager->GetAppearanceSet()->GetHeaderMargin();
  602. if (!(m_pManager->GetItemsLength() + m_pManager->GetHeaderOffset() - rc.left - 1 > m_pManager->GetRectLength(rcNavigateButtons) - (rc.left + rc.right)
  603. || m_pManager->GetHeaderOffset() < 0))
  604. {
  605. m_rcButton.SetRectEmpty();
  606. return;
  607. }
  608. }
  610. CXTPTabManagerNavigateButton::Reposition(rcNavigateButtons);
  612. }
  613. void CXTPTabManager::CNavigateButtonArrowRight::Reposition(CRect& rcNavigateButtons)
  614. {
  615. XTPResourceManager()->LoadString(&m_strToolTip, m_pManager->IsHorizontalPosition() ? XTP_IDS_TABNAVIGATEBUTTON_RIGHT : XTP_IDS_TABNAVIGATEBUTTON_DOWN);
  617. CRect rcHeaderMargin = m_pManager->GetPaintManager()->GetAppearanceSet()->GetHeaderMargin();
  619. m_bEnabled = m_pManager->GetItemsLength() + m_pManager->GetHeaderOffset() >
  620. m_pManager->GetRectLength(rcNavigateButtons) - (rcHeaderMargin.left + rcHeaderMargin.right) - 28;
  622. CNavigateButtonArrow::Reposition(rcNavigateButtons);
  623. }
  625. void CXTPTabManager::CNavigateButtonArrowRight::OnExecute(BOOL bTick)
  626. {
  627. if (bTick)
  628. {
  629. m_pManager->OnScrollHeader(TRUE);
  630. }
  631. }
  633. void CXTPTabManager::OnScrollHeader(BOOL bRight)
  634. {
  635. if (bRight)
  636. {
  637. SetHeaderOffset(GetHeaderOffset() - m_nScrollDelta);
  638. }
  639. else
  640. {
  641. SetHeaderOffset(GetHeaderOffset() + m_nScrollDelta);
  642. }
  643. }
  645. void CXTPTabManager::CNavigateButtonArrowLeft::DrawEntry(CDC* pDC, CRect rc)
  646. {
  647. CPoint pt = rc.CenterPoint();
  649. if (m_pManager->IsHorizontalPosition())
  650. CXTPDrawHelpers::Triangle(pDC, CPoint(pt.x + 2, pt.y - 5), CPoint(pt.x - 2, pt.y - 1), CPoint(pt.x + 2, pt.y + 3));
  651. else
  652. CXTPDrawHelpers::Triangle(pDC, CPoint(pt.x - 5, pt.y + 2), CPoint(pt.x - 1, pt.y - 2), CPoint(pt.x + 3, pt.y + 2));
  653. }
  655. void CXTPTabManager::CNavigateButtonArrowLeft::Reposition(CRect& rcNavigateButtons)
  656. {
  657. XTPResourceManager()->LoadString(&m_strToolTip, m_pManager->IsHorizontalPosition() ? XTP_IDS_TABNAVIGATEBUTTON_LEFT : XTP_IDS_TABNAVIGATEBUTTON_UP);
  659. m_bEnabled = m_pManager->GetHeaderOffset() < 0;
  661. CNavigateButtonArrow::Reposition(rcNavigateButtons);
  662. }
  664. void CXTPTabManager::CNavigateButtonArrowLeft::OnExecute(BOOL bTick)
  665. {
  666. if (bTick)
  667. {
  668. m_pManager->OnScrollHeader(FALSE);
  669. }
  670. }
  674. //////////////////////////////////////////////////////////////////////
  675. // CXTPTabManager
  677. CXTPTabManager::CXTPTabManager()
  678. {
  680. m_pSelected = 0;
  681. m_pHighlighted = 0;
  682. m_pPressed = 0;
  684. m_nHeaderOffset = 0;
  686. m_bAllowReorder = TRUE;
  688. m_bActive = TRUE;
  689. m_nScrollDelta = 20;
  691. m_rcHeaderRect.SetRectEmpty();
  692. m_rcControl.SetRectEmpty();
  693. m_rcClient.SetRectEmpty();
  695. m_bCloseItemButton = xtpTabNavigateButtonNone;
  697. m_pHighlightedNavigateButton = NULL;
  699. m_pRowIndexer = new CRowIndexer(this);
  701. m_arrNavigateButtons.Add(new CNavigateButtonArrowLeft(this, xtpTabNavigateButtonAutomatic));
  702. m_arrNavigateButtons.Add(new CNavigateButtonArrowRight(this, xtpTabNavigateButtonAutomatic));
  703. m_arrNavigateButtons.Add(new CNavigateButtonClose(this, xtpTabNavigateButtonNone));
  705. m_pMarkupContext = NULL;
  706. }
  708. CXTPTabManager::~CXTPTabManager()
  709. {
  710. for (int i = 0; i < m_arrItems.GetSize(); i++)
  711. {
  712. CXTPTabManagerItem* pItem = m_arrItems[i];
  713. pItem->OnRemoved();
  714. pItem->InternalRelease();
  715. }
  717. for (int j = 0; j < m_arrNavigateButtons.GetSize(); j++)
  718. delete m_arrNavigateButtons[j];
  720. delete m_pRowIndexer;
  722. XTPMarkupReleaseContext(m_pMarkupContext);
  723. }
  725. void CXTPTabManager::EnableMarkup(BOOL bEnable)
  726. {
  727. BOOL bMarkupContext = m_pMarkupContext != NULL;
  728. if (bMarkupContext == bEnable)
  729. return;
  731. for (int i = 0; i < m_arrItems.GetSize(); i++)
  732. {
  733. XTPMarkupReleaseElement(m_arrItems[i]->m_pMarkupUIElement);
  734. }
  736. XTPMarkupReleaseContext(m_pMarkupContext);
  738. if (bEnable)
  739. {
  740. m_pMarkupContext = XTPMarkupCreateContext();
  741. }
  742. }
  745. void CXTPTabManager::SetActive(BOOL bActive)
  746. {
  747. if (m_bActive != bActive)
  748. {
  749. m_bActive = bActive;
  750. Reposition();
  751. }
  752. }
  754. BOOL CXTPTabManager::IsNavigateButtonAutomaticVisible(CXTPTabManagerNavigateButton* pButton)
  755. {
  756. if (pButton->GetID() == xtpTabNavigateButtonClose)
  757. {
  758. return m_pSelected ? m_pSelected->IsClosable() : FALSE;
  759. }
  761. return TRUE;
  762. }
  764. void CXTPTabManager::EnableTabThemeTexture(HWND hWnd, BOOL bEnable)
  765. {
  766. m_themeTabControl.OpenTheme(hWnd, L"TAB");
  767. m_themeTabControl.EnableThemeDialogTexture(hWnd, bEnable ? ETDT_ENABLETAB : ETDT_DISABLE | ETDT_USETABTEXTURE);
  769. }
  771. CXTPTabManagerNavigateButton* CXTPTabManager::FindNavigateButton(UINT nID) const
  772. {
  773. for (int i = 0; i < m_arrNavigateButtons.GetSize(); i++)
  774. {
  775. if (m_arrNavigateButtons[i]->m_nID == nID)
  776. return m_arrNavigateButtons[i];
  777. }
  779. return NULL;
  780. }
  782. void CXTPTabManager::SetHeaderOffset(int nOffset)
  783. {
  784. if (nOffset > 0) nOffset = 0;
  786. if (nOffset != m_nHeaderOffset)
  787. {
  788. m_nHeaderOffset = nOffset;
  789. Reposition();
  790. }
  791. }
  793. int CXTPTabManager::GetItemsLength() const
  794. {
  795. int nLength = 0;
  797. if (GetLayout() == xtpTabLayoutRotated)
  798. {
  799. nLength = GetPaintManager()->GetAppearanceSet()->GetButtonHeight(this)
  800. * GetItemCount();
  801. }
  802. else
  803. {
  804. for (int i = 0; i < GetItemCount(); i++)
  805. nLength += GetItem(i)->GetButtonLength();
  806. }
  808. return nLength;
  809. }
  812. void CXTPTabManager::DeleteAllItems()
  813. {
  814. for (int i = 0; i < m_arrItems.GetSize(); i++)
  815. {
  816. CXTPTabManagerItem* pItem = m_arrItems[i];
  817. pItem->OnRemoved();
  818. pItem->InternalRelease();
  819. }
  821. m_arrItems.RemoveAll();
  823. m_pHighlighted = m_pSelected = m_pPressed = NULL;
  825. OnItemsChanged();
  826. }
  828. BOOL CXTPTabManager::DeleteItem(int nItem)
  829. {
  830. if (nItem < 0 || nItem >= GetItemCount())
  831. return FALSE;
  833. CXTPTabManagerItem* pItem = m_arrItems[nItem];
  835. BOOL bSelected = (m_pSelected == pItem);
  837. if (m_pHighlighted == pItem)
  838. m_pHighlighted = NULL;
  840. m_arrItems.RemoveAt(nItem);
  842. pItem->OnRemoved();
  843. pItem->InternalRelease();
  845. if (bSelected)
  846. {
  847. SetCurSel(nItem);
  848. }
  851. OnItemsChanged();
  853. return TRUE;
  854. }
  856. CXTPTabManagerItem* CXTPTabManager::AddItem(int nItem, CXTPTabManagerItem* pItem /*= NULL*/)
  857. {
  858. if (!pItem)
  859. pItem = new CXTPTabManagerItem();
  861. pItem->m_pTabManager = this;
  863. if (nItem < 0 || nItem > GetItemCount())
  864. nItem = GetItemCount();
  866. m_arrItems.InsertAt(nItem, pItem);
  867. pItem->m_clrItem = xtpTabColorBlue + (GetPaintManager()->m_nItemColor++ % 8);
  869. if (m_bCloseItemButton != xtpTabNavigateButtonNone)
  870. {
  871. pItem->m_arrNavigateButtons.Add(new CNavigateButtonTabClose(pItem, m_bCloseItemButton));
  872. }
  874. OnItemsChanged();
  876. return pItem;
  877. }
  879. void CXTPTabManager::OnItemsChanged()
  880. {
  881. for (int i = 0; i < GetItemCount(); i++)
  882. {
  883. GetItem(i)->m_nIndex = i;
  884. }
  885. Reposition();
  886. }
  888. CString CXTPTabManager::GetItemCaption(const CXTPTabManagerItem* pItem) const
  889. {
  890. return pItem->m_strCaption;
  891. }
  893. HICON CXTPTabManager::GetItemIcon(const CXTPTabManagerItem* pItem) const
  894. {
  895. return pItem->m_hIcon;
  896. }
  898. void CXTPTabManager::ShowIcons(BOOL bShowIcons)
  899. {
  900. GetPaintManager()->m_bShowIcons = bShowIcons;
  901. Reposition();
  902. }
  904. COLORREF CXTPTabManager::GetItemColor(const CXTPTabManagerItem* pItem) const
  905. {
  906. COLORREF nColor = pItem->m_clrItem;
  908. if (nColor >= xtpTabColorBlue && nColor <= xtpTabColorMagenta)
  909. return CXTPTabPaintManager::GetOneNoteColor((XTPTabOneNoteColor)nColor);
  911. return nColor;
  912. }
  914. void CXTPTabManager::SetCurSel(int nIndex)
  915. {
  916. if (GetItemCount() != 0)
  917. {
  918. nIndex = nIndex < 0 ? 0: nIndex >= GetItemCount() ? GetItemCount() - 1 : nIndex;
  920. SetSelectedItem(GetItem(nIndex));
  921. }
  922. else
  923. {
  924. SetSelectedItem(NULL);
  925. }
  926. }
  928. int CXTPTabManager::GetCurSel() const
  929. {
  930. if (m_pSelected)
  931. {
  932. return m_pSelected->GetIndex();
  933. }
  934. return -1;
  935. }
  937. void CXTPTabManager::SetSelectedItem(CXTPTabManagerItem* pItem)
  938. {
  939. if (m_pSelected != pItem)
  940. {
  941. m_pSelected = pItem;
  942. Reposition();
  943. EnsureVisible(pItem);
  944. }
  945. }
  947. void CXTPTabManager::EnsureVisible(CXTPTabManagerItem* pItem)
  948. {
  949. if (!pItem)
  950. return;
  952. GetPaintManager()->EnsureVisible(this, pItem);
  953. }
  955. void CXTPTabManager::SetPosition(XTPTabPosition tabPosition)
  956. {
  957. GetPaintManager()->m_tabPosition = tabPosition;
  958. Reposition();
  959. }
  961. void CXTPTabManager::SetLayoutStyle(XTPTabLayoutStyle tabLayout)
  962. {
  963. GetPaintManager()->m_tabLayout = tabLayout;
  964. Reposition();
  965. }
  968. CXTPTabManagerItem* CXTPTabManager::HitTest(CPoint point) const
  969. {
  970. if (!m_rcControl.PtInRect(point))
  971. return NULL;
  973. if (!m_rcHeaderRect.IsRectEmpty() && !m_rcHeaderRect.PtInRect(point))
  974. return NULL;
  976. for (int i = 0; i < GetItemCount(); i++)
  977. {
  978. CXTPTabManagerItem* pItem = GetItem(i);
  980. if (pItem->GetRect().PtInRect(point) && pItem->IsEnabled() && pItem->IsVisible())
  981. {
  982. return pItem;
  983. }
  984. }
  985. return NULL;
  986. }
  988. XTPTabPosition CXTPTabManager::GetPosition() const
  989. {
  990. return GetPaintManager()->m_tabPosition;
  991. }
  993. XTPTabLayoutStyle CXTPTabManager::GetLayout() const
  994. {
  995. return GetPaintManager()->m_tabLayout;
  996. }
  998. void CXTPTabManager::MoveItem(CXTPTabManagerItem* pItem, int nIndex)
  999. {
  1000. ASSERT(pItem && pItem->GetTabManager() == this);
  1002. if (!pItem || pItem->GetTabManager() != this)
  1003. return;
  1005. int nOldIndex = pItem->GetIndex();
  1006. if (nOldIndex == nIndex)
  1007. return;
  1009. ASSERT(nOldIndex >= 0);
  1010. ASSERT(nIndex >= 0 && nIndex < GetItemCount());
  1012. if (nIndex < 0 || nIndex >= GetItemCount())
  1013. nIndex = GetItemCount() - 1;
  1015. m_arrItems.RemoveAt(nOldIndex);
  1016. m_arrItems.InsertAt(nIndex, pItem);
  1018. OnItemsChanged();
  1019. }
  1021. void CXTPTabManager::TrackClick(HWND hWnd, CPoint pt, CXTPTabManagerItem* pItem)
  1022. {
  1023. if (GetPaintManager()->m_bHotTracking)
  1024. m_pHighlighted = pItem;
  1026. m_pPressed = pItem;
  1027. BOOL bHighlighted = TRUE;
  1029. Reposition();
  1030. BOOL bAccept = FALSE;
  1032. ::SetCapture(hWnd);
  1034. while (::GetCapture() == hWnd)
  1035. {
  1036. MSG msg;
  1037. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1039. if (::GetCapture() != hWnd)
  1040. {
  1041. DispatchMessage (&msg);
  1042. break;
  1043. }
  1044. switch (msg.message)
  1045. {
  1046. case WM_MOUSEMOVE:
  1047. {
  1048. pt = CPoint((short signed)LOWORD(msg.lParam), (short signed)HIWORD(msg.lParam));
  1050. bHighlighted = pItem->GetRect().PtInRect(pt);
  1052. if (GetPaintManager()->m_bHotTracking)
  1053. {
  1054. CXTPTabManagerItem* pHighlighted = bHighlighted ? pItem : NULL;
  1055. if (pHighlighted != m_pHighlighted)
  1056. {
  1057. m_pHighlighted = pHighlighted;
  1058. RedrawControl(pItem->GetRect(), TRUE);
  1059. }
  1060. }
  1062. }
  1064. break;
  1066. case WM_KEYDOWN:
  1067. if (msg.wParam != VK_ESCAPE)
  1068. break;
  1069. case WM_CANCELMODE:
  1070. case WM_RBUTTONDOWN:
  1071. goto ExitLoop;
  1073. case WM_LBUTTONUP:
  1074. bAccept = TRUE;
  1075. goto ExitLoop;
  1077. default:
  1078. DispatchMessage (&msg);
  1079. break;
  1080. }
  1081. }
  1083. ExitLoop:
  1084. ReleaseCapture();
  1086. m_pPressed = FALSE;
  1088. PerformMouseMove(hWnd, pt);
  1090. RedrawControl(NULL, FALSE);
  1092. if (bAccept && bHighlighted)
  1093. {
  1094. OnItemClick(pItem);
  1095. }
  1096. }
  1098. void CXTPTabManager::ReOrder(HWND hWnd, CPoint pt, CXTPTabManagerItem* pItem)
  1099. {
  1100. CXTPTabManagerItem* pSelected = m_pSelected;
  1101. m_pSelected = pItem;
  1103. if (GetPaintManager()->m_bHotTracking)
  1104. m_pHighlighted = pItem;
  1106. Reposition();
  1108. CArray<CRect, CRect&> arrRects;
  1110. for (int j = 0; j < GetItemCount(); j++)
  1111. {
  1112. CRect rc = GetItem(j)->GetRect();
  1113. arrRects.Add(rc);
  1114. }
  1116. ::SetCapture(hWnd);
  1118. while (::GetCapture() == hWnd)
  1119. {
  1120. MSG msg;
  1121. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  1123. if (::GetCapture() != hWnd)
  1124. {
  1125. DispatchMessage (&msg);
  1126. break;
  1127. }
  1128. switch (msg.message)
  1129. {
  1130. case WM_MOUSEMOVE:
  1131. {
  1132. pt = CPoint((short signed)LOWORD(msg.lParam), (short signed)HIWORD(msg.lParam));
  1134. for (int i = 0; i < arrRects.GetSize(); i++)
  1135. {
  1136. if (i != pItem->GetIndex() && arrRects[i].PtInRect(pt))
  1137. {
  1139. CXTPTabManagerItem* p = pItem;
  1140. m_arrItems[pItem->GetIndex()] = m_arrItems[i];
  1141. m_arrItems[i] = p;
  1143. OnItemsChanged();
  1144. break;
  1145. }
  1146. }
  1147. }
  1149. break;
  1151. case WM_KEYDOWN:
  1152. if (msg.wParam != VK_ESCAPE)
  1153. break;
  1154. case WM_CANCELMODE:
  1155. case WM_LBUTTONUP:
  1156. case WM_RBUTTONDOWN:
  1157. goto ExitLoop;
  1159. default:
  1160. DispatchMessage (&msg);
  1161. break;
  1162. }
  1163. }
  1165. ExitLoop:
  1166. ReleaseCapture();
  1167. PerformMouseMove(hWnd, pt);
  1169. m_pSelected = pSelected;
  1170. OnItemClick(pItem);
  1171. }
  1173. void CXTPTabManager::OnItemClick(CXTPTabManagerItem* pItem)
  1174. {
  1175. SetSelectedItem(pItem);
  1176. }
  1178. void CXTPTabManager::SetFocusedItem(CXTPTabManagerItem* pItem)
  1179. {
  1180. if (!OnBeforeItemClick(pItem))
  1181. return;
  1183. if (pItem)
  1184. {
  1185. OnItemClick(pItem);
  1186. }
  1187. }
  1189. CXTPTabManagerItem* CXTPTabManager::FindNextFocusable(int nIndex, int nDirection) const
  1190. {
  1191. CXTPTabManagerItem* pItem = NULL;
  1193. do
  1194. {
  1195. nIndex += nDirection;
  1197. pItem = GetItem(nIndex);
  1198. if (!pItem)
  1199. return NULL;
  1201. }
  1202. while (!(pItem->IsVisible() && pItem->IsEnabled()));
  1204. return pItem;
  1205. }
  1207. BOOL CXTPTabManager::PerformKeyDown(HWND hWnd, UINT nChar)
  1208. {
  1209. const int nCount = GetItemCount();
  1210. if (nCount < 1)
  1211. return FALSE;
  1213. if (nChar == VK_LEFT && (DWORD)GetWindowLong(hWnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL)
  1214. nChar = VK_RIGHT;
  1215. else if (nChar == VK_RIGHT && (DWORD)GetWindowLong(hWnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL)
  1216. nChar = VK_LEFT;
  1218. switch (nChar)
  1219. {
  1220. case VK_HOME:
  1221. SetFocusedItem(FindNextFocusable(-1, +1));
  1222. return TRUE;
  1224. case VK_END:
  1225. SetFocusedItem(FindNextFocusable(nCount, -1));
  1226. return TRUE;
  1228. case VK_LEFT:
  1229. if (IsHorizontalPosition() && m_pSelected && m_pSelected->GetIndex() > 0)
  1230. SetFocusedItem(FindNextFocusable(m_pSelected->GetIndex(), -1));
  1231. return TRUE;
  1233. case VK_UP:
  1234. if (!IsHorizontalPosition() && m_pSelected && m_pSelected->GetIndex() > 0)
  1235. SetFocusedItem(FindNextFocusable(m_pSelected->GetIndex(), -1));
  1236. return TRUE;
  1238. case VK_RIGHT:
  1239. if (IsHorizontalPosition() && m_pSelected && m_pSelected->GetIndex() < nCount - 1)
  1240. SetFocusedItem(FindNextFocusable(m_pSelected->GetIndex(), + 1));
  1241. return TRUE;
  1243. case VK_DOWN:
  1244. if (!IsHorizontalPosition() && m_pSelected && m_pSelected->GetIndex() < nCount - 1)
  1245. SetFocusedItem(FindNextFocusable(m_pSelected->GetIndex(), + 1));
  1246. return TRUE;
  1247. }
  1248. return FALSE;
  1249. }
  1251. BOOL CXTPTabManager::OnBeforeItemClick(CXTPTabManagerItem* /*pItem*/)
  1252. {
  1253. return TRUE;
  1254. }
  1257. CXTPTabManagerNavigateButton* CXTPTabManager::HitTestNavigateButton(CPoint point, BOOL bHeaderOnly, int* pnIndex) const
  1258. {
  1259. int i;
  1260. for (i = 0; i < (int)m_arrNavigateButtons.GetSize(); i++)
  1261. {
  1262. CXTPTabManagerNavigateButton* pButton = m_arrNavigateButtons[i];
  1263. if (pButton->m_rcButton.PtInRect(point))
  1264. {
  1265. if (!pButton->IsEnabled())
  1266. return NULL;
  1268. if (pnIndex)
  1269. {
  1270. *pnIndex = i;
  1271. }
  1272. return pButton;
  1273. }
  1274. }
  1276. if (bHeaderOnly)
  1277. return NULL;
  1279. CXTPTabManagerItem* pItem = HitTest(point);
  1280. if (!pItem)
  1281. return NULL;
  1283. for (i = 0; i < (int)pItem->GetNavigateButtons()->GetSize(); i++)
  1284. {
  1285. CXTPTabManagerNavigateButton* pButton = pItem->GetNavigateButtons()->GetAt(i);
  1286. if (pButton->m_rcButton.PtInRect(point))
  1287. {
  1288. if (!pButton->IsEnabled())
  1289. return NULL;
  1291. if (pnIndex)
  1292. {
  1293. *pnIndex = i;
  1294. }
  1295. return pButton;
  1296. }
  1297. }
  1299. return NULL;
  1300. }
  1302. BOOL CXTPTabManager::PerformClick(HWND hWnd, CPoint pt, BOOL bNoItemClick)
  1303. {
  1304. CXTPTabManagerNavigateButton* pNavigateButton = HitTestNavigateButton(pt, FALSE);
  1305. if (pNavigateButton)
  1306. {
  1307. pNavigateButton->PerformClick(hWnd, pt);
  1308. return TRUE;
  1309. }
  1311. if (bNoItemClick)
  1312. return FALSE;
  1314. CXTPTabManagerItem* pItem = HitTest(pt);
  1316. if (pItem)
  1317. {
  1318. if (!OnBeforeItemClick(pItem))
  1319. return FALSE;
  1321. if (IsAllowReorder())
  1322. {
  1323. ReOrder(hWnd, pt, pItem);
  1324. }
  1325. else if (GetPaintManager()->m_bSelectOnButtonDown)
  1326. {
  1327. OnItemClick(pItem);
  1328. }
  1329. else
  1330. {
  1331. TrackClick(hWnd, pt, pItem);
  1332. }
  1333. return TRUE;
  1334. }
  1336. return FALSE;
  1337. }
  1340. void CXTPTabManager::PerformMouseMove(HWND hWnd, CPoint pt)
  1341. {
  1342.  CXTPTabPaintManager::CAppearanceSet* pAppearance = GetPaintManager()->GetAppearanceSet();
  1344.  if (!CXTPDrawHelpers::IsTopParentActive(hWnd) || IsMouseLocked())
  1345. {
  1346. if (m_pHighlighted)
  1347. {
  1348. CRect rcRedraw(pAppearance->GetButtonDrawRect(m_pHighlighted));
  1349. m_pHighlighted = NULL;
  1351. RedrawControl(rcRedraw, TRUE);
  1352. }
  1353. return;
  1354. }
  1356. if (GetPaintManager()->m_bHotTracking)
  1357. {
  1358. CXTPTabManagerItem* pItem = HitTest(pt);
  1360. if (pItem != m_pHighlighted)
  1361. {
  1362. if (m_pHighlighted)
  1363. {
  1364. CRect rcRedraw(pAppearance->GetButtonDrawRect(m_pHighlighted));
  1365. m_pHighlighted = NULL;
  1367. RedrawControl(rcRedraw, TRUE);
  1368. }
  1370. m_pHighlighted = pItem;
  1372. if (m_pHighlighted)
  1373. {
  1374. RedrawControl(pAppearance->GetButtonDrawRect(m_pHighlighted), FALSE);
  1375. }
  1377. if (pItem)
  1378. {
  1379. TRACKMOUSEEVENT tme =
  1380. {
  1381. sizeof(TRACKMOUSEEVENT), TME_LEAVE, hWnd
  1382. };
  1383. _TrackMouseEvent(&tme);
  1384. }
  1385. }
  1386. }
  1388. CXTPTabManagerNavigateButton* pNavigateButton = HitTestNavigateButton(pt, FALSE);
  1390. if (pNavigateButton != m_pHighlightedNavigateButton)
  1391. {
  1392. if (m_pHighlightedNavigateButton)
  1393. {
  1394. RedrawControl(m_pHighlightedNavigateButton->GetRect(), TRUE);
  1395. }
  1397. m_pHighlightedNavigateButton = pNavigateButton;
  1399. if (m_pHighlightedNavigateButton)
  1400. {
  1401. RedrawControl(m_pHighlightedNavigateButton->GetRect(), FALSE);
  1402. }
  1404. if (pNavigateButton)
  1405. {
  1406. TRACKMOUSEEVENT tme =
  1407. {
  1408. sizeof(TRACKMOUSEEVENT), TME_LEAVE, hWnd
  1409. };
  1410. _TrackMouseEvent(&tme);
  1411. }
  1412. }
  1413. }
  1415. CString CXTPTabManager::GetItemTooltip(const CXTPTabManagerItem* pItem) const
  1416. {
  1417. return pItem->m_strToolTip;
  1418. }
  1420. INT_PTR CXTPTabManager::PerformToolHitTest(HWND hWnd, CPoint point, TOOLINFO* pTI) const
  1421. {
  1422. if (IsMouseLocked())
  1423. return -1;
  1425. int nIndex = -1;
  1426. CXTPTabManagerNavigateButton* pNavigateButton = HitTestNavigateButton(point, FALSE, &nIndex);
  1427. if (pNavigateButton)
  1428. {
  1429. ASSERT(nIndex != -1);
  1430. CString strTip = pNavigateButton->GetTooltip();
  1431. if (strTip.IsEmpty())
  1432. return -1;
  1434. CXTPToolTipContext::FillInToolInfo(pTI, hWnd, pNavigateButton->GetRect(), nIndex, strTip);
  1436. return nIndex;
  1437. }
  1439. CXTPTabManagerItem* pItem = HitTest(point);
  1441. if (pItem)
  1442. {
  1443. if (GetPaintManager()->m_toolBehaviour == xtpTabToolTipNever)
  1444. return -1;
  1446. if (GetPaintManager()->m_toolBehaviour == xtpTabToolTipShrinkedOnly && !pItem->IsItemShrinked())
  1447. return -1;
  1449. CString strTip = GetItemTooltip(pItem);
  1450. if (strTip.IsEmpty())
  1451. return -1;
  1453. CXTPToolTipContext::FillInToolInfo(pTI, hWnd, pItem->GetRect(), pItem->GetIndex(), strTip, pItem->GetCaption(), strTip);
  1455. return pItem->GetIndex();
  1456. }
  1457. return -1;
  1458. }
  1460. void CXTPTabManager::GetItemMetrics(CSize* lpszNormal, CSize* lpszMin /*= NULL*/, CSize* lpszMax /*= NULL*/) const
  1461. {
  1462. CXTPTabPaintManager* pPaintManager = GetPaintManager();
  1463. if (lpszNormal) *lpszNormal = CSize(pPaintManager->m_nFixedTabWidth, 0);
  1464. if (lpszMin) *lpszMin = CSize(pPaintManager->m_nMinTabWidth, 0);
  1465. if (lpszMax) *lpszMax = CSize(pPaintManager->m_nMaxTabWidth, 0);
  1466. }
  1468. void CXTPTabManager::SetItemMetrics(CSize szNormal, CSize szMin /*= CSize(0, 0)*/, CSize szMax /*= CSize(0, 0)*/)
  1469. {
  1470. CXTPTabPaintManager* pPaintManager = GetPaintManager();
  1471. pPaintManager->m_nFixedTabWidth = szNormal.cx;
  1472. pPaintManager->m_nMinTabWidth = szMin.cx;
  1473. pPaintManager->m_nMaxTabWidth = szMax.cx;
  1475. Reposition();
  1476. }
  1478. BOOL CXTPTabManager::IsDrawStaticFrame() const
  1479. {
  1480. return GetPaintManager()->m_bStaticFrame;
  1481. }
  1484. CXTPTabPaintManager::CColorSet* CXTPTabManager::SetColor(XTPTabColorStyle tabColor)
  1485. {
  1486. CXTPTabPaintManager::CColorSet* pColorSet = GetPaintManager()->SetColor(tabColor);
  1487. Reposition();
  1488. return pColorSet;
  1489. }
  1491. CXTPTabPaintManager::CColorSet* CXTPTabManager::SetColorSet(CXTPTabPaintManager::CColorSet* pColorSet)
  1492. {
  1493. GetPaintManager()->SetColorSet(pColorSet);
  1494. Reposition();
  1495. return pColorSet;
  1496. }
  1497. CXTPTabPaintManager::CAppearanceSet* CXTPTabManager::SetAppearance(XTPTabAppearanceStyle tabAppearance)
  1498. {
  1499. CXTPTabPaintManager::CAppearanceSet* pAppearanceSet = GetPaintManager()->SetAppearance(tabAppearance);
  1500. Reposition();
  1501. return pAppearanceSet;
  1502. }
  1503. CXTPTabPaintManager::CAppearanceSet* CXTPTabManager::SetAppearanceSet(CXTPTabPaintManager::CAppearanceSet* pAppearanceSet)
  1504. {
  1505. GetPaintManager()->SetAppearanceSet(pAppearanceSet);
  1506. Reposition();
  1507. return pAppearanceSet;
  1508. }