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

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

对话框与窗口

开发平台：

Visual C++

XTPTabPaintManager.cpp：源码内容
  1. // XTPTabPaintManager.cpp: implementation of the CXTPTabPaintManager 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 "Common/XTPVC80Helpers.h"
  23. #include "Common/XTPSystemHelpers.h"
  24. #include "Common/XTPMarkupRender.h"
  26. #include "XTPTabPaintManager.h"
  27. #include "XTPTabManager.h"
  28. #include "Common/XTPColorManager.h"
  29. #include "Common/XTPDrawHelpers.h"
  30. #include "XTPTabPaintManager.inl"
  32. #ifdef _DEBUG
  33. #undef THIS_FILE
  34. static char THIS_FILE[] = __FILE__;
  35. #define new DEBUG_NEW
  36. #endif
  38. //////////////////////////////////////////////////////////////////////
  39. // CXTPTabPaintManager
  42. CXTPTabPaintManager::CXTPTabPaintManager()
  43. {
  44. m_bUseStandardFont = TRUE;
  46. m_pColorSet = NULL;
  47. m_pAppearanceSet = NULL;
  49. SetAppearance(xtpTabAppearancePropertyPage);
  51. m_bHotTracking = FALSE;
  52. m_bBoldNormal = m_bBoldSelected = FALSE;
  53. m_bShowIcons = TRUE;
  54. m_bSelectOnButtonDown = TRUE;
  56. m_bDisableLunaColors = FALSE;
  57. m_bOneNoteColors = FALSE;
  59. m_tabPosition = xtpTabPositionTop;
  60. m_tabLayout = xtpTabLayoutAutoSize;
  62. m_clientFrame = xtpTabFrameBorder;
  63. m_bStaticFrame = FALSE;
  65. m_bInvertGradient = FALSE;
  66. m_bFillBackground = TRUE;
  67. m_bDrawFocusRect = TRUE;
  69. m_rcClientMargin.SetRect(0, 0, 0, 0);
  70. m_rcControlMargin.SetRect(0, 0, 0, 0);
  71. m_rcButtonMargin.SetRect(0, 0, 0, 0);
  73. m_nButtonExtraLength = 0;
  74. m_szIcon = CSize(16, 16);
  76. m_nFixedTabWidth = 70;
  77. m_nMinTabWidth = m_nMaxTabWidth = 0;
  80. m_bDrawTextEndEllipsis = TRUE;
  81. m_bDrawTextPathEllipsis = FALSE;
  82. m_bDrawTextNoPrefix = TRUE;
  83. m_bDrawTextHidePrefix = FALSE;
  85. m_bMultiRowFixedSelection = FALSE;
  86. m_bMultiRowJustified = TRUE;
  88. m_toolBehaviour = xtpTabToolTipShrinkedOnly;
  89. m_bSelectOnDragOver = TRUE;
  90. m_nItemColor = 0;
  92. m_bClearTypeTextQuality = FALSE;
  93. m_bRotateImageOnVerticalDraw = FALSE;
  95. m_rcButtonTextPadding.SetRect(6, 0, 6, 0);
  97. m_bClipHeader = TRUE;
  99. m_nDrawTextFormat = DT_LEFT | DT_VCENTER;
  101. m_szNavigateButton = CSize(14, 15);
  103. m_bShowTabs = TRUE;
  105. EnableAutomation();
  109. RefreshMetrics();
  110. }
  112. CXTPTabPaintManager::~CXTPTabPaintManager()
  113. {
  114. delete m_pColorSet;
  115. delete m_pAppearanceSet;
  117. }
  119. CXTPTabPaintManager::CColorSet* CXTPTabPaintManager::SetColor(XTPTabColorStyle tabColor)
  120. {
  121. CColorSet* pColorSet = NULL;
  123. m_tabColor = tabColor;
  124. if (tabColor == xtpTabColorVisualStudio) pColorSet = new CColorSetVisualStudio();
  125. else if (tabColor == xtpTabColorOffice2003) pColorSet = new CColorSetOffice2003();
  126. else if (tabColor == xtpTabColorWinXP) pColorSet = new CColorSetWinXP();
  127. else if (tabColor == xtpTabColorWhidbey) pColorSet = new CColorSetWhidbey();
  128. else if (tabColor == xtpTabColorVisualStudio2008) pColorSet = new CColorSetVisualStudio2008();
  129. else if (tabColor == xtpTabColorOffice2007) pColorSet = new CColorSetOffice2007();
  130. else if (tabColor == xtpTabColorAccess2007) pColorSet = new CColorSetAccess2007();
  131. else pColorSet = new CColorSetDefault();
  133. return SetColorSet(pColorSet);
  134. }
  135. CXTPTabPaintManager::CColorSet* CXTPTabPaintManager::SetColorSet(CColorSet* pColorSet)
  136. {
  137. if (pColorSet)
  138. {
  139. if (m_pColorSet) delete m_pColorSet;
  140. m_pColorSet = pColorSet;
  142. pColorSet->m_pPaintManager = this;
  143. pColorSet->RefreshMetrics();
  144. }
  145. OnPropertyChanged();
  147. return pColorSet;
  148. }
  150. CXTPTabPaintManager::CAppearanceSet* CXTPTabPaintManager::SetAppearance(XTPTabAppearanceStyle tabAppearance)
  151. {
  152. CAppearanceSet* pAppearanceSet = NULL;
  154. m_tabAppearance = tabAppearance;
  155. if (tabAppearance == xtpTabAppearanceVisualStudio) pAppearanceSet = new CAppearanceSetVisualStudio();
  156. else if (tabAppearance == xtpTabAppearanceExcel) pAppearanceSet = new CAppearanceSetExcel();
  157. else if (tabAppearance == xtpTabAppearancePropertyPageFlat) pAppearanceSet = new CAppearanceSetPropertyPageFlat();
  158. else if (tabAppearance == xtpTabAppearanceFlat) pAppearanceSet = new CAppearanceSetFlat();
  159. else if (tabAppearance == xtpTabAppearanceStateButtons) pAppearanceSet = new CAppearanceSetStateButtons();
  160. else if (tabAppearance == xtpTabAppearancePropertyPageSelected) pAppearanceSet = new CAppearanceSetPropertyPageSelected();
  161. else if (tabAppearance == xtpTabAppearancePropertyPage2003) pAppearanceSet = new CAppearanceSetPropertyPage2003();
  162. else if (tabAppearance == xtpTabAppearanceVisio) pAppearanceSet = new CAppearanceSetVisio();
  163. else if (tabAppearance == xtpTabAppearanceVisualStudio2005) pAppearanceSet = new CAppearanceSetVisualStudio2005();
  164. else if (tabAppearance == xtpTabAppearancePropertyPage2007) pAppearanceSet = new CAppearanceSetPropertyPage2007();
  165. else if (tabAppearance == xtpTabAppearancePropertyPageAccess2007) pAppearanceSet = new CAppearanceSetPropertyPageAccess2007();
  166. else pAppearanceSet = new CAppearanceSetPropertyPage();
  168. return SetAppearanceSet(pAppearanceSet);
  170. }
  171. CXTPTabPaintManager::CAppearanceSet* CXTPTabPaintManager::SetAppearanceSet(CAppearanceSet* pAppearanceSet)
  172. {
  173. if (pAppearanceSet)
  174. {
  175. if (m_pAppearanceSet) delete m_pAppearanceSet;
  176. m_pAppearanceSet = pAppearanceSet;
  178. pAppearanceSet->m_pPaintManager = this;
  179. pAppearanceSet->RefreshMetrics();
  181. SetColor(pAppearanceSet->GetDefaultColorSet());
  182. }
  183. OnPropertyChanged();
  185. return pAppearanceSet;
  187. }
  190. void CXTPTabPaintManager::SetFontIndirect(LOGFONT* pLogFont, BOOL bUseStandardFont /*= FALSE*/)
  191. {
  192. m_bUseStandardFont = bUseStandardFont;
  194. if (!pLogFont)
  195. return;
  197. if (m_bClearTypeTextQuality && XTPSystemVersion()->IsClearTypeTextQualitySupported())
  198. {
  199. pLogFont->lfQuality = 5;
  200. }
  202. m_fntNormal.DeleteObject();
  203. m_fntBold.DeleteObject();
  204. m_fntVerticalNormal.DeleteObject();
  205. m_fntVerticalBold.DeleteObject();
  207. pLogFont->lfWeight = m_bBoldNormal ? FW_BOLD : FW_NORMAL;
  208. VERIFY(m_fntNormal.CreateFontIndirect(pLogFont));
  210. pLogFont->lfWeight = FW_BOLD;
  211. VERIFY(m_fntBold.CreateFontIndirect(pLogFont));
  213. STRCPY_S(pLogFont->lfFaceName, LF_FACESIZE, CXTPDrawHelpers::GetVerticalFontName(FALSE));
  214. pLogFont->lfOrientation = 900;
  215. pLogFont->lfEscapement = 2700;
  216. pLogFont->lfHeight = pLogFont->lfHeight < 0 ? __min(-11, pLogFont->lfHeight) : pLogFont->lfHeight;
  217. pLogFont->lfWeight = m_bBoldNormal ? FW_BOLD : FW_NORMAL;
  218. VERIFY(m_fntVerticalNormal.CreateFontIndirect(pLogFont));
  220. pLogFont->lfWeight = FW_BOLD;
  221. VERIFY(m_fntVerticalBold.CreateFontIndirect(pLogFont));
  222. }
  224. void CXTPTabPaintManager::RefreshMetrics()
  225. {
  226. if (m_bUseStandardFont)
  227. {
  228. LOGFONT lfIcon;
  229. VERIFY(::SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lfIcon), &lfIcon, 0));
  231. SetFontIndirect(&lfIcon, TRUE);
  232. }
  234. m_pColorSet->RefreshMetrics();
  235. m_pAppearanceSet->RefreshMetrics();
  236. }
  238. void CXTPTabPaintManager::DisableLunaColors(BOOL bDisableLunaColors)
  239. {
  240. m_bDisableLunaColors = bDisableLunaColors;
  241. RefreshMetrics();
  242. OnPropertyChanged();
  243. }
  244. BOOL CXTPTabPaintManager::IsLunaColorsDisabled() const
  245. {
  246. return m_bDisableLunaColors || XTPColorManager()->IsLunaColorsDisabled();
  247. }
  249. COLORREF CXTPTabPaintManager::GetOneNoteColor(XTPTabOneNoteColor tabColor)
  250. {
  251. const COLORREF clrTable[] =
  252. {
  253. RGB(138, 168, 228), // xtpTabColorBlue    : Blue tab color used when OneNote colors enabled.
  254. RGB(255, 219, 117), // xtpTabColorYellow  : Yellow tab color used when OneNote colors enabled.
  255. RGB(189, 205, 159), // xtpTabColorGreen   : Green tab color used when OneNote colors enabled.
  256. RGB(240, 158, 159), // xtpTabColorRed     : Red tab color used when OneNote colors enabled.
  257. RGB(186, 166, 225), // xtpTabColorPurple  : Purple tab color used when OneNote colors enabled.
  258. RGB(154, 191, 180), // xtpTabColorCyan    : Cyan tab color used when OneNote colors enabled.
  259. RGB(247, 182, 131), // xtpTabColorOrange  : Orange tab color used when OneNote colors enabled.
  260. RGB(216, 171, 192)  // xtpTabColorMagenta : Magenta tab color used when OneNote colors enabled.
  261. };
  263. return clrTable[tabColor-xtpTabColorBlue];
  264. }
  266. void CXTPTabPaintManager::SetOneNoteColors(BOOL bOneNoteColors /* = TRUE */)
  267. {
  268. m_bOneNoteColors = bOneNoteColors;
  269. RefreshMetrics();
  270. }
  272. void CXTPTabPaintManager::DrawNavigateButton(CDC* pDC, CXTPTabManagerNavigateButton* pButton, CRect& rc)
  273. {
  274. FillNavigateButton(pDC, pButton, rc);
  276. COLORREF clr = pDC->GetTextColor();
  277. CXTPPenDC pen(*pDC, clr);
  279. if (pButton->IsEnabled())
  280. {
  281. CXTPBrushDC brush(*pDC, clr);
  282. pButton->DrawEntry(pDC, rc);
  283. }
  284. else
  285. {
  286. CBrush* pOldBrush = (CBrush*)pDC->SelectStockObject(NULL_BRUSH);
  287. pButton->DrawEntry(pDC, rc);
  288. pDC->SelectObject(pOldBrush);
  289. }
  291. }
  293. void CXTPTabPaintManager::FillNavigateButton(CDC* pDC, CXTPTabManagerNavigateButton* pButton, CRect& rc)
  294. {
  295. m_pColorSet->FillNavigateButton(pDC, pButton, rc);
  296. }
  298. void CXTPTabPaintManager::DrawTabControl(CXTPTabManager* pTabManager, CDC* pDC, CRect rcClient)
  299. {
  300. m_pAppearanceSet->DrawTabControl(pTabManager, pDC, rcClient);
  301. }
  303. void CXTPTabPaintManager::DrawRowItems(CXTPTabManager* pTabManager, CDC* pDC, const CRect& rcClipBox, int nItemRow)
  304. {
  305. CXTPTabManagerItem* pSelected = NULL;
  307. CXTPTabManager::ROW_ITEMS* pRowItems = pTabManager->m_pRowIndexer->GetRowItems();
  309. if (!pRowItems)
  310. return;
  312. if (nItemRow >= pTabManager->GetRowCount())
  313. return;
  315. int nFirstItem = pRowItems[nItemRow].nFirstItem;
  316. int nLastItem = pRowItems[nItemRow].nLastItem;
  317. BOOL bDrawRow = TRUE;
  319. if (m_pAppearanceSet->m_bButtonsReverseZOrder)
  320. {
  321. bDrawRow = FALSE;
  323. for (int i = nFirstItem; i <= nLastItem; i++)
  324. {
  325. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  326. if (!pItem)
  327. return;
  329. if (pItem->m_nItemRow != nItemRow)
  330. break;
  332. if (pItem->IsSelected())
  333. {
  334. nFirstItem = i;
  335. bDrawRow = TRUE;
  336. break;
  337. }
  339. if (pItem->IsVisible() && CRect().IntersectRect(rcClipBox, m_pAppearanceSet->GetButtonDrawRect(pItem)))
  340. {
  341. m_pAppearanceSet->DrawSingleButton(pDC, pItem);
  342. }
  343. }
  344. }
  346. if (bDrawRow)
  347. {
  348. for (int i = nLastItem; i >= nFirstItem; i--)
  349. {
  350. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  351. if (!pItem)
  352. return;
  354. if (pItem->m_nItemRow != nItemRow)
  355. break;
  357. if (pItem->IsVisible() && CRect().IntersectRect(rcClipBox, m_pAppearanceSet->GetButtonDrawRect(pItem)))
  358. {
  359. if (pItem->IsSelected())
  360. pSelected = pItem;
  361. else
  362. m_pAppearanceSet->DrawSingleButton(pDC, pItem);
  363. }
  364. }
  365. }
  368. if (pSelected)
  369. {
  370. m_pAppearanceSet->DrawSingleButton(pDC, pSelected);
  371. }
  374. }
  376. void CXTPTabPaintManager::DrawTabControlEx(CXTPTabManager* pTabManager, CDC* pDC, CRect rcClient)
  377. {
  378. if (pTabManager->IsDrawStaticFrame())
  379. {
  380. pDC->Draw3dRect(rcClient, GetColorSet()->m_clrFrameBorder, GetColorSet()->m_clrFrameBorder);
  381. CAppearanceSet::DeflateRectEx(rcClient, CRect(1, 1, 1, 1), pTabManager->GetPosition());
  382. pDC->Draw3dRect(rcClient, GetColorSet()->m_clrControlFace, GetColorSet()->m_clrControlFace);
  383. CAppearanceSet::DeflateRectEx(rcClient, CRect(1, 0, 1, 1), pTabManager->GetPosition());
  384. }
  386. if (m_bFillBackground)
  387. {
  388. pDC->FillSolidRect(rcClient, GetColorSet()->m_clrControlFace);
  389. }
  391. CAppearanceSet::DeflateRectEx(rcClient, m_rcControlMargin, pTabManager->GetPosition());
  393. pDC->SetBkMode(TRANSPARENT);
  396. if (m_bFillBackground)
  397. {
  398. m_pAppearanceSet->FillTabControl(pTabManager, pDC, rcClient);
  399. }
  401. int i;
  403. CRect rcClipBox;
  404. pDC->GetClipBox(rcClipBox);
  406. if (m_bClipHeader)
  407. rcClipBox.IntersectRect(rcClipBox, pTabManager->m_rcHeaderRect);
  409. if (!rcClipBox.IsRectEmpty())
  410. {
  411. CRgn rgn;
  412. if (m_bClipHeader)
  413. {
  414. CRect rcClipBoxViewport(rcClipBox);
  415. rcClipBoxViewport.OffsetRect(-pDC->GetWindowOrg());
  417. rgn.CreateRectRgnIndirect(rcClipBoxViewport);
  418. pDC->SelectClipRgn(&rgn);
  420. m_pColorSet->SelectClipRgn(pDC, rcClient, pTabManager);
  421. }
  423. int nRowCont = pTabManager->GetRowCount();
  425. for (int j = nRowCont - 1; j >= 0; j--)
  426. {
  427. DrawRowItems(pTabManager, pDC, rcClipBox, j);
  428. }
  430. if (m_bClipHeader)
  431. {
  432. pDC->SelectClipRgn(NULL);
  433. }
  434. }
  436. for (i = pTabManager->GetNavigateButtonCount() - 1; i >= 0; i--)
  437. pTabManager->GetNavigateButton(i)->Draw(pDC);
  439. }
  440. int CXTPTabPaintManager::_GetButtonLength(int nValue, int nMin, int nMax)
  441. {
  442. nValue += m_rcButtonMargin.left +  m_rcButtonMargin.right;
  443. if (nMin > 0) nValue = max(nMin, nValue);
  444. if (nMax > 0) nValue = min(nMax, nValue);
  445. return nValue;
  446. }
  448. void CXTPTabPaintManager::StripMnemonics(CString& strClear)
  449. {
  450. CXTPDrawHelpers::StripMnemonics(strClear);
  451. }
  453. int CXTPTabPaintManager::GetPrefixTextExtent(CDC* pDC, const CString& str, UINT uFormat)
  454. {
  455. if (uFormat & DT_NOPREFIX)
  456. return pDC->GetTextExtent(str).cx;
  458. CString strClear = str;
  459. StripMnemonics(strClear);
  461. return pDC->GetTextExtent(strClear).cx;
  462. }
  464. void CXTPTabPaintManager::DrawTextPathEllipsis(CDC* pDC, const CString& strItem, CRect rcItem, UINT uFormat)
  465. {
  466. if (strItem.Find(_T('\')) != -1)
  467. {
  468. pDC->DrawText(strItem, rcItem, uFormat | DT_PATH_ELLIPSIS);
  469. return;
  470. }
  472. LPCTSTR strEllipsis = _T("...");
  473. int cxEllipsis = pDC->GetTextExtent(strEllipsis, 3).cx;
  474. int cxItem = GetPrefixTextExtent(pDC, strItem, uFormat);
  476. if (cxItem <= rcItem.Width())
  477. {
  478. pDC->DrawText(strItem, rcItem, uFormat);
  479. return;
  480. }
  481. if (rcItem.Width() <= cxEllipsis)
  482. {
  483. pDC->DrawText(strEllipsis, 3, rcItem, uFormat);
  484. return;
  485. }
  486. int nWidth = rcItem.Width() - cxEllipsis;
  488. int nResultLength = strItem.GetLength() * nWidth / cxItem;
  489. CString strResultLeft = strItem.Left(nResultLength - nResultLength / 2);
  490. CString strResultRight = strItem.Right(nResultLength / 2);
  492. while (GetPrefixTextExtent(pDC, strResultLeft, uFormat) + GetPrefixTextExtent(pDC, strResultRight, uFormat) < nWidth)
  493. {
  494. nResultLength++;
  495. strResultLeft = strItem.Left(nResultLength - nResultLength / 2);
  496. strResultRight = strItem.Right(nResultLength / 2);
  497. }
  499. while (GetPrefixTextExtent(pDC, strResultLeft, uFormat) + GetPrefixTextExtent(pDC, strResultRight, uFormat) > nWidth)
  500. {
  501. nResultLength--;
  502. strResultLeft = strItem.Left(nResultLength - nResultLength / 2);
  503. strResultRight = strItem.Right(nResultLength / 2);
  504. }
  506. pDC->DrawText(strResultLeft + strEllipsis + strResultRight, rcItem, uFormat);
  507. }
  509. void CXTPTabPaintManager::DrawFocusRect(CDC* pDC, CXTPTabManagerItem* /*pItem*/, CRect rcItem)
  510. {
  511. if (!m_bDrawFocusRect)
  512. return;
  514. rcItem.DeflateRect(3, 3, 3, 3);
  515. pDC->SetTextColor(0);
  516. pDC->SetBkColor(0xFFFFFF);
  517. pDC->DrawFocusRect(rcItem);
  518. }
  520. int CXTPTabPaintManager::DrawSingleButtonIconAndText(CDC* pDC, CXTPTabManagerItem* pItem, CRect rcItem, BOOL bDraw)
  521. {
  522. CXTPTabManager* pManager = pItem->GetTabManager();
  524. XTPTabLayoutStyle layout = pManager->GetLayout();
  526. BOOL bVertical = !pManager->IsHorizontalPosition();
  527. if (layout == xtpTabLayoutRotated) bVertical = !bVertical;
  529. CString strItem = pItem->GetCaption();
  531. CFont* pFont = m_bBoldSelected && pItem->IsSelected() && pManager->IsActive() ? GetBoldFont(bVertical) : GetFont(bVertical);
  532. CXTPFontDC fnt(pDC, pFont);
  535. CSize szIcon(m_szIcon);
  536. BOOL bDrawIcon = pManager->DrawIcon(pDC, 0, pItem, FALSE, szIcon);
  537. BOOL bDrawText = layout != xtpTabLayoutCompressed || pItem->IsSelected();
  539. int nNavigateButtonsLength = 0;
  540. if (bDrawText && pItem->GetNavigateButtons()->GetSize() > 0)
  541. {
  542. nNavigateButtonsLength = 0;
  543. for (int i = 0; i < (int)pItem->GetNavigateButtons()->GetSize(); i++)
  544. {
  545. CXTPTabManagerNavigateButton* pButton = pItem->GetNavigateButtons()->GetAt(i);
  546. if ((pButton->GetFlags() == xtpTabNavigateButtonAlways) ||
  547. ((pButton->GetFlags() == xtpTabNavigateButtonAutomatic) && pItem->IsSelected()))
  548. {
  549. CSize sz = pButton->GetSize();
  550. nNavigateButtonsLength += bVertical ? sz.cy : sz.cx;
  551. }
  552. }
  554. if (nNavigateButtonsLength > 0) nNavigateButtonsLength += 3;
  555. }
  558. if (bDraw)
  559. {
  560. if (nNavigateButtonsLength > 0)
  561. {
  562. m_pColorSet->SetTextColor(pDC, pItem);
  564. if (bVertical) rcItem.bottom -= 3; else rcItem.right -= 3;
  566. for (int i = (int)pItem->GetNavigateButtons()->GetSize() - 1; i >= 0; i--)
  567. {
  568. CXTPTabManagerNavigateButton* pButton = pItem->GetNavigateButtons()->GetAt(i);
  569. if ((pButton->GetFlags() == xtpTabNavigateButtonAlways) ||
  570. ((pButton->GetFlags() == xtpTabNavigateButtonAutomatic) && pItem->IsSelected()))
  571. {
  572. CSize szButton = pButton->GetSize();
  573. if (!bVertical)
  574. {
  575. pButton->SetRect(CRect(rcItem.right - szButton.cx,
  576. rcItem.CenterPoint().y + szButton.cy / 2 - szButton.cy, rcItem.right,
  577. rcItem.CenterPoint().y + szButton.cy / 2));
  578. rcItem.right -= szButton.cx;
  579. }
  580. else
  581. {
  582. pButton->SetRect(CRect(rcItem.CenterPoint().x - szButton.cx / 2,
  583. rcItem.bottom - szButton.cy, rcItem.CenterPoint().x - szButton.cx / 2 + szButton.cx, rcItem.bottom));
  584. rcItem.bottom -= szButton.cy;
  585. }
  586. pItem->GetNavigateButtons()->GetAt(i)->Draw(pDC);
  587. }
  588. }
  589. }
  591. m_pColorSet->SetTextColor(pDC, pItem);
  593. CRect rcFocus(rcItem);
  595. if (bVertical)
  596. {
  597. int nAvailLength = pItem->GetButtonLength() - pItem->GetContentLength();
  598. if (nAvailLength > 0)
  599. {
  600. rcItem.DeflateRect(0, nAvailLength / 2);
  601. }
  603. rcItem.top += m_rcButtonTextPadding.left + m_rcButtonMargin.left;
  604. if (pManager->GetPosition() == xtpTabPositionRight)
  605. rcItem.DeflateRect(m_rcButtonMargin.bottom, 0, m_rcButtonMargin.top, 0);
  606. else
  607. rcItem.DeflateRect(m_rcButtonMargin.top, 0, m_rcButtonMargin.bottom, 0);
  609. if (bDrawIcon)
  610. {
  611. CPoint pt(rcItem.CenterPoint().x - szIcon.cx/2, rcItem.top - 1);
  612. if (rcItem.Height() > szIcon.cy) pManager->DrawIcon(pDC, pt, pItem, TRUE, szIcon);
  613. rcItem.top += szIcon.cy + 2;
  614. }
  615. if (bDrawText && rcItem.bottom > rcItem.top + 8)
  616. {
  617. CSize szText = pDC->GetTextExtent(strItem);
  618. rcItem.left = rcItem.right - (rcItem.Width() - szText.cy - (pManager->GetPosition() == xtpTabPositionRight ? 1 : 0)) / 2;
  619. rcItem.right = rcItem.left + rcItem.Height();
  620. rcItem.bottom -= m_rcButtonMargin.right + max(0, m_rcButtonTextPadding.right - 4);
  622. if (!m_bDrawTextNoPrefix)
  623. StripMnemonics(strItem);
  625. if (m_bDrawTextPathEllipsis)
  626. {
  627. DrawTextPathEllipsis(pDC, strItem, rcItem, DT_SINGLELINE | DT_NOCLIP | DT_NOPREFIX);
  628. }
  629. else
  630. {
  631. pDC->DrawText(strItem, &rcItem, DT_SINGLELINE | DT_NOCLIP |
  632. DT_NOPREFIX | (m_bDrawTextEndEllipsis ? DT_END_ELLIPSIS : 0));
  633. }
  634. }
  636. }
  637. else
  638. {
  639. int nAvailLength = pItem->GetButtonLength() - pItem->GetContentLength();
  640. if (nAvailLength > 0)
  641. {
  642. rcItem.DeflateRect(nAvailLength / 2, 0);
  643. }
  645. rcItem.left += m_rcButtonTextPadding.left + m_rcButtonMargin.left;
  647. if (pManager->GetPosition() == xtpTabPositionBottom)
  648. rcItem.DeflateRect(0, m_rcButtonMargin.bottom, 0, m_rcButtonMargin.top);
  649. else
  650. rcItem.DeflateRect(0, m_rcButtonMargin.top, 0, m_rcButtonMargin.bottom);
  652. if (bDrawIcon)
  653. {
  654. CPoint pt(rcItem.left - 1, rcItem.CenterPoint().y - szIcon.cy/2);
  655. if (rcItem.Width() > szIcon.cx) pManager->DrawIcon(pDC, pt, pItem, TRUE, szIcon);
  656. rcItem.left += szIcon.cx + 2;
  657. }
  659. if (bDrawText && rcItem.right > rcItem.left)
  660. {
  661. rcItem.right -= m_rcButtonTextPadding.right + m_rcButtonMargin.right - (bDrawIcon ? 2 : 0);
  663. if (pItem->GetMarkupUIElement())
  664. {
  665. XTPMarkupSetDefaultFont(pItem->GetTabManager()->GetMarkupContext(), (HFONT)pFont->GetSafeHandle(), pDC->GetTextColor());
  667. CRect rcText(rcItem);
  669. if (m_nDrawTextFormat & DT_VCENTER)
  670. {
  671. CSize szText = XTPMarkupMeasureElement(pItem->GetMarkupUIElement());
  672. rcText.top = (rcText.top + rcText.bottom - szText.cy) / 2;
  673. rcText.bottom = rcText.top + szText.cy;
  674. }
  676. XTPMarkupRenderElement(pItem->GetMarkupUIElement(), pDC->GetSafeHdc(), rcText);
  677. }
  678. else if (m_bDrawTextPathEllipsis)
  679. {
  680. DrawTextPathEllipsis(pDC, strItem, rcItem, DT_SINGLELINE | m_nDrawTextFormat | (m_bDrawTextNoPrefix ? DT_NOPREFIX : 0));
  681. }
  682. else
  683. {
  684. if (m_bDrawTextHidePrefix)
  685. StripMnemonics(strItem);
  687. pDC->DrawText(strItem, rcItem, DT_SINGLELINE | m_nDrawTextFormat |
  688. (m_bDrawTextHidePrefix || m_bDrawTextNoPrefix ? DT_NOPREFIX : 0) | (m_bDrawTextEndEllipsis ? DT_END_ELLIPSIS : 0));
  689. }
  690. }
  691. }
  693. if (pItem->IsFocused())
  694. {
  695. DrawFocusRect(pDC, pItem, rcFocus);
  696. }
  697. return 0;
  698. }
  699. else
  700. {
  701. if (layout == xtpTabLayoutFixed)
  702. {
  703. return _GetButtonLength(m_nFixedTabWidth, m_nMinTabWidth, m_nMaxTabWidth);
  704. }
  706. if (layout == xtpTabLayoutCompressed)
  707. {
  708. if (!bDrawText)
  709. return _GetButtonLength(8 + (bVertical ? szIcon.cy : szIcon.cx), m_nMinTabWidth, m_nMaxTabWidth) ;
  711. CXTPFontDC fntItems(pDC, m_bBoldSelected && pManager->IsActive() ? GetBoldFont(bVertical) : GetFont(bVertical));
  713. int nLength = 0;
  715. for (int i = 0; i < pManager->GetItemCount(); i++)
  716. {
  717. CRect rcItemText(0, 0, 0, 0);
  718. pDC->DrawText(pManager->GetItem(i)->GetCaption(), rcItemText, DT_SINGLELINE | DT_CALCRECT | DT_NOCLIP | (m_bDrawTextNoPrefix ? DT_NOPREFIX : 0));
  719. nLength = max(nLength, rcItemText.Width());
  720. }
  721. return _GetButtonLength(nNavigateButtonsLength + nLength + m_rcButtonTextPadding.left + m_rcButtonTextPadding.right +
  722. (!bDrawIcon ? 0: bVertical ? szIcon.cy : szIcon.cx), m_nMinTabWidth, m_nMaxTabWidth);
  723. }
  725. CSize szText(0);
  726. if (pItem->GetMarkupUIElement())
  727. {
  728. XTPMarkupSetDefaultFont(pItem->GetTabManager()->GetMarkupContext(), (HFONT)pFont->GetSafeHandle(), pDC->GetTextColor());
  729. szText = XTPMarkupMeasureElement(pItem->GetMarkupUIElement());
  730. }
  731. else
  732. {
  733. pDC->DrawText(strItem, rcItem, DT_SINGLELINE | DT_CALCRECT | DT_NOCLIP | (m_bDrawTextNoPrefix ? DT_NOPREFIX : 0));
  734. szText = rcItem.Size();
  735. }
  737. return _GetButtonLength(nNavigateButtonsLength + szText.cx + m_rcButtonTextPadding.left + m_rcButtonTextPadding.right +
  738. (!bDrawIcon ? 0: bVertical ? szIcon.cy : szIcon.cx), m_nMinTabWidth, m_nMaxTabWidth);
  739. }
  740. }
  743. void CXTPTabPaintManager::AdjustClientRect(CXTPTabManager* pTabManager, CRect& rcClient)
  744. {
  745. if (pTabManager->IsDrawStaticFrame())
  746. CAppearanceSet::DeflateRectEx(rcClient, CRect(2, 1, 2, 2), pTabManager->GetPosition());
  748. if (pTabManager->GetItemCount() > 0)
  749. {
  750. m_pAppearanceSet->AdjustClientRect(pTabManager, rcClient);
  751. }
  752. }
  754. CRect CXTPTabPaintManager::RepositionNavigateButtons(CXTPTabManager* pTabManager, CRect rcClient)
  755. {
  756. CRect rcNavigateButtons = m_pAppearanceSet->GetHeaderRect(rcClient, pTabManager);
  758. if (pTabManager->IsHorizontalPosition())
  759. rcNavigateButtons.right -= 1;
  760. else
  761. rcNavigateButtons.bottom -= 1;
  763. for (int i = pTabManager->GetNavigateButtonCount() - 1; i >= 0; i--)
  764. pTabManager->GetNavigateButton(i)->Reposition(rcNavigateButtons);
  766. return rcNavigateButtons;
  767. }
  769. void CXTPTabPaintManager::RepositionTabControl(CXTPTabManager* pTabManager, CDC* pDC, CRect rcClient)
  770. {
  771. pTabManager->m_rcHeaderRect.SetRectEmpty();
  772. pTabManager->m_rcClient = pTabManager->m_rcControl = rcClient;
  774. pTabManager->m_pRowIndexer->CreateIndexer(1);
  776. for (int i = 0; i < pTabManager->GetItemCount(); i++)
  777. {
  778. pTabManager->GetItem(i)->m_nItemRow = 0;
  779. }
  781. m_pAppearanceSet->RepositionTabControl(pTabManager, pDC, rcClient);
  782. AdjustClientRect(pTabManager, pTabManager->m_rcClient);
  783. }
  787. BOOL CXTPTabPaintManager::_CreateMultiRowIndexerBestFit(CXTPTabManager* pTabManager, int nWidth, int nRow, int nTotalLength)
  788. {
  789. const int nRowCount = pTabManager->GetRowCount();
  790. const int nLengthPerRow = !m_bMultiRowJustified ? nWidth : min(nTotalLength / (nRowCount - nRow), nWidth);
  792. CXTPTabManager::ROW_ITEMS* pRowItems = pTabManager->m_pRowIndexer->GetRowItems();
  793. int x = 0;
  795. for (int i = pRowItems[nRow].nLastItem; i < pTabManager->GetItemCount(); i++)
  796. {
  797. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  798. int nLength = pItem->GetButtonLength();
  800. if (x + nLength > nLengthPerRow && x != 0 && nLength > 0)
  801. {
  802. if (nRow == nRowCount - 1)
  803. return FALSE;
  805. pRowItems[nRow + 1].nFirstItem = pRowItems[nRow + 1].nLastItem = i;
  807. if (_CreateMultiRowIndexerBestFit(pTabManager, nWidth, nRow + 1, nTotalLength - x))
  808. return TRUE;
  810. if (x + nLength > nWidth)
  811. return FALSE;
  812. }
  813. pRowItems[nRow].nLastItem = i;
  814. pItem->m_nItemRow = nRow;
  815. x += nLength;
  816. }
  817. return TRUE;
  818. }
  820. void CXTPTabPaintManager::CreateMultiRowIndexer(CXTPTabManager* pTabManager, CDC* pDC, int nWidth)
  821. {
  822. int x = 0;
  823. int nRowCount = 1;
  824. int i;
  825. int nTotalLength = 0;
  826. int nItemCount = pTabManager->GetItemCount();
  827. CXTPTabManagerItem* pSelectedItem = 0;
  829. for (i = 0; i < nItemCount; i++)
  830. {
  831. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  833. if (pItem->IsSelected())
  834. {
  835. pSelectedItem = pItem;
  836. }
  838. int nLength = pItem->m_nContentLength = pItem->m_nButtonLength =
  839. pItem->IsVisible() ? m_pAppearanceSet->GetButtonLength(pDC, pItem) : 0;
  841. if (x + nLength > nWidth && x != 0)
  842. {
  843. x = 0;
  844. nRowCount++;
  845. }
  846. x += nLength;
  847. nTotalLength += nLength;
  848. }
  850. CXTPTabManager::ROW_ITEMS* pRowItems = pTabManager->m_pRowIndexer->CreateIndexer(nRowCount);
  852. if (nRowCount == 1)
  853. return;
  855. pRowItems[0].nFirstItem = pRowItems[0].nLastItem = 0;
  856. VERIFY(_CreateMultiRowIndexerBestFit(pTabManager, nWidth, 0, nTotalLength));
  858. if (!m_bMultiRowFixedSelection && pSelectedItem)
  859. {
  860. int nSelectedRow = pSelectedItem->GetItemRow();
  862. CXTPTabManager::ROW_ITEMS selectedRow = pRowItems[nSelectedRow];
  863. pRowItems[nSelectedRow] = pRowItems[0];
  864. pRowItems[0] = selectedRow;
  865. }
  866. }
  868. void CXTPTabPaintManager::RepositionTabControlMultiRow(CXTPTabManager* pTabManager, CDC* pDC, CRect rcClient)
  869. {
  871. pTabManager->m_rcHeaderRect = RepositionNavigateButtons(pTabManager, rcClient);
  872. pTabManager->m_nHeaderOffset = 0;
  874. if (pTabManager->GetItemCount() == 0)
  875. return;
  877. CRect rcHeaderMargin = m_pAppearanceSet->GetHeaderMargin();
  878. int nButtonHeight = m_pAppearanceSet->GetButtonHeight(pTabManager);
  880. if (pTabManager->IsHorizontalPosition())
  881. {
  882. int nWidth = pTabManager->m_rcHeaderRect.Width() - (rcHeaderMargin.left + rcHeaderMargin.right);
  883. CreateMultiRowIndexer(pTabManager, pDC, nWidth);
  885. int nRowCount = pTabManager->GetRowCount();
  886. int nTop = 0;
  888. if (pTabManager->GetPosition() == xtpTabPositionBottom)
  889. {
  890. nTop = rcClient.bottom - (nButtonHeight * nRowCount + m_pAppearanceSet->m_nRowMargin * (nRowCount - 1))
  891. - rcHeaderMargin.top;
  892. }
  893. else
  894. {
  895. nTop = rcClient.top +  (nButtonHeight * (nRowCount - 1) + m_pAppearanceSet->m_nRowMargin * (nRowCount - 1))
  896. + rcHeaderMargin.top;
  897. }
  899. int nBottom = nTop + nButtonHeight;
  901. int nOffset = pTabManager->GetPosition() == xtpTabPositionBottom ?
  902. nButtonHeight + m_pAppearanceSet->m_nRowMargin: -(nButtonHeight + m_pAppearanceSet->m_nRowMargin);
  905. CXTPTabManager::ROW_ITEMS* pRowItems = pTabManager->m_pRowIndexer->GetRowItems();
  906. int i;
  908. BOOL bSizeToFit = nRowCount > 1 && m_bMultiRowJustified;
  910. for (int nRow = 0; nRow < nRowCount; nRow++)
  911. {
  912. int nTotalLength = 0;
  914. int nItemInRow = pRowItems[nRow].nLastItem - pRowItems[nRow].nFirstItem + 1;
  915. int nFirstItem = pRowItems[nRow].nFirstItem;
  917. if (bSizeToFit)
  918. {
  919. for (i = 0; i < nItemInRow; i++)
  920. {
  921. nTotalLength += pTabManager->GetItem(nFirstItem + i)->GetButtonLength();
  922. }
  923. }
  925. int nTotalWidth = nWidth;
  927. int x = pTabManager->m_rcHeaderRect.left + rcHeaderMargin.left;
  929. for (i = 0; i < nItemInRow; i++)
  930. {
  931. CXTPTabManagerItem* pItem = pTabManager->GetItem(nFirstItem + i);
  932. ASSERT(pItem);
  933. if (!pItem)
  934. continue;
  935. int nButtonLength = pItem->m_nButtonLength;
  937. if (bSizeToFit)
  938. {
  939. int nLength = nButtonLength + (nTotalWidth - nTotalLength) / (nItemInRow - i);
  940. nTotalWidth -= nLength;
  941. nTotalLength -= nButtonLength;
  943. pItem->m_nButtonLength = nButtonLength = nLength;
  944. }
  946. pItem->SetRect(CRect(x, nTop, x + nButtonLength, nBottom));
  947. pItem->m_nItemRow = nRow;
  950. x += nButtonLength;
  951. }
  952. nTop += nOffset;
  953. nBottom += nOffset;
  954. }
  955. }
  956. else
  957. {
  958. int nWidth = pTabManager->m_rcHeaderRect.Height() - (rcHeaderMargin.left + rcHeaderMargin.right);
  959. CreateMultiRowIndexer(pTabManager, pDC, nWidth);
  962. int nRowCount = pTabManager->GetRowCount();
  963. int nLeft = 0;
  965. if (pTabManager->GetPosition() == xtpTabPositionRight)
  966. {
  967. nLeft = rcClient.right - (nButtonHeight * nRowCount + m_pAppearanceSet->m_nRowMargin * (nRowCount - 1))
  968. - rcHeaderMargin.top;
  969. }
  970. else
  971. {
  972. nLeft = rcClient.left +  (nButtonHeight * (nRowCount - 1) + m_pAppearanceSet->m_nRowMargin * (nRowCount - 1))
  973. + rcHeaderMargin.top;
  974. }
  976. int nRight = nLeft + nButtonHeight;
  978. int nOffset = pTabManager->GetPosition() == xtpTabPositionRight ?
  979. nButtonHeight + m_pAppearanceSet->m_nRowMargin: -(nButtonHeight + m_pAppearanceSet->m_nRowMargin);
  982. CXTPTabManager::ROW_ITEMS* pRowItems = pTabManager->m_pRowIndexer->GetRowItems();
  983. int i;
  985. BOOL bSizeToFit = nRowCount > 1 && m_bMultiRowJustified;
  987. for (int nRow = 0; nRow < nRowCount; nRow++)
  988. {
  989. int nTotalLength = 0;
  991. int nItemInRow = pRowItems[nRow].nLastItem - pRowItems[nRow].nFirstItem + 1;
  992. int nFirstItem = pRowItems[nRow].nFirstItem;
  994. if (bSizeToFit)
  995. {
  996. for (i = 0; i < nItemInRow; i++)
  997. {
  998. nTotalLength += pTabManager->GetItem(nFirstItem + i)->GetButtonLength();
  999. }
  1000. }
  1002. int nTotalWidth = nWidth;
  1004. int y = pTabManager->m_rcHeaderRect.top + rcHeaderMargin.left;
  1006. for (i = 0; i < nItemInRow; i++)
  1007. {
  1008. CXTPTabManagerItem* pItem = pTabManager->GetItem(nFirstItem + i);
  1009. ASSERT(pItem);
  1010. if (!pItem)
  1011. continue;
  1012. int nButtonLength = pItem->m_nButtonLength;
  1014. if (bSizeToFit)
  1015. {
  1016. int nLength = nButtonLength + (nTotalWidth - nTotalLength) / (nItemInRow - i);
  1017. nTotalWidth -= nLength;
  1018. nTotalLength -= nButtonLength;
  1020. pItem->m_nButtonLength = nButtonLength = nLength;
  1021. }
  1023. pItem->SetRect(CRect(nLeft, y, nRight, y + nButtonLength));
  1024. pItem->m_nItemRow = nRow;
  1027. y += nButtonLength;
  1028. }
  1029. nLeft += nOffset;
  1030. nRight += nOffset;
  1031. }
  1032. }
  1033. pTabManager->m_rcHeaderRect = RepositionNavigateButtons(pTabManager, rcClient);
  1034. }
  1036. void CXTPTabPaintManager::RepositionTabControlEx(CXTPTabManager* pTabManager, CDC* pDC, CRect rcClient)
  1037. {
  1038. if (pTabManager->IsDrawStaticFrame())
  1039. {
  1040. CAppearanceSet::DeflateRectEx(rcClient, CRect(2, 1, 2, 2), pTabManager->GetPosition());
  1041. }
  1043. CAppearanceSet::DeflateRectEx(rcClient, m_rcControlMargin, pTabManager->GetPosition());
  1045. int i;
  1047. if (!m_bShowTabs)
  1048. {
  1049. pTabManager->m_rcHeaderRect.SetRectEmpty();
  1050. for (i = 0; i < pTabManager->GetItemCount(); i++)
  1051. {
  1052. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  1053. pItem->SetRect(CRect(0, 0, 0, 0));
  1054. }
  1056. for (i = pTabManager->GetNavigateButtonCount() - 1; i >= 0; i--)
  1057. pTabManager->GetNavigateButton(i)->SetRect(CRect(0, 0, 0, 0));
  1059. return;
  1060. }
  1061. if (pTabManager->GetLayout() == xtpTabLayoutMultiRow)
  1062. {
  1063. RepositionTabControlMultiRow(pTabManager, pDC, rcClient);
  1064. return;
  1065. }
  1067. for (i = 0; i < pTabManager->GetItemCount(); i++)
  1068. {
  1069. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  1071. pItem->m_nButtonLength = pItem->m_nContentLength =
  1072. pItem->IsVisible() ? m_pAppearanceSet->GetButtonLength(pDC, pItem) : 0;
  1074. if (pItem->IsVisible())
  1075. pItem->m_nButtonLength += m_nButtonExtraLength;
  1076. }
  1078. pTabManager->m_rcHeaderRect = m_pAppearanceSet->GetHeaderRect(rcClient, pTabManager);
  1080. if (pTabManager->GetItemCount() == 0)
  1081. {
  1082. RepositionNavigateButtons(pTabManager, rcClient);
  1083. return;
  1084. }
  1086. CRect rcHeaderMargin = m_pAppearanceSet->GetHeaderMargin();
  1087. int nButtonHeight = m_pAppearanceSet->GetButtonHeight(pTabManager);
  1090. if (pTabManager->IsHorizontalPosition())
  1091. {
  1092. int nTop = rcClient.top + rcHeaderMargin.top;
  1094. if (pTabManager->GetPosition() == xtpTabPositionBottom)
  1095. {
  1096. nTop = rcClient.bottom - nButtonHeight - rcHeaderMargin.top;
  1097. }
  1099. int nBottom = nTop + nButtonHeight;
  1102. if (pTabManager->GetLayout() == xtpTabLayoutSizeToFit)
  1103. {
  1104. int nWidth = rcClient.Width() - (rcHeaderMargin.right + rcHeaderMargin.left);
  1106. for (i = pTabManager->GetNavigateButtonCount() - 1; i >= 0; i--)
  1107. pTabManager->GetNavigateButton(i)->AdjustWidth(nWidth);
  1109. SizeToFit(pTabManager, nWidth);
  1110. }
  1112. pTabManager->m_rcHeaderRect = RepositionNavigateButtons(pTabManager, rcClient);
  1114. if (pTabManager->m_nHeaderOffset < 0)
  1115. {
  1116. int nLength = pTabManager->GetItemsLength();
  1117. int nNavigateButtonsWidth = pTabManager->m_rcHeaderRect.Width() - rcHeaderMargin.left - rcHeaderMargin.right;
  1119. if (nLength + pTabManager->m_nHeaderOffset < nNavigateButtonsWidth)
  1120. {
  1121. pTabManager->m_nHeaderOffset = min(0, nNavigateButtonsWidth - nLength);
  1122. pTabManager->m_rcHeaderRect = RepositionNavigateButtons(pTabManager, rcClient);
  1123. }
  1124. }
  1126. int x = pTabManager->m_rcHeaderRect.left + rcHeaderMargin.left + pTabManager->GetHeaderOffset();
  1128. if (pTabManager->GetLayout() == xtpTabLayoutRotated)
  1129. {
  1130. if (pTabManager->GetPosition() == xtpTabPositionTop)
  1131. {
  1132. nBottom = pTabManager->m_rcHeaderRect.bottom - rcHeaderMargin.bottom;
  1133. }
  1134. else
  1135. {
  1136. nTop = pTabManager->m_rcHeaderRect.top + rcHeaderMargin.bottom;
  1138. }
  1140. for (i = 0; i < pTabManager->GetItemCount(); i++)
  1141. {
  1142. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  1144. if (pTabManager->GetPosition() == xtpTabPositionTop)
  1145. {
  1146. pItem->SetRect(CRect(x, nBottom - pItem->m_nButtonLength, x + nButtonHeight, nBottom));
  1147. }
  1148. else
  1149. {
  1150. pItem->SetRect(CRect(x, nTop, x + nButtonHeight, nTop + pItem->m_nButtonLength));
  1152. }
  1153. x += nButtonHeight;
  1154. }
  1155. }
  1156. else
  1157. {
  1159. for (i = 0; i < pTabManager->GetItemCount(); i++)
  1160. {
  1161. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  1163. pItem->SetRect(CRect(x, nTop, x + pItem->m_nButtonLength, nBottom));
  1164. x += pItem->m_nButtonLength;
  1165. }
  1166. }
  1168. }
  1169. else
  1170. {
  1171. int nLeft = rcClient.left + rcHeaderMargin.top;
  1173. if (pTabManager->GetPosition() == xtpTabPositionRight)
  1174. {
  1175. nLeft = rcClient.right - nButtonHeight - rcHeaderMargin.top;
  1176. }
  1178. int nRight = nLeft + nButtonHeight;
  1180. if (pTabManager->GetLayout() == xtpTabLayoutSizeToFit)
  1181. {
  1182. int nWidth = rcClient.Height() - (rcHeaderMargin.right + rcHeaderMargin.left);
  1184. for (i = pTabManager->GetNavigateButtonCount() - 1; i >= 0; i--)
  1185. pTabManager->GetNavigateButton(i)->AdjustWidth(nWidth);
  1187. SizeToFit(pTabManager, nWidth);
  1188. }
  1190. pTabManager->m_rcHeaderRect = RepositionNavigateButtons(pTabManager, rcClient);
  1192. if (pTabManager->m_nHeaderOffset < 0)
  1193. {
  1194. int nLength = pTabManager->GetItemsLength();
  1195. int nNavigateButtonsWidth = pTabManager->m_rcHeaderRect.Height() - rcHeaderMargin.left - rcHeaderMargin.right;
  1197. if (nLength + pTabManager->m_nHeaderOffset < nNavigateButtonsWidth)
  1198. {
  1199. pTabManager->m_nHeaderOffset = min(0, nNavigateButtonsWidth - nLength);
  1200. pTabManager->m_rcHeaderRect = RepositionNavigateButtons(pTabManager, rcClient);
  1201. }
  1202. }
  1204. int y = pTabManager->m_rcHeaderRect.top + rcHeaderMargin.left + pTabManager->GetHeaderOffset();
  1206. if (pTabManager->GetLayout() == xtpTabLayoutRotated)
  1207. {
  1208. if (pTabManager->GetPosition() == xtpTabPositionLeft)
  1209. {
  1210. nRight = pTabManager->m_rcHeaderRect.right - rcHeaderMargin.bottom;
  1211. }
  1212. else
  1213. {
  1214. nLeft = pTabManager->m_rcHeaderRect.left + rcHeaderMargin.bottom;
  1216. }
  1218. for (i = 0; i < pTabManager->GetItemCount(); i++)
  1219. {
  1220. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  1222. if (pTabManager->GetPosition() == xtpTabPositionLeft)
  1223. {
  1224. pItem->SetRect(CRect(nRight - pItem->m_nButtonLength, y, nRight, y + nButtonHeight));
  1225. }
  1226. else
  1227. {
  1228. pItem->SetRect(CRect(nLeft, y, nLeft + pItem->m_nButtonLength, y + nButtonHeight));
  1230. }
  1231. y += nButtonHeight;
  1232. }
  1233. }
  1234. else
  1235. {
  1236. for (i = 0; i < pTabManager->GetItemCount(); i++)
  1237. {
  1238. CXTPTabManagerItem* pItem = pTabManager->GetItem(i);
  1240. pItem->SetRect(CRect(nLeft, y, nRight, y + pItem->m_nButtonLength));
  1241. y += pItem->m_nButtonLength;
  1242. }
  1243. }
  1244. }
  1245. }
  1247. void CXTPTabPaintManager::EnsureVisible(CXTPTabManager* pTabManager, CXTPTabManagerItem* pItem)
  1248. {
  1249. CRect rcHeader = pTabManager->m_rcHeaderRect;
  1250. CRect rcItem = pItem->GetRect();
  1252. if (rcHeader.IsRectEmpty() || rcItem.IsRectEmpty())
  1253. return;
  1255. if (GetLayout() == xtpTabLayoutSizeToFit)
  1256. return;
  1258. if (pTabManager->IsHorizontalPosition())
  1259. {
  1260. if (rcItem.left < rcHeader.left)
  1261. {
  1262. pTabManager->SetHeaderOffset(pTabManager->GetHeaderOffset() - rcItem.left + rcHeader.left + m_pAppearanceSet->GetHeaderMargin().left);
  1263. }
  1264. else if (rcItem.right > rcHeader.right)
  1265. {
  1266. pTabManager->SetHeaderOffset(pTabManager->GetHeaderOffset() - rcItem.right + rcHeader.right - 2);
  1267. }
  1269. }
  1270. else
  1271. {
  1272. if (rcItem.top < rcHeader.top)
  1273. {
  1274. pTabManager->SetHeaderOffset(pTabManager->GetHeaderOffset() - rcItem.top + rcHeader.top + m_pAppearanceSet->GetHeaderMargin().left);
  1275. }
  1276. else if (rcItem.bottom > rcHeader.bottom)
  1277. {
  1278. pTabManager->SetHeaderOffset(pTabManager->GetHeaderOffset() - rcItem.bottom + rcHeader.bottom - 2);
  1279. }
  1281. }
  1283. }
  1285. int _cdecl CXTPTabPaintManager::_SizeToFitCompare(const void *arg1, const void *arg2)
  1286. {
  1287. int nLength1 = (*((CXTPTabManagerItem**)arg1))->GetButtonLength();
  1288. int nLength2 = (*((CXTPTabManagerItem**)arg2))->GetButtonLength();
  1290. return nLength1 - nLength2;
  1291. };
  1293. void CXTPTabPaintManager::SizeToFit(CXTPTabManager* pTabManager, int nWidth)
  1294. {
  1295. int nLength = pTabManager->GetItemsLength();
  1296. int nCount = pTabManager->GetItemCount();
  1297. if (nCount == 0)
  1298. return;
  1300. if (nWidth < nLength)
  1301. {
  1302. if (nCount == 1)
  1303. pTabManager->GetItem(0)->m_nButtonLength = nWidth;
  1304. else
  1305. {
  1306. CXTPTabManagerItem** pItems = new CXTPTabManagerItem*[nCount];
  1307. if (!pItems)
  1308. return;
  1310. for (int c = 0; c < nCount; c++)
  1311. {
  1312. pItems[c] = pTabManager->GetItem(c);
  1313. }
  1315. qsort(pItems, nCount, sizeof(CXTPTabManagerItem*), _SizeToFitCompare);
  1317. for (int i = 0; i < nCount; i++)
  1318. {
  1319. int nButtonLength = pItems[i]->m_nButtonLength;
  1321. if (nButtonLength * (nCount - i) >= nWidth)
  1322. {
  1323. for (int j = i; j < nCount; j++)
  1324. {
  1325. nButtonLength = nWidth / (nCount - j);
  1326. pItems[j]->m_nButtonLength = nButtonLength;
  1327. nWidth -= nButtonLength;
  1328. }
  1330. break;
  1331. }
  1333. nWidth -= nButtonLength;
  1334. }
  1336. delete[] pItems;
  1337. }
  1338. }
  1339. }
  1341. XTPTabAppearanceStyle CXTPTabPaintManager::GetAppearance() const
  1342. {
  1343. return m_tabAppearance;
  1344. }
  1346. XTPTabColorStyle CXTPTabPaintManager::GetColor() const
  1347. {
  1348. return m_tabColor;
  1349. }
  1351. void CXTPTabPaintManager::SetPosition(XTPTabPosition tabPosition)
  1352. {
  1353. m_tabPosition = tabPosition;
  1354. OnPropertyChanged();
  1356. }
  1358. void CXTPTabPaintManager::SetLayout(XTPTabLayoutStyle tabLayout)
  1359. {
  1360. m_tabLayout = tabLayout;
  1361. OnPropertyChanged();
  1362. }
  1364. XTPTabPosition CXTPTabPaintManager::GetPosition() const
  1365. {
  1366. return m_tabPosition;
  1367. }
  1369. XTPTabLayoutStyle CXTPTabPaintManager::GetLayout() const
  1370. {
  1371. return m_tabLayout;
  1372. }
  1375. void CXTPTabPaintManager::OnPropertyChanged()
  1376. {
  1377. for (int i = 0; i < m_arrObservers.GetSize(); i++)
  1378. {
  1379. m_arrObservers[i]->OnPropertyChanged();
  1380. }
  1381. }
  1384. void CXTPTabPaintManager::AddObserver(CXTPTabManagerAtom* pObserver)
  1385. {
  1386. for (int i = 0; i < m_arrObservers.GetSize(); i++)
  1387. {
  1388. if (m_arrObservers[i] == pObserver)
  1389. return;
  1390. }
  1391. m_arrObservers.Add(pObserver);
  1392. }
  1394. //////////////////////////////////////////////////////////////////////////